dsh-mishu 0.7.3 → 0.7.4

package/lib/core/index.js

@@ -32,6 +32,7 @@ export { deleteMailAccount, effectiveSettings, mailAccounts, saveMailAccount, sa
 export { deleteWatch, dueWatches, entryKey, parseKeywords, resolveWatch, saveWatch, watchById, watchReportKey, watchSources, WATCH_SOURCE, } from "./watch/source.js";
 export { describeWatchError, httpFetch, parseFeed, parseJson, parsePage, plainText, readWatchBody } from "./watch/fetch.js";
 export { describeKeywords, describeWatch, diffItems, judgeWatch, syncWatch } from "./watch/sync.js";
+export { BRIEF_MARK, BRIEF_TASK_KEY, briefPrompt, briefTiming, briefTitle, clockText, describeTiming, instantText, isBriefTask, sortTasks, taskView, } from "./schedule/tasks.js";
 export const DEFAULT_HOME = '~/.mishu';
 /** `~` and `~/…` expand to the home directory on every platform. */
 export function expandHome(path) {

package/lib/core/schedule/tasks.js

@@ -0,0 +1,149 @@
+/**
+ * DSH's own scheduled tasks, seen from the secretary's side.
+ *
+ * DSH keeps a Schedule service (`@deepseek-ai/dsh-schedule`) that delivers a
+ * prompt to a Session at a wall-clock time: the "自动化任务" page. This module
+ * only describes what that service returns — it never imports DSH, so the
+ * wording, the time formatting and the check for "is this the brief task"
+ * stay testable without a host.
+ *
+ * The one task the secretary creates itself is the daily brief: same content
+ * as the desktop notification, delivered into a conversation instead, so it
+ * reaches you when DSH is open but you are not looking at the board.
+ */
+import { bi, pick } from "../i18n.js";
+import { localClock } from "../notify.js";
+/** Where the notebook remembers the brief task it created, so it can be updated instead of duplicated. */
+export const BRIEF_TASK_KEY = 'schedule.briefTask';
+/** Marks the prompt the secretary writes, so a task edited by hand is still recognisable. */
+export const BRIEF_MARK = '[dsh-mishu brief]';
+const pad = (n) => String(n).padStart(2, '0');
+/** `HH:mm:ss.SSS` → `HH:mm`, or the raw value when it is not a clock time. */
+export function clockText(time) {
+    if (time === undefined)
+        return '';
+    const match = /^(\d{2}):(\d{2})/.exec(time);
+    return match === null ? time : `${match[1]}:${match[2]}`;
+}
+/** An RFC 3339 instant as a local day and clock time, `11-12 08:30`. */
+export function instantText(iso, timeZone, lang) {
+    if (iso === undefined)
+        return '';
+    const at = Date.parse(iso);
+    if (!Number.isFinite(at))
+        return iso;
+    let clock;
+    try {
+        clock = localClock(at, timeZone);
+    }
+    catch {
+        clock = localClock(at, '');
+    }
+    const [year, month, day] = clock.day.split('-');
+    const now = new Date();
+    const sameYear = Number(year) === now.getFullYear();
+    return `${sameYear ? '' : `${year}-`}${month}-${day} ${pad(Math.floor(clock.minutes / 60))}:${pad(clock.minutes % 60)}`;
+}
+const WEEKDAY_ZH = ['一', '二', '三', '四', '五', '六', '日'];
+const WEEKDAY_EN = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun'];
+/** The rule in words. Every branch names the unit a person set, never a cron string alone. */
+export function describeTiming(entry, lang) {
+    const zh = lang === 'zh';
+    const zone = entry.timeZone === undefined || entry.timeZone === '' ? '' : entry.timeZone;
+    switch (entry.kind) {
+        case 'after': {
+            const seconds = entry.afterSeconds ?? 0;
+            if (seconds % 3600 === 0 && seconds >= 3600)
+                return zh ? `${seconds / 3600} 小时后一次` : `once in ${seconds / 3600} h`;
+            if (seconds % 60 === 0 && seconds >= 60)
+                return zh ? `${seconds / 60} 分钟后一次` : `once in ${seconds / 60} min`;
+            return zh ? `${seconds} 秒后一次` : `once in ${seconds} s`;
+        }
+        case 'at':
+            return zh ? `只跑一次，${instantText(entry.scheduledAt, zone, lang)}` : `once, ${instantText(entry.scheduledAt, zone, lang)}`;
+        case 'every': {
+            const seconds = entry.everySeconds ?? 0;
+            if (seconds % 3600 === 0)
+                return zh ? `每 ${seconds / 3600} 小时` : `every ${seconds / 3600} h`;
+            return zh ? `每 ${Math.max(1, Math.round(seconds / 60))} 分钟` : `every ${Math.max(1, Math.round(seconds / 60))} min`;
+        }
+        case 'daily':
+            return zh ? `每天 ${clockText(entry.time)}` : `daily at ${clockText(entry.time)}`;
+        case 'weekly': {
+            const days = (entry.weekdays ?? []).slice().sort((a, b) => a - b);
+            const names = zh ? days.map(d => WEEKDAY_ZH[d - 1] ?? String(d)) : days.map(d => WEEKDAY_EN[d - 1] ?? String(d));
+            const list = zh ? names.join('、') : names.join(', ');
+            return zh ? `每${list} ${clockText(entry.time)}` : `${list} at ${clockText(entry.time)}`;
+        }
+        case 'cron':
+            return zh ? `按规则 ${entry.expression ?? ''}` : `on the rule ${entry.expression ?? ''}`;
+        case 'rrule': {
+            const first = (entry.rrule ?? '').split('\n').find(line => line.toUpperCase().startsWith('RRULE:')) ?? entry.rrule ?? '';
+            return first.replace(/^RRULE:/i, '');
+        }
+    }
+}
+/** One entry, as the settings page shows it. */
+export function taskView(entry, lang, briefTaskId) {
+    const status = entry.status === undefined || entry.status === 'inactive' ? 'ended' : entry.status;
+    const zone = entry.timeZone ?? '';
+    return {
+        id: entry.id,
+        title: entry.title,
+        when: describeTiming(entry, lang),
+        next: status === 'ended' ? null : instantText(entry.scheduledAt, zone, lang) || null,
+        status,
+        prompt: entry.prompt.replace(BRIEF_MARK, '').trim().slice(0, 400),
+        mine: entry.id === briefTaskId || entry.prompt.includes(BRIEF_MARK),
+        running: entry.executionActive === true,
+        lastDelivery: entry.lastDelivery?.at === undefined ? null : instantText(entry.lastDelivery.at, zone, lang) || null,
+    };
+}
+/** Sorted for reading: what still runs first, then what has ended. */
+export function sortTasks(tasks) {
+    const rank = (t) => (t.status === 'active' ? 0 : t.status === 'paused' ? 1 : 2);
+    return [...tasks].sort((a, b) => rank(a) - rank(b) || a.title.localeCompare(b.title));
+}
+/** The prompt the brief task carries: what the agent should do at that hour. */
+export function briefPrompt(lang) {
+    return lang === 'zh'
+        ? [
+            BRIEF_MARK,
+            '现在是小秘书的每日简报时间。',
+            '用 mishu_list 读出看板，然后用三句话说清楚：今天要处理什么（最多五件，按紧急程度），哪些快到期限，有没有哪个来源同步失败了。',
+            '不要重复卡片原文，也不要替我做事，只把需要我决定的说出来。没有要处理的事就直接说"今天没有要处理的"。',
+        ].join('\n')
+        : [
+            BRIEF_MARK,
+            'It is time for the secretary\'s daily brief.',
+            'Read the board with mishu_list, then say in three sentences: what needs me today (at most five, most urgent first), what is coming up, and whether any source failed to sync.',
+            'Do not repeat the cards verbatim and do not act for me — only surface what needs my decision. If nothing is waiting, just say "nothing needs you today".',
+        ].join('\n');
+}
+/** Title of the brief task, in the language it was created in. */
+export function briefTitle(lang) {
+    return pick(bi('小秘书 · 每日简报', 'Secretary · daily brief'), lang);
+}
+/**
+ * The daily rule for the brief, from a `HH:mm` setting and a zone. Seconds are
+ * zero so the task fires on the minute; the zone falls back to this computer's
+ * when the settings page has not picked one yet.
+ */
+export function briefTiming(time, timeZone) {
+    const match = /^(\d{2}):(\d{2})$/.exec(time.trim());
+    const clock = match === null ? '08:30' : `${match[1]}:${match[2]}`;
+    let zone = timeZone.trim();
+    if (zone === '') {
+        try {
+            zone = Intl.DateTimeFormat().resolvedOptions().timeZone ?? '';
+        }
+        catch {
+            zone = '';
+        }
+    }
+    return { time: `${clock}:00.000`, time_zone: zone === '' ? 'UTC' : zone };
+}
+/** Whether a task already is the brief for this notebook. */
+export function isBriefTask(entry, briefTaskId) {
+    return entry.id === briefTaskId || entry.prompt.includes(BRIEF_MARK);
+}

package/lib/dsh/api.js

@@ -151,6 +151,13 @@ export function apiHandlers(runtime, clock = Date.now) {
                 feishu: { configured: (await runtime.secrets.get(FEISHU_WEBHOOK).catch(() => undefined)) !== undefined },
                 last: store.get(NOTIFY_REPORT_KEY) ?? null,
             },
+            // DSH's own scheduled tasks; null when this Host has no Schedule service.
+            // A failing service must not take the rest of the settings page down.
+            schedule: runtime.schedule === undefined ? null : await runtime.schedule.view(lang).catch(() => ({
+                available: true,
+                tasks: [],
+                brief: { id: null, time: notifySettings(store).brief.time, timeZone: notifySettings(store).timeZone, armed: false, error: lang === 'zh' ? '读不到 DSH 的自动化任务' : 'could not read DSH\'s scheduled tasks' },
+            })),
             presets: MAIL_PRESETS.map(p => ({
                 id: p.id, label: p.label[lang], host: p.host, port: p.port, secure: p.secure, supported: p.supported, howTo: p.howTo[lang],
                 domains: p.domains, passwordLength: p.passwordLength ?? null,
@@ -282,6 +289,8 @@ export function apiHandlers(runtime, clock = Date.now) {
         '/notify/save': async (body) => {
             const lang = langOf(body);
             saveNotifySettings(need(lang), (body.notify ?? {}), clock());
+            // A brief that is also a scheduled task follows the time you just set.
+            await runtime.schedule?.followBrief(lang);
             return { view: await settingsView(lang) };
         },
         /** One test message through one channel, turned on or not. */
@@ -400,8 +409,41 @@ export function apiHandlers(runtime, clock = Date.now) {
                 throw new ApiError(report.error[lang]);
             return { report: report ?? null, board: board(store, lang), view: await settingsView(lang) };
         },
-        /** Whether the page's "restart DSH" button can work here, and if not, what to do instead. */
-        '/restart/info': async (body) => {
+        // ── DSH's own scheduled tasks ─────────────────────────
+        /** Hand the daily brief to DSH's Schedule: it then arrives as a conversation, not a notification. */
+        '/schedule/brief/arm': async (body) => {
+            const lang = langOf(body);
+            const bridge = runtime.schedule;
+            if (bridge === undefined)
+                throw new ApiError(lang === 'zh' ? '这个 DSH 没有自动化任务服务，简报只会用桌面通知发' : 'This DSH has no scheduled tasks service; the brief stays a desktop notification');
+            // Arm first, then read the page back: the task list and the armed flag are only right afterwards.
+            const schedule = await bridge.armBrief(lang);
+            return { view: await settingsView(lang), schedule };
+        },
+        '/schedule/brief/disarm': async (body) => {
+            const lang = langOf(body);
+            const bridge = runtime.schedule;
+            if (bridge === undefined)
+                throw new ApiError(lang === 'zh' ? '这个 DSH 没有自动化任务服务' : 'This DSH has no scheduled tasks service');
+            const schedule = await bridge.disarmBrief(lang);
+            return { view: await settingsView(lang), schedule };
+        },
+        /** Run any task now. */
+        '/schedule/run': async (body) => {
+            const lang = langOf(body);
+            const bridge = runtime.schedule;
+            if (bridge === undefined)
+                throw new ApiError(lang === 'zh' ? '这个 DSH 没有自动化任务服务' : 'This DSH has no scheduled tasks service');
+            return { schedule: await bridge.run(String(body.id ?? ''), lang) };
+        },
+        '/schedule/delete': async (body) => {
+            const lang = langOf(body);
+            const bridge = runtime.schedule;
+            if (bridge === undefined)
+                throw new ApiError(lang === 'zh' ? '这个 DSH 没有自动化任务服务' : 'This DSH has no scheduled tasks service');
+            return { schedule: await bridge.delete(String(body.id ?? ''), lang) };
+        },
+        /** Whether the page's "restart DSH" button can work here, and if not, what to do instead. */ '/restart/info': async (body) => {
             const plan = runtime.restarter.plan();
             return plan.kind === 'none' ? { supported: false, why: plan.why[langOf(body)] } : { supported: true };
         },

package/lib/dsh/plugin.js

@@ -111,6 +111,15 @@ export function apply(ctx, config, runtime = new Runtime(config, ctx.logger)) {
             }));
         }
     });
+    // DSH's own scheduled tasks ("自动化任务"). Optional: a Host without the
+    // service simply keeps the brief as a desktop notification.
+    ctx.inject(['schedule'], (scheduleCtx) => {
+        const service = scheduleCtx.schedule;
+        if (service === undefined || service === null)
+            return;
+        runtime.attachSchedule(service);
+        scheduleCtx.effect(() => () => { runtime.schedule = undefined; });
+    });
     ctx.inject(['commands'], (commandCtx) => {
         const commands = commandCtx.commands;
         commandCtx.effect(() => commands.register({

package/lib/dsh/runtime.js

@@ -4,7 +4,8 @@
  * what you set on the settings page on top), the keychain, and one sync of
  * every source at a time.
  */
-import { dayOf, detectLang, effectiveSettings, GitHubClient, ImapFetcher, mailAccounts, mailReportKey, renderBrief, buildBoard, DesktopChannel, FeishuChannel, FileSecrets, GithubDeviceLogin, KeychainOrFile, notifySettings, notifyTick, mishuPaths, resolveGithubToken, secretAccount, secretFromEnv, syncGithub, syncMail, systemSecrets, tickManual, bi, restartPlan, scheduleRestart, dueWatches, httpFetch, syncWatch, watchReportKey, watchSources, } from "../core/index.js";
+import { dayOf, detectLang, effectiveSettings, GitHubClient, ImapFetcher, mailAccounts, mailReportKey, renderBrief, buildBoard, DesktopChannel, FeishuChannel, FileSecrets, GithubDeviceLogin, KeychainOrFile, notifySettings, notifyTick, mishuPaths, resolveGithubToken, secretAccount, secretFromEnv, syncGithub, syncMail, systemSecrets, tickManual, bi, restartPlan, scheduleRestart, dueWatches, httpFetch, syncWatch, watchReportKey, watchSources, DEFAULT_NOTIFY, } from "../core/index.js";
+import { ScheduleBridge } from "./schedule.js";
 export class Runtime {
     store;
     config;
@@ -21,6 +22,11 @@ export class Runtime {
     githubLogin;
     /** How DSH restarts; tests swap it so they never restart anything. */
     restarter = { plan: () => restartPlan(), schedule: plan => scheduleRestart(plan) };
+    /**
+     * DSH's own scheduled tasks, when this Host has them. Attached by the shell
+     * once the `schedule` service shows up; absent on a Host without it.
+     */
+    schedule;
     constructor(config, logger, secrets = new KeychainOrFile(systemSecrets(), new FileSecrets(mishuPaths(config.home).secrets)), fetcher = new ImapFetcher()) {
         this.config = config;
         this.logger = logger;
@@ -49,6 +55,23 @@ export class Runtime {
     watches() {
         return this.store === undefined ? [] : watchSources(this.store);
     }
+    /**
+     * Wire in DSH's Schedule service, once. The bridge reads the brief's time
+     * from the reminder settings, so a brief moved on this page moves the task
+     * too. Called again with the same service (a service restart) keeps the
+     * bridge and hands it the new handle.
+     */
+    attachSchedule(service) {
+        if (this.schedule !== undefined) {
+            this.schedule.replace(service);
+            return this.schedule;
+        }
+        this.schedule = new ScheduleBridge(service, () => this.store, () => this.lang(), () => {
+            const settings = this.store === undefined ? DEFAULT_NOTIFY : notifySettings(this.store);
+            return { time: settings.brief.time, timeZone: settings.timeZone };
+        });
+        return this.schedule;
+    }
     brief(lang = this.lang()) {
         const store = this.store;
         if (store === undefined)

package/lib/dsh/schedule.js

@@ -0,0 +1,221 @@
+/**
+ * The bridge to DSH's own Schedule service (`@deepseek-ai/dsh-schedule`, the
+ * "自动化任务" page).
+ *
+ * Two directions, both kept small on purpose:
+ *
+ * - The daily brief can be handed to Schedule: the same text the desktop
+ *   notification carries, delivered as a turn in a conversation instead. That
+ *   is the one task the secretary creates on its own, and it is marked in its
+ *   prompt so a later visit recognises it even after you edited the title.
+ * - Every task on the Host is listed for the settings page, so what the
+ *   secretary scheduled and what you scheduled yourself sit in one place.
+ *
+ * Schedule is optional: a Host without the service simply has no bridge, and
+ * the page says so instead of offering a button that cannot work.
+ */
+import { bi, BRIEF_MARK, briefPrompt, briefTiming, briefTitle, BRIEF_TASK_KEY, isBriefTask, sortTasks, taskView } from "../core/index.js";
+import { MishuError } from "../core/i18n.js";
+/** A code the service returns instead of throwing (`schedule_not_found`, `schedule_conflict`, …). */
+const isMiss = (value) => typeof value === 'object' && value !== null && 'code' in value && typeof value.code === 'string';
+/** The service's own words, wrapped so the page shows one sentence in one language. */
+function wrap(error, _lang) {
+    const message = error instanceof Error ? error.message : String(error);
+    const code = error.code;
+    const hint = typeof code === 'string' ? `（${code}）` : '';
+    return new MishuError(bi(`DSH 的自动化任务没接受这个请求：${message}${hint}`, `DSH's scheduled tasks refused this: ${message}${hint}`));
+}
+const BRIEF_ERROR_KEY = 'schedule.briefError';
+export class ScheduleBridge {
+    service;
+    store;
+    lang;
+    /** The brief's time and zone, as the reminder settings hold them. */
+    briefClock;
+    constructor(service, store, lang, briefClock) {
+        this.service = service;
+        this.store = store;
+        this.lang = lang;
+        this.briefClock = briefClock;
+    }
+    /** A restarted service: same bridge, new handle. */
+    replace(service) {
+        this.service = service;
+    }
+    /** The page's language when it asked, else the notebook's. A task's wording is read by a person, not logged. */
+    useLang(lang) {
+        return lang ?? this.lang();
+    }
+    savedId() {
+        return this.store()?.get(BRIEF_TASK_KEY);
+    }
+    /** Every task on the Host, newest rules first, plus whether the brief is armed. */
+    async view(asked) {
+        const lang = this.useLang(asked);
+        const briefId = this.savedId();
+        let entries = [];
+        let error = null;
+        try {
+            const page = await this.service.list({ limit: 100 });
+            entries = page.items;
+        }
+        catch (problem) {
+            error = wrap(problem, lang).text[lang];
+        }
+        const store = this.store();
+        const clock = this.briefClock();
+        const timing = briefTiming(clock.time, clock.timeZone);
+        const armed = entries.some(entry => isBriefTask(entry, briefId) && (entry.status ?? 'active') === 'active');
+        return {
+            available: true,
+            tasks: sortTasks(entries.map(entry => taskView(entry, lang, briefId))),
+            brief: {
+                id: briefId ?? null,
+                time: clock.time,
+                timeZone: timing.time_zone,
+                armed,
+                error: error ?? store?.get(BRIEF_ERROR_KEY) ?? null,
+            },
+        };
+    }
+    /**
+     * Arm the brief as a daily task, or move it when the time changed. Reuses
+     * the task it made before — editing it in the automation page keeps it.
+     */
+    async armBrief(asked) {
+        const store = this.store();
+        if (store === undefined)
+            throw new MishuError(bi('小秘书的记事本没有打开', 'the notebook is not open'));
+        const lang = this.useLang(asked);
+        const clock = this.briefClock();
+        const timing = { kind: 'daily', daily: briefTiming(clock.time, clock.timeZone) };
+        const request = { title: briefTitle(lang), prompt: briefPrompt(lang), timing };
+        const existing = this.savedId();
+        try {
+            let id = existing;
+            if (id !== undefined) {
+                const current = await this.service.view({ id });
+                if (isMiss(current))
+                    id = undefined;
+                else {
+                    const updated = await this.service.edit({
+                        id,
+                        action: 'update',
+                        patch: { ...request, active: true },
+                        ...current.updatedAt === undefined ? {} : { expectedUpdatedAt: current.updatedAt },
+                    });
+                    if (isMiss(updated))
+                        id = undefined;
+                }
+            }
+            if (id === undefined) {
+                const created = await this.service.create({ ...request, target: { kind: 'new_once', create: {} } });
+                if (isMiss(created))
+                    throw new MishuError(bi(`自动化任务没有建成：${created.code}`, `the task was not created: ${created.code}`));
+                id = created.id;
+                store.set(BRIEF_TASK_KEY, id);
+            }
+            store.set(BRIEF_ERROR_KEY, null);
+            store.log(Date.now(), 'schedule-brief', { id, time: clock.time, zone: briefTiming(clock.time, clock.timeZone).time_zone });
+        }
+        catch (problem) {
+            const wrapped = problem instanceof MishuError ? problem : wrap(problem, lang);
+            store.set(BRIEF_ERROR_KEY, wrapped.text[lang]);
+            throw wrapped;
+        }
+        return this.view(lang);
+    }
+    /**
+     * Move the brief when its time changed on the settings page, and say
+     * nothing when it was never armed. Errors are kept, not thrown: this runs
+     * behind a save that has already succeeded.
+     */
+    async followBrief(asked) {
+        const store = this.store();
+        const id = this.savedId();
+        if (store === undefined || id === undefined)
+            return;
+        try {
+            const current = await this.service.view({ id });
+            if (isMiss(current)) {
+                store.set(BRIEF_TASK_KEY, null);
+                return;
+            }
+            if ((current.status ?? 'active') !== 'active')
+                return;
+            const clock = this.briefClock();
+            const timing = briefTiming(clock.time, clock.timeZone);
+            if (current.kind === 'daily' && current.time === timing.time && current.timeZone === timing.time_zone)
+                return;
+            const updated = await this.service.edit({
+                id,
+                action: 'update',
+                patch: { timing: { kind: 'daily', daily: timing } },
+                ...current.updatedAt === undefined ? {} : { expectedUpdatedAt: current.updatedAt },
+            });
+            const lang = this.useLang(asked);
+            if (isMiss(updated))
+                store.set(BRIEF_ERROR_KEY, bi(`改不动：${updated.code}`, `could not move it: ${updated.code}`)[lang]);
+            else
+                store.log(Date.now(), 'schedule-brief-moved', { id, time: clock.time });
+        }
+        catch (problem) {
+            const lang = this.useLang(asked);
+            store.set(BRIEF_ERROR_KEY, wrap(problem, lang).text[lang]);
+        }
+    }
+    /** Take the brief task off the Host; the desktop notification is unaffected. */
+    async disarmBrief(asked) {
+        const store = this.store();
+        if (store === undefined)
+            throw new MishuError(bi('小秘书的记事本没有打开', 'the notebook is not open'));
+        const lang = this.useLang(asked);
+        const id = this.savedId();
+        if (id !== undefined) {
+            try {
+                const result = await this.service.edit({ id, action: 'delete' });
+                // Already gone is the same as gone.
+                if (isMiss(result) && result.code !== 'schedule_not_found')
+                    throw new MishuError(bi(`删不掉：${result.code}`, `could not delete: ${result.code}`));
+            }
+            catch (problem) {
+                throw problem instanceof MishuError ? problem : wrap(problem, lang);
+            }
+            store.set(BRIEF_TASK_KEY, null);
+            store.log(Date.now(), 'schedule-brief-off', { id });
+        }
+        store.set(BRIEF_ERROR_KEY, null);
+        return this.view(lang);
+    }
+    /** Delete any task on the Host — the secretary only ever deletes its own, but the page lists all. */
+    async delete(id, asked) {
+        const lang = this.useLang(asked);
+        try {
+            const result = await this.service.edit({ id, action: 'delete' });
+            if (isMiss(result) && result.code === 'schedule_not_found')
+                throw new MishuError(bi('这个任务已经不在了', 'that task is already gone'));
+        }
+        catch (problem) {
+            throw problem instanceof MishuError ? problem : wrap(problem, lang);
+        }
+        if (this.savedId() === id)
+            this.store()?.set(BRIEF_TASK_KEY, null);
+        return this.view(lang);
+    }
+    /** Run a task now, without waiting for its time. */
+    async run(id, asked) {
+        const lang = this.useLang(asked);
+        try {
+            const result = await this.service.run({ id });
+            if (isMiss(result)) {
+                throw new MishuError(result.code === 'schedule_execution_pending'
+                    ? bi('这个任务正在跑，等它跑完', 'that task is already running')
+                    : bi('这个任务已经不在了', 'that task is already gone'));
+            }
+        }
+        catch (problem) {
+            throw problem instanceof MishuError ? problem : wrap(problem, lang);
+        }
+        return this.view(lang);
+    }
+}

package/lib/types/core/index.d.ts

@@ -31,6 +31,7 @@ export { deleteMailAccount, effectiveSettings, mailAccounts, saveMailAccount, sa
 export { deleteWatch, dueWatches, entryKey, parseKeywords, resolveWatch, saveWatch, watchById, watchReportKey, watchSources, WATCH_SOURCE, type WatchInput, type WatchReport, type WatchSource, } from './watch/source.ts';
 export { describeWatchError, httpFetch, parseFeed, parseJson, parsePage, plainText, readWatchBody, type WatchFetch, type WatchItem } from './watch/fetch.ts';
 export { describeKeywords, describeWatch, diffItems, judgeWatch, syncWatch } from './watch/sync.ts';
+export { BRIEF_MARK, BRIEF_TASK_KEY, briefPrompt, briefTiming, briefTitle, clockText, describeTiming, instantText, isBriefTask, sortTasks, taskView, type BriefTiming, type ScheduleEntry, type ScheduleKind, type ScheduleTaskView, } from './schedule/tasks.ts';
 export declare const DEFAULT_HOME = "~/.mishu";
 /** `~` and `~/…` expand to the home directory on every platform. */
 export declare function expandHome(path: string): string;

package/lib/types/core/schedule/tasks.d.ts

@@ -0,0 +1,89 @@
+/**
+ * DSH's own scheduled tasks, seen from the secretary's side.
+ *
+ * DSH keeps a Schedule service (`@deepseek-ai/dsh-schedule`) that delivers a
+ * prompt to a Session at a wall-clock time: the "自动化任务" page. This module
+ * only describes what that service returns — it never imports DSH, so the
+ * wording, the time formatting and the check for "is this the brief task"
+ * stay testable without a host.
+ *
+ * The one task the secretary creates itself is the daily brief: same content
+ * as the desktop notification, delivered into a conversation instead, so it
+ * reaches you when DSH is open but you are not looking at the board.
+ */
+import { type Lang } from '../i18n.ts';
+/** Where the notebook remembers the brief task it created, so it can be updated instead of duplicated. */
+export declare const BRIEF_TASK_KEY = "schedule.briefTask";
+/** Marks the prompt the secretary writes, so a task edited by hand is still recognisable. */
+export declare const BRIEF_MARK = "[dsh-mishu brief]";
+export type ScheduleKind = 'after' | 'at' | 'every' | 'daily' | 'weekly' | 'cron' | 'rrule';
+/**
+ * One task as the Schedule service hands it out: its rule fields are spread
+ * onto the entry, so which ones are present says what kind it is.
+ */
+export interface ScheduleEntry {
+    id: string;
+    kind: ScheduleKind;
+    title: string;
+    prompt: string;
+    /** Next occurrence, RFC 3339 in UTC. */
+    scheduledAt?: string;
+    afterSeconds?: number;
+    everySeconds?: number;
+    /** Local wall-clock time, `HH:mm:ss.SSS`. */
+    time?: string;
+    timeZone?: string;
+    /** ISO weekdays, 1 = Monday. */
+    weekdays?: number[];
+    expression?: string;
+    rrule?: string;
+    status?: 'active' | 'paused' | 'ended' | 'inactive';
+    createdAt?: string;
+    updatedAt?: string;
+    executionActive?: boolean;
+    lastDelivery?: {
+        at?: string;
+    };
+}
+/** One task, worded for the settings page. */
+export interface ScheduleTaskView {
+    id: string;
+    title: string;
+    /** The rule, in words: "每天 08:30" / "every 15 minutes". */
+    when: string;
+    /** Next occurrence, `11-12 08:30` in the task's own zone; null once it has ended. */
+    next: string | null;
+    status: 'active' | 'paused' | 'ended';
+    /** What the task tells the session, shortened for a tooltip. */
+    prompt: string;
+    /** Created by the secretary itself (the daily brief). */
+    mine: boolean;
+    running: boolean;
+    lastDelivery: string | null;
+}
+/** `HH:mm:ss.SSS` → `HH:mm`, or the raw value when it is not a clock time. */
+export declare function clockText(time: string | undefined): string;
+/** An RFC 3339 instant as a local day and clock time, `11-12 08:30`. */
+export declare function instantText(iso: string | undefined, timeZone: string, lang: Lang): string;
+/** The rule in words. Every branch names the unit a person set, never a cron string alone. */
+export declare function describeTiming(entry: ScheduleEntry, lang: Lang): string;
+/** One entry, as the settings page shows it. */
+export declare function taskView(entry: ScheduleEntry, lang: Lang, briefTaskId: string | undefined): ScheduleTaskView;
+/** Sorted for reading: what still runs first, then what has ended. */
+export declare function sortTasks(tasks: ScheduleTaskView[]): ScheduleTaskView[];
+/** The prompt the brief task carries: what the agent should do at that hour. */
+export declare function briefPrompt(lang: Lang): string;
+/** Title of the brief task, in the language it was created in. */
+export declare function briefTitle(lang: Lang): string;
+export interface BriefTiming {
+    time: string;
+    time_zone: string;
+}
+/**
+ * The daily rule for the brief, from a `HH:mm` setting and a zone. Seconds are
+ * zero so the task fires on the minute; the zone falls back to this computer's
+ * when the settings page has not picked one yet.
+ */
+export declare function briefTiming(time: string, timeZone: string): BriefTiming;
+/** Whether a task already is the brief for this notebook. */
+export declare function isBriefTask(entry: ScheduleEntry, briefTaskId: string | undefined): boolean;

package/lib/types/dsh/runtime.d.ts

@@ -6,6 +6,7 @@
  */
 import { GithubDeviceLogin, type Defaults, type Lang, type MailAccount, type MailFetcher, type MailSyncReport, type MishuStore, type Channel, type ChannelId, type NotifyReport, type RestartPlan, type RestartStarted, type SecretStore, type TokenResult, type WatchFetch, type WatchReport, type WatchSource } from '../core/index.ts';
 import type { MishuConfig } from './config.ts';
+import { ScheduleBridge, type ScheduleLike } from './schedule.ts';
 interface Logger {
     info(message: string): void;
     warn(message: string): void;
@@ -31,6 +32,11 @@ export declare class Runtime {
             kind: 'none';
         }>): RestartStarted;
     };
+    /**
+     * DSH's own scheduled tasks, when this Host has them. Attached by the shell
+     * once the `schedule` service shows up; absent on a Host without it.
+     */
+    schedule: ScheduleBridge | undefined;
     constructor(config: MishuConfig, logger: Logger, secrets?: SecretStore, fetcher?: MailFetcher);
     defaults(): Defaults;
     settings(): Defaults;
@@ -39,6 +45,13 @@ export declare class Runtime {
     lang(): Lang;
     accounts(): MailAccount[];
     watches(): WatchSource[];
+    /**
+     * Wire in DSH's Schedule service, once. The bridge reads the brief's time
+     * from the reminder settings, so a brief moved on this page moves the task
+     * too. Called again with the same service (a service restart) keeps the
+     * bridge and hands it the new handle.
+     */
+    attachSchedule(service: ScheduleLike): ScheduleBridge;
     brief(lang?: Lang): string;
     /** The password for an account: keychain first, then the documented environment variable. */
     mailPassword(id: number): Promise<string | undefined>;