dsh-mishu 0.7.2 → 0.7.4

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/ask.d.ts

@@ -29,6 +29,11 @@ export type AskRequest = {
     kind: 'mail-setup';
     preset: string;
     error?: string;
+} | {
+    kind: 'watch-error';
+    watchId: number;
+} | {
+    kind: 'watch-setup';
 };
 export interface AskOptions {
     now: number;

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

@@ -17,7 +17,7 @@ export interface BoardCard {
     /** Matter id, or series id for a series card. */
     id: number;
     target: 'matter' | 'series';
-    source: 'github' | 'mail' | 'manual';
+    source: 'github' | 'mail' | 'manual' | 'watch';
     title: string;
     /** One short line: when it is due, or why it is here. */
     meta: string;
@@ -58,6 +58,12 @@ export interface BoardData {
             state: 'never' | 'ok' | 'error';
             text: string;
         }>;
+        watch: Array<{
+            id: number;
+            label: string;
+            state: 'never' | 'ok' | 'error';
+            text: string;
+        }>;
     };
     markRead: MarkReadMode;
     columns: {
@@ -83,6 +89,11 @@ export interface BoardOptions {
         id: number;
         label: string;
     }>;
+    /** Things you watch yourself, for their status line. */
+    watches?: Array<{
+        id: number;
+        label: string;
+    }>;
 }
 export declare function buildBoard(store: MishuStore, options: BoardOptions): BoardData;
 export interface MatterDetail {

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

@@ -27,6 +27,11 @@ export interface BriefOptions {
         id: number;
         label: string;
     }>;
+    /** Things you watch yourself, for their status lines. */
+    watches?: Array<{
+        id: number;
+        label: string;
+    }>;
 }
 export declare function renderBrief(store: MishuStore, options: BriefOptions): string;
 /** Recently closed matters with reasons, so a wrong closure can be reopened. */

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

@@ -28,6 +28,10 @@ export { DEFAULT_NOTIFY, deliver, inQuiet, localClock, notifySettings, notifyTic
 export { restartPlan, scheduleRestart, type RestartPlan, type RestartStarted } from './restart.ts';
 export { FileSecrets, KeychainOrFile, MemorySecrets, secretEnvName, secretFromEnv, systemSecrets, type SecretStatus, type SecretStore } from './secrets.ts';
 export { deleteMailAccount, effectiveSettings, mailAccounts, saveMailAccount, saveSettings, type Defaults, type UserSettings } from './settings.ts';
+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/core/watch/fetch.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Reading a watched address: a feed, a JSON list, or just a page.
+ *
+ * Whatever comes back is turned into a handful of items — a title, a bit of
+ * text and a stable key — so the rest of the code never has to care whether
+ * it was RSS, Atom, JSON or plain HTML. No parser library: the shapes that
+ * matter here are small, and a wrong guess costs nothing (the page is read
+ * as text and still works).
+ */
+import { type Bi } from '../i18n.ts';
+import { type WatchSource } from './source.ts';
+export interface WatchItem {
+    /** Stable across checks: the same entry twice is the same item. */
+    key: string;
+    title: string;
+    /** The text to look for keywords in, and to quote back. */
+    text: string;
+    url: string | null;
+    /** When the source says it happened; the fetch time when it does not. */
+    at: number;
+}
+export interface WatchFetch {
+    (url: string): Promise<{
+        status: number;
+        body: string;
+        contentType: string;
+    }>;
+}
+/** The real fetch: a plain GET with a short timeout and no cookies. */
+export declare const httpFetch: WatchFetch;
+/** Markup out, whitespace collapsed. */
+export declare function plainText(markup: string): string;
+/** RSS `<item>` and Atom `<entry>` blocks, whichever the document has. */
+export declare function parseFeed(body: string, now: number, base: string): WatchItem[] | undefined;
+/**
+ * A JSON body: an array of objects, or an object with one array inside. Each
+ * element's title-like and text-like fields become an item.
+ */
+export declare function parseJson(body: string, now: number, base: string): WatchItem[] | undefined;
+/** A page with no feed: its title and text, as one item keyed by a hash of the text. */
+export declare function parsePage(body: string, now: number, base: string): WatchItem[];
+/** Whatever the address returned, as items. */
+export declare function readWatchBody(options: {
+    body: string;
+    contentType: string;
+    url: string;
+    now: number;
+}): WatchItem[];
+/** The sentence shown when a watch cannot be read. */
+export declare function describeWatchError(error: unknown, source: WatchSource): Bi;

package/lib/types/core/watch/source.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Things you watch yourself: a page, a feed or an API you care about.
+ *
+ * GitHub and mail are sources the secretary knows how to read. Everything
+ * else a person cares about — a game's patch notes, a job posting, a price,
+ * a status page — is a URL. You add it here with the words that matter to
+ * you, and the secretary looks at it now and then: when it changes, or when
+ * one of your words shows up, it becomes a card like anything else.
+ *
+ * Only where and what to look for is kept here. What was seen last lives in
+ * the notebook's key-value table, so an entry never grows without bound.
+ */
+import { type Bi } from '../i18n.ts';
+import type { MishuStore } from '../store.ts';
+export declare const WATCH_SOURCE = "watch";
+export interface WatchSource {
+    id: number;
+    /** What you call it: "补丁公告", "机票价格". */
+    label: string;
+    url: string;
+    /**
+     * Words to watch for, lower-cased. Empty: any change is worth a card.
+     * A feed is read per entry; a page is read as one text.
+     */
+    keywords: string[];
+    enabled: boolean;
+    /** Minutes between checks. */
+    intervalMinutes: number;
+}
+export interface WatchInput {
+    id?: number;
+    label?: string;
+    url?: string;
+    keywords?: string | string[];
+    enabled?: boolean;
+    intervalMinutes?: number;
+}
+export interface WatchReport {
+    at: number;
+    id: number;
+    /** Entries or text pieces the fetch turned up. */
+    items: number;
+    opened: number;
+    closed: number;
+    error?: Bi;
+}
+export declare function watchSources(store: MishuStore): WatchSource[];
+export declare function watchById(store: MishuStore, id: number): WatchSource | undefined;
+export declare function watchReportKey(id: number): string;
+/** Where one watch keeps what it has already seen. */
+export declare function watchStateKey(id: number): string;
+export declare function watchSeenKey(id: number): string;
+/** A stable id for a feed entry: its guid, else its link, else its title. */
+export declare function entryKey(entry: {
+    id?: string;
+    link?: string;
+    title?: string;
+}): string;
+/** Split what you typed into words: commas, 、, spaces or new lines all work. */
+export declare function parseKeywords(value: string | string[] | undefined): string[];
+/** Check and complete what the settings page sent; throws a sentence a person can act on. */
+export declare function resolveWatch(input: WatchInput, id: number): WatchSource;
+/** Add (no id) or update one watch. */
+export declare function saveWatch(store: MishuStore, input: WatchInput, now: number): WatchSource;
+/** Remove one watch and close whatever it still has open. */
+export declare function deleteWatch(store: MishuStore, id: number, now: number): boolean;
+/** The watches whose next check is due. */
+export declare function dueWatches(store: MishuStore, now: number): WatchSource[];

package/lib/types/core/watch/sync.d.ts

@@ -0,0 +1,51 @@
+/**
+ * One watch, one check: read the address, compare with what was seen last
+ * time, and turn anything new into a card.
+ *
+ * A card per watch, not per entry: "补丁公告 · 3 条新内容" is what you want to
+ * see, not three cards that say the same thing. Marking it done closes it;
+ * the next change opens it again with what changed.
+ *
+ * The first check only writes down what is there now — otherwise adding a
+ * feed would hand you every entry it ever published. Words you asked to watch
+ * for are the exception: those are shown right away, because you asked.
+ */
+import type { MishuStore } from '../store.ts';
+import type { Verdict } from '../github/rules.ts';
+import { type WatchFetch, type WatchItem } from './fetch.ts';
+import { type WatchReport, type WatchSource } from './source.ts';
+interface WatchState {
+    /** Keys of entries already reported, newest last. */
+    seen: string[];
+    /** Fingerprint of the whole page, for addresses that are not feeds. */
+    digest?: string;
+    /** First check done. */
+    primed: boolean;
+}
+/** Which items are new since last time, and whether the whole page changed. */
+export declare function diffItems(items: WatchItem[], state: WatchState): {
+    fresh: WatchItem[];
+    changed: boolean;
+    digest: string;
+};
+export declare function judgeWatch(options: {
+    source: WatchSource;
+    items: WatchItem[];
+    fresh: WatchItem[];
+    changed: boolean;
+    first: boolean;
+    now: number;
+}): Verdict | undefined;
+export declare function syncWatch(options: {
+    store: MishuStore;
+    source: WatchSource;
+    fetcher: WatchFetch;
+    now: number;
+}): Promise<WatchReport>;
+/** Everything about one watch the settings page shows. */
+export declare function describeWatch(store: MishuStore, source: WatchSource, lang: 'zh' | 'en'): string;
+/** The words, for showing back to you. */
+export declare function describeKeywords(source: WatchSource, lang: 'zh' | 'en'): string;
+/** Guard for the settings page: an address that cannot be a watch at all. */
+export declare function assertWatchable(source: WatchSource): void;
+export {};

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

@@ -4,8 +4,9 @@
  * what you set on the settings page on top), the keychain, and one sync of
  * every source at a time.
  */
-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 } from '../core/index.ts';
+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;
@@ -15,6 +16,8 @@ export declare class Runtime {
     readonly config: MishuConfig;
     readonly secrets: SecretStore;
     readonly fetcher: MailFetcher;
+    /** How watched addresses are read; tests swap it for a fake. */
+    watchFetch: WatchFetch;
     private readonly logger;
     private syncing;
     /** Where reminders can go; tests swap them for recorders. */
@@ -29,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;
@@ -36,6 +44,14 @@ export declare class Runtime {
     fixedLang(): Lang | undefined;
     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>;
@@ -44,6 +60,8 @@ export declare class Runtime {
     private syncGithubNow;
     /** One account; the result is also kept as its last report. */
     syncMailAccount(account: MailAccount): Promise<MailSyncReport | undefined>;
+    /** One watch; the result is also kept as its last report. */
+    syncWatchSource(source: WatchSource): Promise<WatchReport | undefined>;
     /** The channels that are turned on and work on this computer. */
     activeChannels(): Promise<Channel[]>;
     /** The board as the brief describes it. */