dsh-later 1.2.0 → 1.3.0

package/lib/index.js

@@ -65,6 +65,19 @@ export const Config = s.object({
      * - `classic`：强制使用旧版点阵风格（10×10 fill 方块 crispEdges）。
      */
     clockIconStyle: s.union([s.const('auto'), s.const('modern'), s.const('classic')]).default('auto'),
+    /**
+     * 高级语法（**Beta**，默认开启）：`/later` 与 `/schedule` 的多次写法。
+     *
+     * 覆盖三种写法：等间隔重复 `+1h*3`、相对链式序列 `+1h+1h+0.5h`、绝对锚点序列
+     * `15:32+16:32` / `9:00+1d`。标 Beta 的理由不是"没测"（38 个单测已覆盖），而是
+     * **展开语义还没被真实使用验证过**：一次命令写 10 条任务会不会刷屏 dock、
+     * 60 秒地板与 10 条上限的尺度是否合适，都需要一段观察期。
+     *
+     * 关闭后这些写法被**明确拒绝**并提示来设置页开启——不会退回"静默建成一条乱码"
+     * 的旧行为：那是 bug，不属于可回退的功能面。残片守卫（`15:32*3`、`+1h..3h`）
+     * 与本开关无关，始终生效。
+     */
+    advancedSyntax: s.boolean().default(true),
 }).volatile();
 /**
  * 0.1.5 时代 settings namespace 注册所用的 schema。
@@ -119,7 +132,8 @@ function registerUserScheduleTools(rootCtx, toolCtx, agent, getSettings, onUserC
                 name: 'user_schedule_create',
                 // description 在每次 register 时按当前 settings 生成：
                 // 模型看到的字符上限始终与宿主实际校验一致，避免描述与实现脱节。
-                description: '为用户创建一条当前会话内的定时提醒。必须提供非空提示与恰好一个选择器：after_seconds（正整数延时秒）、at（显式偏移时间或 {date,time,time_zone} 本地时间）、every_seconds（≥300 的固定间隔秒）。time_zone 可选，缺省用会话检测时区。创建来源被标记为用户工具，GUI 面板会展示。',
+                description: '为用户创建一条当前会话内的定时提醒。必须提供非空提示与恰好一个选择器：after_seconds（正整数延时秒）、at（显式偏移时间或 {date,time,time_zone} 本地时间）、every_seconds（≥300 的固定间隔秒）。time_zone 可选，缺省用会话检测时区。创建来源被标记为用户工具，GUI 面板会展示。' +
+                    'every_seconds 是**无结束条件**的固定间隔（会一直发下去，直到用户删除）；用户说了次数上限（如「每小时提醒我一次，持续 3 次」）时不要用 every_seconds，改为**逐条调用本工具 N 次**、每次用 at 给出对应的绝对时刻（t+1h、t+2h、t+3h）。',
                 parameters: {
                     prompt: {
                         type: 'string',
@@ -127,7 +141,7 @@ function registerUserScheduleTools(rootCtx, toolCtx, agent, getSettings, onUserC
                         description: `提醒内容（trim 后非空，≤${resolveSchedulerPromptLimits(getSettings()).maxChars} 字符；超过会返回 invalid_prompt）。`,
                     },
                     after_seconds: { type: 'number', description: '正整数延时秒数。' },
-                    every_seconds: { type: 'number', description: '固定间隔秒数，至少 300。' },
+                    every_seconds: { type: 'number', description: '固定间隔秒数，至少 300；无结束条件（有次数上限请改为逐条创建 at）。' },
                     at: {
                         description: '绝对目标：显式偏移的 RFC 3339 字符串，或 {date, time, time_zone} 本地日历对象。',
                         oneOf: [
@@ -263,6 +277,8 @@ export function apply(ctx, config) {
         confirmDelivery: true,
         onUnconfirmed: 'keep',
         clockIconStyle: 'auto',
+        // Beta 功能默认开：语法已经过 38 个单测，关闭它只会把用户推向报错。
+        advancedSyntax: true,
     };
     let getSettings = () => startSettings;
     ctx.inject(['settings'], (settingsCtx) => {
@@ -300,6 +316,8 @@ export function apply(ctx, config) {
             clockIconStyle: value?.clockIconStyle === 'modern' || value?.clockIconStyle === 'classic'
                 ? value.clockIconStyle
                 : 'auto',
+            // 仅显式 false 关闭；缺失/非法一律按默认开（与 schema 的 default(true) 同源）
+            advancedSyntax: value?.advancedSyntax !== false,
         });
         // ── 轨道 1：0.2.0（settings rewrite 第二版）─────────────────────────────
         //

package/lib/ownership-store.js

@@ -26,6 +26,33 @@
 import { mkdirSync, readFileSync, renameSync, statSync, writeFileSync, existsSync, unlinkSync, readdirSync, copyFileSync, } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
+/**
+ * 校验并收窄任意来源（含磁盘 JSON）的附件块数组。
+ *
+ * sidecar 是本地文件，可能被外部改写或被旧版本写入半成品；而附件块最终会
+ * 拼进**以用户身份代发**的消息 content，故读路径必须视为不可信输入：
+ * 只放行 `{type:'image'|'file', attachment:{attachmentId: string}}` 形状的块，
+ * 其余一律丢弃（不抛错——单块损坏不应让整份 sidecar 不可读）。
+ */
+export function sanitizeAttachments(value) {
+    if (!Array.isArray(value) || value.length === 0)
+        return undefined;
+    const blocks = [];
+    for (const item of value) {
+        if (typeof item !== 'object' || item === null)
+            continue;
+        const block = item;
+        if (block.type !== 'image' && block.type !== 'file')
+            continue;
+        const ref = block.attachment;
+        if (typeof ref !== 'object' || ref === null)
+            continue;
+        if (typeof ref.attachmentId !== 'string')
+            continue;
+        blocks.push(item);
+    }
+    return blocks.length > 0 ? blocks : undefined;
+}
 /**
  * 显式状态目录覆盖（测试 / 便携场景）。
  *
@@ -140,10 +167,23 @@ function readFresh(sessionId) {
             throw new Error('unexpected shape');
         }
         // v1 → v2：补空 paused，写回时统一升到 2
+        //
+        // 附件块在**读路径**收窄（sidecar 是本地文件，视同不可信输入）：旧版本
+        // 写入的半成品或外部改写在此被滤掉，下游（代发拼 content）只见到合法块。
+        const entries = {};
+        for (const [id, entry] of Object.entries(parsed.entries)) {
+            const attachments = sanitizeAttachments(entry.attachments);
+            entries[id] = attachments === undefined ? entry : { ...entry, attachments };
+        }
+        const paused = {};
+        for (const [uid, entry] of Object.entries(parsed.paused ?? {})) {
+            const attachments = sanitizeAttachments(entry.attachments);
+            paused[uid] = attachments === undefined ? entry : { ...entry, attachments };
+        }
         const file = {
             version: 2,
-            entries: parsed.entries,
-            paused: parsed.paused ?? {},
+            entries,
+            paused,
         };
         cache.set(sessionId, { mtimeMs: stat.mtimeMs, size: stat.size, file });
         return file;
@@ -216,13 +256,15 @@ export function newTaskUid() {
     return globalThis.crypto?.randomUUID?.() ?? `uid-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
 }
 /** 记录（新增或覆盖）一条所有权；幂等。仅显式传入 `uid` 时写入稳定身份。 */
-export function recordOwnership(sessionId, id, delivery, uid, windowSeconds) {
+export function recordOwnership(sessionId, id, delivery, uid, windowSeconds, attachments) {
+    const safeAttachments = sanitizeAttachments(attachments);
     if (typeof sessionId !== 'string' || sessionId.length === 0 || typeof id !== 'string' || id.length === 0) {
         const bare = {
             delivery,
             createdAt: Date.now(),
             ...(uid !== undefined ? { uid } : {}),
             ...(typeof windowSeconds === 'number' ? { windowSeconds } : {}),
+            ...(safeAttachments !== undefined ? { attachments: safeAttachments } : {}),
         };
         return bare;
     }
@@ -230,11 +272,16 @@ export function recordOwnership(sessionId, id, delivery, uid, windowSeconds) {
     const entries = { ...file.entries };
     const nextUid = uid ?? entries[id]?.uid;
     const nextWindow = windowSeconds ?? entries[id]?.windowSeconds;
+    // 附件与 uid/window 同语义：未显式传入时保留旧条目值，保证「pause 回填 uid」
+    // 与「flush 失败回滚」等覆盖写不丢附件；显式传入（含 undefined 清空语义由
+    // 调用方用 previousEntry?.attachments 表达）以传入值为准。
+    const nextAttachments = attachments !== undefined ? safeAttachments : entries[id]?.attachments;
     const entry = {
         delivery,
         createdAt: Date.now(),
         ...(nextUid !== undefined ? { uid: nextUid } : {}),
         ...(typeof nextWindow === 'number' ? { windowSeconds: nextWindow } : {}),
+        ...(nextAttachments !== undefined ? { attachments: nextAttachments } : {}),
     };
     entries[id] = entry;
     writeThrough(sessionId, { version: 2, entries, paused: file.paused ?? {} });

package/lib/runtime.js

@@ -2,7 +2,7 @@ import { createUserMessage, boundContextSummary } from '@deepseek-ai/dsh-llm';
 import { foldScheduleEvents, renderReminderFraming, resolveEveryOccurrence, ScheduleId, } from '@deepseek-ai/dsh-schedule';
 import { renderRecurringBatchFraming as renderEveryReminderBatchFraming, scheduleMessageSource, } from './schedule-compat.js';
 import { OWNED_EVENT } from './domain.js';
-import { findScheduleIdByUid, getPaused, removePaused } from './ownership-store.js';
+import { findScheduleIdByUid, getOwnership, getPaused, removePaused } from './ownership-store.js';
 import { foldUserState } from './user-tools.js';
 import { confirmDelivery, messageIdOf } from './delivery.js';
 import { detectTimeZone, formatHhmm } from './time-utils.js';
@@ -453,9 +453,14 @@ export class UserScheduleRuntime {
         if (paused === undefined)
             return undefined;
         const asUser = paused.delivery === 'user';
+        // 附件随留档冻结（pause 时带出），代发/插话时原样拼回，与 buildMessage 同形。
+        const attachmentBlocks = paused.attachments ?? [];
         const message = asUser
             ? createUserMessage({
-                content: [{ type: 'text', text: paused.prompt }],
+                content: [
+                    { type: 'text', text: paused.prompt },
+                    ...attachmentBlocks,
+                ],
                 source: { kind: 'user' },
             })
             : createUserMessage({
@@ -494,7 +499,9 @@ export class UserScheduleRuntime {
      * 构造注入的消息，按投递形态分流：
      *  - `user`（`/later` 显式请求的延迟发送）：原样内容 + `source.kind='user'`，
      *    让 GUI 呈现为「我」发出的普通气泡（产品取舍：用户明确要求以本人身份）。
-     *    跳过 framing 防护 —— 这是「代发」语义，不是注入。
+     *    跳过 framing 防护 —— 这是「代发」语义，不是注入。随命令提交的附件
+     *    （图片/文件耐久引用，存于 sidecar）按记录顺序拼在文本块之后，
+     *    与用户自己发「文字+图」的消息形状一致。
      *  - `context`（默认）：复用 dsh-schedule 的注入防护 framing + notice 表单，
      *    保持「上下文注入」的可信审计线；多条一次性到期合并为批次 framing（P1-5），
      *    形状与 dsh-schedule 的固定间隔批次一致。
@@ -506,8 +513,13 @@ export class UserScheduleRuntime {
             // 兜底：任一条带 user 标记即按代发处理，与旧语义一致。
             const asUser = decision.delivery === 'user' || records.some((record) => delivery.get(record.id) === 'user');
             if (asUser) {
+                const content = [
+                    { type: 'text', text: records.map((record) => record.prompt).join('\n') },
+                ];
+                for (const record of records)
+                    content.push(...this.attachmentsOf(record.id));
                 return createUserMessage({
-                    content: [{ type: 'text', text: records.map((record) => record.prompt).join('\n') }],
+                    content,
                     source: { kind: 'user' },
                 });
             }
@@ -522,8 +534,13 @@ export class UserScheduleRuntime {
         const records = decision.reminders.map((reminder) => reminder.record);
         // 固定间隔批次里任一条以「代发」为准（当前入口不会产生该组合，防御性保留）
         if (records.some((record) => delivery.get(record.id) === 'user')) {
+            const content = [
+                { type: 'text', text: records.map((record) => record.prompt).join('\n') },
+            ];
+            for (const record of records)
+                content.push(...this.attachmentsOf(record.id));
             return createUserMessage({
-                content: [{ type: 'text', text: records.map((record) => record.prompt).join('\n') }],
+                content,
                 source: { kind: 'user' },
             });
         }
@@ -532,6 +549,23 @@ export class UserScheduleRuntime {
             source: scheduleMessageSource(boundContextSummary(noticeSummary(records))),
         });
     }
+    /**
+     * 读某条提醒随命令提交的附件（sidecar 权威；无会话 id / 无条目时为空）。
+     *
+     * 只在 `user` 代发路径调用——context 注入通道从未声明接受附件（见 commands.ts），
+     * 不会把图片拼进防护 framing。sidecar 读路径已做块级收窄（sanitizeAttachments）。
+     */
+    attachmentsOf(scheduleId) {
+        const sessionId = this.agent.session.header?.id;
+        if (typeof sessionId !== 'string' || sessionId.length === 0)
+            return [];
+        try {
+            return getOwnership(sessionId, scheduleId)?.attachments ?? [];
+        }
+        catch {
+            return [];
+        }
+    }
 }
 /** notice 摘要：每条 `HH:mm · 内容`，最多列 3 条，余者以计数收尾。 */
 function noticeSummary(records) {

package/lib/smart-window.js

@@ -226,9 +226,34 @@ export function epochFromLocal(date, time, timeZone) {
         day > 31) {
         return undefined;
     }
-    // 以纯 UTC 构造「当日近似 epoch」作为锚点，再用偏移校正解析真实墙钟时刻。
-    const approx = Date.UTC(year, month - 1, day, 0, 0, 0, 0);
-    return resolveWallClock(approx, timeZone, hour, minute, second);
+    // 「哪一天」必须由**请求的日历日期**决定，不能从某个探测瞬点反推：
+    // 旧实现传 `Date.UTC(y,m-1,d)`（UTC 零点）给 resolveWallClock，它再用
+    // localFieldsOf 读「当天」——在 UTC 负偏移时区（America/Los_Angeles 等）那个
+    // 瞬间读出来的是**前一天**，于是 `2026-11-01 09:00 @LA` 解成 10-31 09:00，
+    // 面板自定义日期与 `/later 明天9点` 整体错一天（正偏移 ≤ +11 的时区恰好看不出）。
+    // 这里改为直接以请求日期为判据，在候选偏移里挑字段完全吻合的最小瞬点。
+    const localEpoch = Date.UTC(year, month - 1, day, hour, minute, second, 0);
+    const offsets = new Set();
+    for (let delta = -2; delta <= 2; delta += 1) {
+        offsets.add(offsetOf(localEpoch + delta * DAY_MS, timeZone));
+    }
+    const candidates = [];
+    for (const offset of offsets) {
+        const candidate = localEpoch - offset;
+        const f = localFieldsOf(candidate, timeZone);
+        if (f.year === year &&
+            f.month === month &&
+            f.day === day &&
+            f.hour === hour &&
+            f.minute === minute &&
+            f.second === second) {
+            candidates.push(candidate);
+        }
+    }
+    // 回拨日同一墙钟出现两次 → 取较早的一次（与 dsh-schedule 的 weekly/daily 口径一致）；
+    // 前拨跳过的墙钟 → 无候选 → undefined，由调用方给出「该时刻不存在」的提示。
+    candidates.sort((a, b) => a - b);
+    return candidates[0];
 }
 /**
  * 智能模式的一站式目标构造：返回可直接作为 `at` 对象使用的本地日历字段。

package/lib/types/commands.d.ts

@@ -50,28 +50,60 @@ export type ParsedScheduleSpec = {
     ok: false;
     error: string;
 };
-/** `parseScheduleInput` 的结果：时间目标 + 剩余内容。 */
+/**
+ * `parseScheduleInput` 的结果：时间目标 + 剩余内容。
+ *
+ * `targets` 恒为 1..MAX_OCCURRENCES 个未来时刻：单条写法就是 1 个；
+ * `+1h*3` / `+1h+30m` 这类多次写法给出多个，由命令层展开成同等数量的任务。
+ * `target` 恒等于 `targets[0]`，为既有调用方保留。
+ */
 export type ParsedScheduleInput = {
     ok: true;
-    target: {
-        kind: 'after';
-        afterSeconds: number;
-    } | {
-        kind: 'at';
-        at: {
-            date: string;
-            time: string;
-            time_zone: string;
-        };
-        epoch: number;
-    };
+    target: ResolvedTarget;
+    targets: readonly ResolvedTarget[];
     content: string;
 } | {
     ok: false;
     error: string;
 };
+/** 语法开关（来自 settings.advancedSyntax）。 */
+export interface ScheduleSyntaxOptions {
+    /**
+     * 高级语法（Beta）是否可用。
+     *
+     * `undefined` 与 `true` 都按开启处理——只有显式 `false` 才关闭，
+     * 与 schema 的 `default(true)` 及旧调用方（不传第三参）的行为一致。
+     */
+    readonly advancedSyntax?: boolean;
+}
+/** 关闭高级语法时的统一提示：说清去哪儿开，而不是只说"不支持"。 */
+export declare const ADVANCED_SYNTAX_DISABLED: string;
+/** 一次命令最多展开出的任务条数（`+1h*11`、11 段序列一律拒绝）。 */
+export declare const MAX_OCCURRENCES = 10;
+/**
+ * 多次写法下相邻两次之间的最小间隔（秒）。
+ *
+ * 只约束「多次」：单条 `/later +5s` 是既有合法用法（README 演示与测试都依赖它），
+ * 不因这道地板失效。`every` 记录在宿主侧另有 ≥300s 口径；多次写法走的是
+ * 「展开成 N 条 one-shot」，不经过 `every`，所以这里自带一道 60s 防护，
+ * 免得 `+1s*10` 一行命令把 dock 刷成瀑布。
+ */
+export declare const MIN_OCCURRENCE_INTERVAL_SECONDS = 60;
+/** 目标解析结果（时间 → 具体时刻/时长的落定）。 */
+type ResolvedTarget = {
+    kind: 'after';
+    afterSeconds: number;
+} | {
+    kind: 'at';
+    at: {
+        date: string;
+        time: string;
+        time_zone: string;
+    };
+    epoch: number;
+};
 /**
- * 解析 `/schedule` 的完整输入：开头的时间表达式 + 剩余内容。
+ * 解析 `/schedule` 与 `/later` 的完整输入：开头的时间表达式 + 剩余内容。
  *
  * 支持格式（示例）：
  *  - `+30m` `+1h30m` `+90s` `+1w`
@@ -80,13 +112,22 @@ export type ParsedScheduleInput = {
  *  - `明天 15:32` `后天9点` `大后天 10:00`
  *  - `8月21日 15:32` `08-21 15:32`
  *  - `2026-08-21 15:32` `0821-1532` `20260821-1532`
+ *  - 等间隔重复：`+1h*3` `+30m×2` `两小时后x3次` → t+1h、t+2h、t+3h
+ *  - 链式序列：`+1h+1h+0.5h` → t+1h、t+2h、t+2.5h（梯度催办）
+ *
+ * 多次写法一律展开成 N 条 `after` 一次性任务（不是 1 条 `every`），理由见
+ * {@link expandOccurrences}。上限 `MAX_OCCURRENCES`，多次写法的最小间隔
+ * `MIN_OCCURRENCE_INTERVAL_SECONDS`。
  *
  * `limits` 可选：未传时回落到 `DEFAULT_MAX_PROMPT_CHARS=1000`，错误文案里
  * 的字符数与 settings 实际生效值一致。
  */
-export declare function parseScheduleInput(raw: string, now: number, timeZone: string, limits?: PromptLimits): ParsedScheduleInput;
+export declare function parseScheduleInput(raw: string, now: number, timeZone: string, limits?: PromptLimits, options?: ScheduleSyntaxOptions): ParsedScheduleInput;
 /**
- * 兼容旧签名：解析纯时间描述（不含内容）。
+ * 兼容旧签名：解析纯时间描述（不含内容），**只支持单条**。
+ *
+ * 多次/序列写法会被明确拒绝：本函数的消费方（GUI 单次通道）一次只能落一条记录，
+ * 静默取第一条等于把用户的「3 次」吃掉。
  */
 export declare function parseScheduleSpec(spec: string, now: number, timeZone: string): ParsedScheduleSpec;
 /** 命令工厂：返回三个命令定义。
@@ -100,10 +141,13 @@ export declare function userScheduleCommands(ctx: Context, getSettings?: number
     maxSchedules: number;
     allowLongPrompts?: boolean;
     maxPromptChars?: number;
+    advancedSyntax?: boolean;
 }), onUserChange?: UserChangeNotifier, onUserSteer?: UserSteerHandler): CommandDefinition[];
 /** 注册三个命令，返回统一 disposer。 */
 export declare function registerUserScheduleCommands(ctx: Context, getSettings?: number | (() => number) | (() => {
     maxSchedules: number;
     allowLongPrompts?: boolean;
     maxPromptChars?: number;
+    advancedSyntax?: boolean;
 }), onUserChange?: UserChangeNotifier, onUserSteer?: UserSteerHandler): () => void;
+export {};

package/lib/types/index.d.ts

@@ -45,6 +45,8 @@ export interface SchedulerSettings {
     readonly onUnconfirmed: UserScheduleOnUnconfirmed;
     /** 时钟图标风格（auto / modern / classic）。 */
     readonly clockIconStyle: 'auto' | 'modern' | 'classic';
+    /** 高级语法（Beta）：多次写法是否可用。默认开。 */
+    readonly advancedSyntax: boolean;
 }
 /** 插话投递方式。 */
 export type UserScheduleSteerDelivery = 'followup' | 'steer';

package/lib/types/ownership-store.d.ts

@@ -1,4 +1,23 @@
+import type { FileBlock, ImageBlock } from '@deepseek-ai/dsh-llm';
 import type { UserScheduleDelivery } from './domain.js';
+/**
+ * 随提醒一起延迟发送的附件块（宿主命令准入后的耐久引用，JSON 可序列化）。
+ *
+ * `/later` 声明 `input.attachments` 后，命令框架把 composer 附件做耐久化准入
+ * （图片→内容寻址存储，文件→staged receipt 解析），以这两种块交给 handler。
+ * 块内只持有不透明 `attachmentId` 引用（非路径、非字节），因此可以安全地
+ * 落进 sidecar JSON，到点投递时再拼回 user message 的 content。
+ */
+export type ScheduledAttachment = ImageBlock | FileBlock;
+/**
+ * 校验并收窄任意来源（含磁盘 JSON）的附件块数组。
+ *
+ * sidecar 是本地文件，可能被外部改写或被旧版本写入半成品；而附件块最终会
+ * 拼进**以用户身份代发**的消息 content，故读路径必须视为不可信输入：
+ * 只放行 `{type:'image'|'file', attachment:{attachmentId: string}}` 形状的块，
+ * 其余一律丢弃（不抛错——单块损坏不应让整份 sidecar 不可读）。
+ */
+export declare function sanitizeAttachments(value: unknown): readonly ScheduledAttachment[] | undefined;
 /** 单条所有权记录。 */
 export interface OwnedEntry {
     /** 到点注入形态（/later 为 'user'，其余 'context'）。 */
@@ -15,6 +34,14 @@ export interface OwnedEntry {
      * 若直接当窗口会从 0 重跑；此处保留原 after 间隔供 wire/进度条使用。
      */
     readonly windowSeconds?: number;
+    /**
+     * `/later` 随命令提交的附件（到点代发时拼进消息 content）。
+     *
+     * 为什么不进会话日志：`schedule/change` 荷载被 dsh-schedule 严格解码
+     * （hasExactKeys），追加字段会让整份历史拒读（见 domain.ts 的兼容性说明）；
+     * sidecar 是本插件私有存储，加字段天然向后兼容。
+     */
+    readonly attachments?: readonly ScheduledAttachment[];
 }
 /** 暂停留档（仅 kind==='after'；不进会话日志）。 */
 export interface PausedEntry {
@@ -31,6 +58,8 @@ export interface PausedEntry {
     /** 暂停前的日志 schedule id（审计/关联）。 */
     readonly lastScheduleId: string;
     readonly pausedAt: number;
+    /** 暂停时随条目冻结的附件（resume/插话投递时原样带回）。 */
+    readonly attachments?: readonly ScheduledAttachment[];
 }
 /** 读取某会话的全部所有权记录（缓存优先；返回副本语义，调用方不得变更）。 */
 export declare function allOwnership(sessionId: string): Readonly<Record<string, OwnedEntry>>;
@@ -41,7 +70,7 @@ export declare function getOwnership(sessionId: string, id: string): OwnedEntry
 /** 生成稳定插件 uid（pause/resume 跨日志 id 变更）。 */
 export declare function newTaskUid(): string;
 /** 记录（新增或覆盖）一条所有权；幂等。仅显式传入 `uid` 时写入稳定身份。 */
-export declare function recordOwnership(sessionId: string, id: string, delivery: UserScheduleDelivery, uid?: string, windowSeconds?: number): OwnedEntry;
+export declare function recordOwnership(sessionId: string, id: string, delivery: UserScheduleDelivery, uid?: string, windowSeconds?: number, attachments?: readonly ScheduledAttachment[]): OwnedEntry;
 /** 撤销一条所有权；幂等（不存在时无操作）。 */
 export declare function removeOwnership(sessionId: string, id: string): void;
 /** 按 uid 找当前仍 active 的 schedule id（缺失 undefined）。 */

package/lib/types/runtime.d.ts

@@ -158,11 +158,20 @@ export declare class UserScheduleRuntime {
      * 构造注入的消息，按投递形态分流：
      *  - `user`（`/later` 显式请求的延迟发送）：原样内容 + `source.kind='user'`，
      *    让 GUI 呈现为「我」发出的普通气泡（产品取舍：用户明确要求以本人身份）。
-     *    跳过 framing 防护 —— 这是「代发」语义，不是注入。
+     *    跳过 framing 防护 —— 这是「代发」语义，不是注入。随命令提交的附件
+     *    （图片/文件耐久引用，存于 sidecar）按记录顺序拼在文本块之后，
+     *    与用户自己发「文字+图」的消息形状一致。
      *  - `context`（默认）：复用 dsh-schedule 的注入防护 framing + notice 表单，
      *    保持「上下文注入」的可信审计线；多条一次性到期合并为批次 framing（P1-5），
      *    形状与 dsh-schedule 的固定间隔批次一致。
      */
     private buildMessage;
+    /**
+     * 读某条提醒随命令提交的附件（sidecar 权威；无会话 id / 无条目时为空）。
+     *
+     * 只在 `user` 代发路径调用——context 注入通道从未声明接受附件（见 commands.ts），
+     * 不会把图片拼进防护 framing。sidecar 读路径已做块级收窄（sanitizeAttachments）。
+     */
+    private attachmentsOf;
 }
 export {};

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

@@ -21,7 +21,7 @@ import type { Agent } from '@deepseek-ai/dsh-agent';
 import type { Session, SessionEvent } from '@deepseek-ai/dsh-session';
 import type { ScheduleRecord, ScheduleView } from '@deepseek-ai/dsh-schedule';
 import type { UserScheduleDelivery } from './domain.js';
-import type { PausedEntry } from './ownership-store.js';
+import type { PausedEntry, ScheduledAttachment } from './ownership-store.js';
 /** 单 session 用户任务上限（PRD：防滥用）。 */
 export declare const DEFAULT_MAX_SCHEDULES = 100;
 /**
@@ -195,6 +195,14 @@ export declare function runUserScheduleTransaction<T>(agent: Agent, operation: (
 export interface UserScheduleCreateOptions {
     /** 可信通道显式声明的投递形态；未提供或非 'user' 一律按安全默认 'context'。 */
     readonly trustedDelivery?: UserScheduleDelivery;
+    /**
+     * 可信通道（人类显式输入的 `/later`）随命令提交的附件块。
+     *
+     * 与 `trustedDelivery` 同一道闸门：**只**接受选项传入，原始输入载荷里的
+     * `attachments` 字段不具任何效力——模型工具与 GUI JSON 载荷永远带不进附件，
+     * 防止任何通道夹带未准入的对象拼进代发消息。
+     */
+    readonly attachments?: readonly ScheduledAttachment[];
 }
 /** `user_schedule_create` 核心实现。 */
 export declare function userScheduleCreate(input: unknown, agent: Agent, ctx: Context, maxSchedules?: number, options?: UserScheduleCreateOptions, limits?: PromptLimits): Promise<UserScheduleCreateResult>;

package/lib/user-tools.js

@@ -1,7 +1,7 @@
 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, allPaused, findPausedByScheduleId, findScheduleIdByUid, getOwnership, getPaused, newTaskUid, recordOwnership, recordPaused, removeOwnership, removePaused, } from './ownership-store.js';
+import { allOwnership, allPaused, findPausedByScheduleId, findScheduleIdByUid, getOwnership, getPaused, newTaskUid, recordOwnership, recordPaused, removeOwnership, removePaused, sanitizeAttachments, } from './ownership-store.js';
 import { detectTimeZone } from './time-utils.js';
 import { readInheritedEventCount, readOwnEvents } from './upstream-compat.js';
 /** 单 session 用户任务上限（PRD：防滥用）。 */
@@ -268,6 +268,9 @@ export async function userScheduleCreate(input, agent, ctx, maxSchedules = DEFAU
         return validated;
     // 只认可信通道显式声明的形态；输入载荷中的 delivery 字段不具任何效力。
     const trustedDelivery = options?.trustedDelivery === 'user' ? 'user' : 'context';
+    // 附件同理：仅取选项（可信通道）传入的块，并再过一次收窄（防御纵深——
+    // 命令框架的准入已保证形状，但 options 是跨模块边界，不假设上游不变式）。
+    const trustedAttachments = sanitizeAttachments(options?.attachments);
     return runUserScheduleTransaction(agent, async () => {
         const now = Date.now();
         let folded;
@@ -299,7 +302,7 @@ 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, newTaskUid(), record.kind === 'after' ? record.afterSeconds : undefined);
+        recordOwnership(sessionId, id, trustedDelivery, newTaskUid(), record.kind === 'after' ? record.afterSeconds : undefined, trustedAttachments);
         try {
             agent.session.append('schedule/change', {
                 version: 1,
@@ -487,7 +490,10 @@ export async function userScheduleEditPrompt(id, newPrompt, agent, ctx, limits =
         const sessionId = agent.session.header?.id;
         const previousEntry = getOwnership(sessionId, scheduleId);
         // 编辑 after 会重置倒计时 → 窗口等于新 afterSeconds，不沿用 resume 旧窗口
-        recordOwnership(sessionId, record.id, delivery, previousEntry?.uid, record.kind === 'after' ? record.afterSeconds : undefined);
+        recordOwnership(sessionId, record.id, delivery, previousEntry?.uid, record.kind === 'after' ? record.afterSeconds : undefined, 
+        // 附件跨「删旧建新」保留：编辑只换文案，随命令提交的图片/文件仍属于这条
+        // 提醒。新 id 无旧条目可回退，必须显式带上。
+        previousEntry?.attachments);
         try {
             agent.session.append('schedule/change', { version: 1, operation: 'delete', id: scheduleId });
             agent.session.append('schedule/change', { version: 1, operation: 'create', schedule: toChangePayload(record) });
@@ -582,6 +588,9 @@ export async function userSchedulePause(id, agent, ctx) {
             ...(windowSeconds !== undefined ? { originalAfterSeconds: windowSeconds } : {}),
             lastScheduleId: scheduleId,
             pausedAt: now,
+            // 附件随条目冻结：pause 会把日志记录删除，留档是暂停项唯一的素材来源，
+            // 不带附件会让「暂停→恢复/插话」静默丢图。
+            ...(ownership?.attachments !== undefined ? { attachments: ownership.attachments } : {}),
         };
         // sidecar 先写（投影 delete 后按 lastScheduleId 挂回 paused 列表）
         recordPaused(sessionId, pausedEntry);
@@ -651,7 +660,7 @@ export async function userScheduleResume(uid, agent, ctx, maxSchedules = DEFAULT
         // removePaused，视图会短暂同时出现「已暂停」+ 新活动行（实测重复行根因）。
         removePaused(sessionId, uid);
         // 保留原 after 窗口：日志 afterSeconds 只是 remaining，进度条需要原窗口才能接着跑
-        recordOwnership(sessionId, record.id, paused.delivery, uid, paused.originalAfterSeconds ?? paused.remainingSeconds);
+        recordOwnership(sessionId, record.id, paused.delivery, uid, paused.originalAfterSeconds ?? paused.remainingSeconds, paused.attachments);
         try {
             agent.session.append('schedule/change', {
                 version: 1,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-later",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "description": "给 DSH 加上定时发送：输入一句话，到点自动以你的身份送出，关掉网页也准时触发。定时发送 / 定时提醒 / 延迟发送。",
   "icon": "./icon.svg",
   "keywords": [
@@ -16,11 +16,11 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/WuJiaoJue/dsh-later.git"
+    "url": "git+https://github.com/dsh-plugins/dsh-later.git"
   },
-  "homepage": "https://github.com/WuJiaoJue/dsh-later",
+  "homepage": "https://github.com/dsh-plugins/dsh-later",
   "bugs": {
-    "url": "https://github.com/WuJiaoJue/dsh-later/issues"
+    "url": "https://github.com/dsh-plugins/dsh-later/issues"
   },
   "type": "module",
   "main": "lib/index.js",
@@ -73,6 +73,7 @@
     "@deepseek-ai/dsh-session-projection": "0.2.0-rc.2",
     "@deepseek-ai/dsh-settings": "0.2.0-rc.2",
     "@deepseek-ai/dsh-tools": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-client-ui-primitives": "0.2.0-rc.2",
     "@deepseek-ai/schemastery": "^3.18.4",
     "@types/node": "^22.0.0",
     "@types/react": "^19.2.18",