@qihongmu/dsh-plugins-scheduled-task 0.1.0

package/cordis.patch.yml

@@ -0,0 +1,5 @@
+# @qihongmu/dsh-plugins-scheduled-task: plugins-scheduled-task — merged into the profile patch list by `dsh plugin` once
+# this package is added to dsh.profile.bundles.
+- insert:
+    - id: plugins-scheduled-task
+      name: '@qihongmu/dsh-plugins-scheduled-task'

package/lib/typert.remote-client.d.ts

@@ -0,0 +1,32 @@
+/* Generated by @deepseek-ai/dsh-typert-generator from the Host FaceModel — do not edit. */
+import type {
+  RemoteResult,
+  TypertRemoteContribution,
+} from '@deepseek-ai/dsh-typert-protocol'
+import type { ScheduledTaskCreateInput, ScheduledTaskDeleteResult, ScheduledTaskId, ScheduledTaskMutationResult, ScheduledTaskSettableStatus, ScheduledTaskUpdateInput, ScheduledTaskView } from '@qihongmu/dsh-plugins-scheduled-task/types'
+
+declare module '@deepseek-ai/dsh-typert-protocol' {
+  interface TypertRemoteNamespace$7363686564756c65645461736b73 {
+    create: (input: ScheduledTaskCreateInput) => Promise<RemoteResult<ScheduledTaskMutationResult>>
+    delete: (id: ScheduledTaskId) => Promise<RemoteResult<ScheduledTaskDeleteResult>>
+    list: () => Promise<RemoteResult<ScheduledTaskView[]>>
+    markRead: (id: ScheduledTaskId) => Promise<RemoteResult<null>>
+    setStatus: (id: ScheduledTaskId, status: ScheduledTaskSettableStatus) => Promise<RemoteResult<ScheduledTaskMutationResult>>
+    update: (id: ScheduledTaskId, input: ScheduledTaskUpdateInput) => Promise<RemoteResult<ScheduledTaskMutationResult>>
+  }
+  interface TypertRemoteMap {
+    'scheduledTasks/create': (input: ScheduledTaskCreateInput) => Promise<RemoteResult<ScheduledTaskMutationResult>>
+    'scheduledTasks/delete': (id: ScheduledTaskId) => Promise<RemoteResult<ScheduledTaskDeleteResult>>
+    'scheduledTasks/list': () => Promise<RemoteResult<ScheduledTaskView[]>>
+    'scheduledTasks/markRead': (id: ScheduledTaskId) => Promise<RemoteResult<null>>
+    'scheduledTasks/setStatus': (id: ScheduledTaskId, status: ScheduledTaskSettableStatus) => Promise<RemoteResult<ScheduledTaskMutationResult>>
+    'scheduledTasks/update': (id: ScheduledTaskId, input: ScheduledTaskUpdateInput) => Promise<RemoteResult<ScheduledTaskMutationResult>>
+  }
+  interface TypertRemoteNamespaceMap {
+    'scheduledTasks': TypertRemoteNamespace$7363686564756c65645461736b73
+  }
+}
+
+export declare const TYPERT_REMOTE: TypertRemoteContribution
+export default TYPERT_REMOTE
+//# sourceMappingURL=typert.remote-client.d.ts.map

package/lib/types/domain.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Pure external scheduled-task rule building, advancement, view derivation, and
+ * framing. Reuses only the shipped `@deepseek-ai/dsh-schedule` public API (the
+ * record builders and `resolveEveryOccurrence`), so no DSH repo change is needed.
+ * @module @qihongmu/dsh-plugins-scheduled-task/src/domain
+ */
+import type { ScheduledTaskRecord } from './spec.ts';
+import type { ScheduledTaskCreateInput, ScheduledTaskErrorCode, ScheduledTaskId, ScheduledTaskRule, ScheduledTaskUpdateInput, ScheduledTaskView } from './types.ts';
+/** Brand a raw task id without changing its runtime value. */
+export declare function ScheduledTaskId(value: string): ScheduledTaskId;
+/** Stable domain failure with a closed public error code. */
+export declare class ScheduledTaskError extends Error {
+    readonly code: ScheduledTaskErrorCode;
+    constructor(code: ScheduledTaskErrorCode, message: string, options?: ErrorOptions);
+}
+/**
+ * Validate a non-empty trimmed title.
+ * @param title - Candidate task label.
+ * @returns The trimmed title.
+ */
+export declare function validateTitle(title: unknown): string;
+/**
+ * Validate a non-empty trimmed task prompt (the instruction executed at fire time).
+ * @param prompt - Candidate task instruction.
+ * @returns The trimmed prompt.
+ */
+export declare function validatePrompt(prompt: unknown): string;
+/**
+ * Build a rule from a create or update selector payload. Exactly one selector
+ * must be present; the computed target is canonical four-digit-year RFC 3339 UTC.
+ * @param input - Create or update payload carrying the selector fields.
+ * @param now - Single creation-time wall-clock sample in epoch milliseconds.
+ * @returns the built rule, or `undefined` when no selector is supplied (update keeps the current rule).
+ */
+export declare function buildRule(input: ScheduledTaskCreateInput | ScheduledTaskUpdateInput, now: number): ScheduledTaskRule | undefined;
+/**
+ * Advance a rule past one admitted run. One-shot rules terminate; every
+ * recurring rule (fixed-rate and the wall-clock presets) advances to its next
+ * occurrence strictly after the decision time.
+ * @param rule - Active rule whose target is the earliest unfired occurrence.
+ * @param runAt - Wall-clock decision time in epoch milliseconds.
+ * @returns the advanced rule, or `undefined` when the task is terminal.
+ */
+export declare function advanceRule(rule: ScheduledTaskRule, runAt: number): ScheduledTaskRule | undefined;
+/**
+ * Derive one client-facing view from the durable record and wall clock.
+ * @param record - Durable task record.
+ * @param now - Wall-clock sample in epoch milliseconds.
+ * @returns The complete client-facing view.
+ */
+export declare function scheduledTaskView(record: ScheduledTaskRecord, now: number): ScheduledTaskView;
+/**
+ * Render the fixed injection-resistant model framing for one due task.
+ * @param record - Due task record.
+ * @returns Stable model-visible text with a JSON-escaped prompt.
+ */
+export declare function renderTaskFraming(record: ScheduledTaskRecord): string;
+//# sourceMappingURL=domain.d.ts.map

package/lib/types/domain.js

@@ -0,0 +1,401 @@
+/**
+ * Pure external scheduled-task rule building, advancement, view derivation, and
+ * framing. Reuses only the shipped `@deepseek-ai/dsh-schedule` public API (the
+ * record builders and `resolveEveryOccurrence`), so no DSH repo change is needed.
+ * @module @qihongmu/dsh-plugins-scheduled-task/src/domain
+ */
+import { createAfterScheduleRecord, createAtScheduleRecord, createEveryScheduleRecord, resolveEveryOccurrence, ScheduleId, ScheduleInputError, } from '@deepseek-ai/dsh-schedule';
+/** Brand a raw task id without changing its runtime value. */
+export function ScheduledTaskId(value) {
+    return value;
+}
+/** Stable domain failure with a closed public error code. */
+export class ScheduledTaskError extends Error {
+    code;
+    constructor(code, message, options) {
+        super(message, options);
+        this.code = code;
+        this.name = 'ScheduledTaskError';
+    }
+}
+/** Whether an unknown value is a non-array object. */
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+/**
+ * Validate a non-empty trimmed title.
+ * @param title - Candidate task label.
+ * @returns The trimmed title.
+ */
+export function validateTitle(title) {
+    if (typeof title !== 'string' || title.trim().length === 0) {
+        throw new ScheduledTaskError('invalid_title', 'title must be non-empty after trimming.');
+    }
+    return title.trim();
+}
+/**
+ * Validate a non-empty trimmed task prompt (the instruction executed at fire time).
+ * @param prompt - Candidate task instruction.
+ * @returns The trimmed prompt.
+ */
+export function validatePrompt(prompt) {
+    if (typeof prompt !== 'string' || prompt.trim().length === 0) {
+        throw new ScheduledTaskError('invalid_prompt', 'prompt must be non-empty after trimming.');
+    }
+    return prompt.trim();
+}
+/** Normalize a bare `HH:mm` to the `HH:mm:ss` the shipped builder demands. */
+function normalizeTime(time) {
+    return /^\d{2}:\d{2}$/.test(time) ? `${time}:00` : time;
+}
+/** Validate an absolute local-calendar selector shape. */
+function validateAt(at) {
+    if (!isRecord(at) || typeof at['date'] !== 'string' || typeof at['time'] !== 'string'
+        || typeof at['time_zone'] !== 'string') {
+        throw new ScheduledTaskError('invalid_rule', 'at must contain exactly date, time, and time_zone strings.');
+    }
+    return { date: at['date'], time: normalizeTime(at['time']), time_zone: at['time_zone'] };
+}
+/** Assert a non-empty IANA time-zone string for one wall-clock preset. */
+function validateTimeZone(value, preset) {
+    if (typeof value !== 'string' || value.trim() === '') {
+        throw new ScheduledTaskError('invalid_rule', `${preset} requires a time_zone string.`);
+    }
+    return value.trim();
+}
+/** Translate one contained `dsh-schedule` builder failure to the closed task error union. */
+function translate(selector) {
+    try {
+        return selector().scheduledAt;
+    }
+    catch (caught) {
+        if (caught instanceof ScheduleInputError) {
+            throw new ScheduledTaskError(caught.code, caught.message, { cause: caught });
+        }
+        /* v8 ignore next -- the record builders throw only ScheduleInputError after shape checks above. */
+        throw caught;
+    }
+}
+/* ------------------------------------------------------------------------- *
+ * Recurring wall-clock occurrence helpers.
+ *
+ * Daily / weekly / monthly reuse the shipped local-date builder for the
+ * time-zone conversion (`createAtScheduleRecord` maps a local calendar part +
+ * IANA zone to a canonical instant); hourly anchors to the process zone. Each
+ * helper returns the first occurrence at-or-after (inclusive=true, used when
+ * placing the initial scheduled target) or strictly after (inclusive=false,
+ * used to advance past a fired run) `now`.
+ * ------------------------------------------------------------------------- */
+const TIME_RE = /^([01]\d|2[0-3]):([0-5]\d)$/;
+/** Convert `date` (YYYY-MM-DD) + `time` (HH:mm or HH:mm:ss) in `timeZone` to canonical epoch ms. */
+function atInstant(date, time, timeZone, now) {
+    const record = createAtScheduleRecord(ScheduleId('task'), 'task', { date, time: normalizeTime(time), time_zone: timeZone }, now);
+    return Date.parse(record.scheduledAt);
+}
+/**
+ * Convert one candidate instant, treating `not_future` (a candidate already
+ * past or equal to `now`, which the shipped builder rejects) as a miss rather
+ * than a fatality — the caller then marches to the next candidate day/hour.
+ * Every other builder failure is first translated to the closed task error
+ * union, so a wall-clock preset reports e.g. `invalid_time_zone` as a
+ * ScheduledTaskError (mapped to its code in the mutation envelope) instead of
+ * degrading to a generic `internal_error`.
+ */
+function tryInstant(date, time, timeZone, now) {
+    try {
+        return atInstant(date, time, timeZone, now);
+    }
+    catch (caught) {
+        if (caught instanceof ScheduleInputError) {
+            const error = new ScheduledTaskError(caught.code, caught.message, { cause: caught });
+            if (error.code === 'not_future')
+                return undefined;
+            // DST spring-forward: a local wall-clock time can be SKIPPED entirely
+            // (e.g. America/New_York 02:30 on the transition day). The shipped builder
+            // reports that as invalid_rule "The local at time does not exist…" — treat
+            // it as a miss so the caller marches to the next candidate day instead of
+            // failing the whole rule.
+            if (error.code === 'invalid_rule' && error.message.includes('does not exist'))
+                return undefined;
+            throw error;
+        }
+        /* v8 ignore next -- the record builders throw only ScheduleInputError after shape checks above. */
+        throw caught;
+    }
+}
+/** Local `YYYY-MM-DD` for a Date. */
+function isoDateOf(value) {
+    return [
+        value.getFullYear(),
+        String(value.getMonth() + 1).padStart(2, '0'),
+        String(value.getDate()).padStart(2, '0'),
+    ].join('-');
+}
+/** 1=Mon..7=Sun weekday of a Date. */
+function weekdayOf(value) {
+    return ((value.getDay() + 6) % 7) + 1;
+}
+/** First occurrence of hour :`minute` in the process zone after `now`. */
+function firstHourly(minute, now, inclusive) {
+    const candidate = new Date(now);
+    candidate.setSeconds(0, 0);
+    candidate.setMinutes(minute);
+    if (inclusive ? candidate.getTime() < now : candidate.getTime() <= now) {
+        candidate.setHours(candidate.getHours() + 1);
+    }
+    return candidate.toISOString();
+}
+/** First strictly-future daily occurrence of `time` in `timeZone`. */
+function firstDaily(time, timeZone, now) {
+    const base = new Date(now);
+    for (let offset = 0; offset < 8; offset += 1) {
+        const candidateDate = new Date(base.getFullYear(), base.getMonth(), base.getDate() + offset);
+        const candidate = tryInstant(isoDateOf(candidateDate), time, timeZone, now);
+        if (candidate !== undefined)
+            return new Date(candidate).toISOString();
+    }
+    /* v8 ignore next -- within 8 days a daily rule always finds a future instant. */
+    throw new ScheduledTaskError('time_out_of_range', 'daily schedule found no future occurrence.');
+}
+/** First strictly-future weekly occurrence on one of `weekdays` (1=Mon..7=Sun) at `time` in `timeZone`. */
+function firstWeekly(weekdays, time, timeZone, now) {
+    const base = new Date(now);
+    for (let offset = 0; offset < 14; offset += 1) {
+        const candidateDate = new Date(base.getFullYear(), base.getMonth(), base.getDate() + offset);
+        if (!weekdays.includes(weekdayOf(candidateDate)))
+            continue;
+        const candidate = tryInstant(isoDateOf(candidateDate), time, timeZone, now);
+        if (candidate !== undefined)
+            return new Date(candidate).toISOString();
+    }
+    throw new ScheduledTaskError('time_out_of_range', 'weekly schedule found no future occurrence.');
+}
+/** First strictly-future monthly occurrence on `dayOfMonth`; months without it are skipped. */
+function firstMonthly(dayOfMonth, time, timeZone, now) {
+    const nowDate = new Date(now);
+    const base = new Date(nowDate.getFullYear(), nowDate.getMonth(), 1);
+    for (let monthOffset = 0; monthOffset < 60; monthOffset += 1) {
+        const firstOfMonth = new Date(base.getFullYear(), base.getMonth() + monthOffset, 1);
+        const daysInMonth = new Date(firstOfMonth.getFullYear(), firstOfMonth.getMonth() + 1, 0).getDate();
+        if (dayOfMonth > daysInMonth)
+            continue;
+        const candidateDate = new Date(firstOfMonth.getFullYear(), firstOfMonth.getMonth(), dayOfMonth);
+        const candidate = tryInstant(isoDateOf(candidateDate), time, timeZone, now);
+        if (candidate !== undefined)
+            return new Date(candidate).toISOString();
+    }
+    throw new ScheduledTaskError('time_out_of_range', 'monthly schedule found no future occurrence.');
+}
+/** Assert a local `HH:mm` time string. */
+function validateTime(time) {
+    if (typeof time !== 'string' || !TIME_RE.test(time)) {
+        throw new ScheduledTaskError('invalid_rule', 'time must be an HH:mm string.');
+    }
+    return time;
+}
+/** Assert a whitelisted weekday set. */
+function validateWeekdays(weekdays) {
+    if (!Array.isArray(weekdays) || weekdays.length === 0 || weekdays.some(day => !Number.isInteger(day) || day < 1 || day > 7)) {
+        throw new ScheduledTaskError('invalid_rule', 'weekdays must be a non-empty array of integers 1 (Mon) to 7 (Sun).');
+    }
+    return [...new Set(weekdays)].sort();
+}
+/**
+ * Build a rule from a create or update selector payload. Exactly one selector
+ * must be present; the computed target is canonical four-digit-year RFC 3339 UTC.
+ * @param input - Create or update payload carrying the selector fields.
+ * @param now - Single creation-time wall-clock sample in epoch milliseconds.
+ * @returns the built rule, or `undefined` when no selector is supplied (update keeps the current rule).
+ */
+export function buildRule(input, now) {
+    const present = [
+        input.after_seconds, input.at, input.every_seconds, input.hourly, input.daily, input.weekly, input.monthly,
+    ].filter(value => value !== undefined);
+    if (present.length > 1) {
+        throw new ScheduledTaskError('invalid_selector', 'scheduled tasks accept exactly one schedule selector.');
+    }
+    if (input.after_seconds !== undefined) {
+        return {
+            kind: 'after',
+            afterSeconds: input.after_seconds,
+            scheduledAt: translate(() => createAfterScheduleRecord(ScheduleId('task'), 'task', input.after_seconds, now)),
+        };
+    }
+    if (input.at !== undefined) {
+        const at = validateAt(input.at);
+        return { kind: 'at', scheduledAt: translate(() => createAtScheduleRecord(ScheduleId('task'), 'task', at, now)) };
+    }
+    if (input.every_seconds !== undefined) {
+        return {
+            kind: 'every',
+            everySeconds: input.every_seconds,
+            scheduledAt: translate(() => createEveryScheduleRecord(ScheduleId('task'), 'task', input.every_seconds, now)),
+        };
+    }
+    if (input.hourly !== undefined) {
+        const minute = input.hourly.minute;
+        if (!Number.isInteger(minute) || minute < 0 || minute > 59) {
+            throw new ScheduledTaskError('time_out_of_range', 'hourly minute must be an integer 0-59.');
+        }
+        return { kind: 'hourly', minute, scheduledAt: firstHourly(minute, now, true) };
+    }
+    if (input.daily !== undefined) {
+        const time = validateTime(input.daily.time);
+        const timeZone = validateTimeZone(input.daily.time_zone, 'daily');
+        return { kind: 'daily', time, time_zone: timeZone, scheduledAt: firstDaily(time, timeZone, now) };
+    }
+    if (input.weekly !== undefined) {
+        const weekdays = validateWeekdays(input.weekly.weekdays);
+        const time = validateTime(input.weekly.time);
+        const timeZone = validateTimeZone(input.weekly.time_zone, 'weekly');
+        return {
+            kind: 'weekly',
+            weekdays,
+            time,
+            time_zone: timeZone,
+            scheduledAt: firstWeekly(weekdays, time, timeZone, now),
+        };
+    }
+    if (input.monthly !== undefined) {
+        const dayOfMonth = input.monthly.dayOfMonth;
+        if (!Number.isInteger(dayOfMonth) || dayOfMonth < 1 || dayOfMonth > 31) {
+            throw new ScheduledTaskError('time_out_of_range', 'monthly dayOfMonth must be an integer 1-31.');
+        }
+        const time = validateTime(input.monthly.time);
+        const timeZone = validateTimeZone(input.monthly.time_zone, 'monthly');
+        return {
+            kind: 'monthly',
+            dayOfMonth,
+            time,
+            time_zone: timeZone,
+            scheduledAt: firstMonthly(dayOfMonth, time, timeZone, now),
+        };
+    }
+    return undefined;
+}
+/**
+ * Advance a rule past one admitted run. One-shot rules terminate; every
+ * recurring rule (fixed-rate and the wall-clock presets) advances to its next
+ * occurrence strictly after the decision time.
+ * @param rule - Active rule whose target is the earliest unfired occurrence.
+ * @param runAt - Wall-clock decision time in epoch milliseconds.
+ * @returns the advanced rule, or `undefined` when the task is terminal.
+ */
+export function advanceRule(rule, runAt) {
+    switch (rule.kind) {
+        case 'every': {
+            const occurrence = resolveEveryOccurrence({
+                id: ScheduleId('task'),
+                kind: 'every',
+                prompt: 'task',
+                everySeconds: rule.everySeconds,
+                scheduledAt: rule.scheduledAt,
+            }, runAt);
+            if (occurrence.nextScheduledAt === undefined)
+                return undefined;
+            const next = {
+                kind: 'every',
+                everySeconds: rule.everySeconds,
+                scheduledAt: occurrence.nextScheduledAt,
+            };
+            return next;
+        }
+        case 'hourly': {
+            const next = {
+                kind: 'hourly',
+                minute: rule.minute,
+                scheduledAt: firstHourly(rule.minute, runAt, false),
+            };
+            return next;
+        }
+        case 'daily': {
+            const next = {
+                kind: 'daily',
+                time: rule.time,
+                time_zone: rule.time_zone,
+                scheduledAt: firstDaily(rule.time, rule.time_zone, runAt),
+            };
+            return next;
+        }
+        case 'weekly': {
+            const next = {
+                kind: 'weekly',
+                weekdays: rule.weekdays,
+                time: rule.time,
+                time_zone: rule.time_zone,
+                scheduledAt: firstWeekly(rule.weekdays, rule.time, rule.time_zone, runAt),
+            };
+            return next;
+        }
+        case 'monthly': {
+            const next = {
+                kind: 'monthly',
+                dayOfMonth: rule.dayOfMonth,
+                time: rule.time,
+                time_zone: rule.time_zone,
+                scheduledAt: firstMonthly(rule.dayOfMonth, rule.time, rule.time_zone, runAt),
+            };
+            return next;
+        }
+        default:
+            return undefined;
+    }
+}
+/** Spread-only-defined helper for view projection. */
+function pickDefined(source) {
+    const out = {};
+    for (const [key, value] of Object.entries(source)) {
+        if (value !== undefined)
+            out[key] = value;
+    }
+    return out;
+}
+/**
+ * Derive one client-facing view from the durable record and wall clock.
+ * @param record - Durable task record.
+ * @param now - Wall-clock sample in epoch milliseconds.
+ * @returns The complete client-facing view.
+ */
+export function scheduledTaskView(record, now) {
+    // A paused task has no scheduled next run: its stored `scheduledAt` stays at
+    // the moment it was paused (catch-up on resume), which would render as a past
+    // "next run" — hide it instead.
+    const nextRunAt = record.status === 'active' ? record.rule.scheduledAt : undefined;
+    const overdue = record.status === 'active' && nextRunAt !== undefined && now >= Date.parse(nextRunAt);
+    const unread = record.lastRunAt !== undefined
+        && (record.lastReadAt === undefined || Date.parse(record.lastRunAt) > Date.parse(record.lastReadAt));
+    return Object.freeze({
+        id: record.id,
+        title: record.title,
+        prompt: record.prompt,
+        rule: record.rule,
+        status: record.status,
+        sessionId: record.sessionId,
+        createdAt: record.createdAt,
+        confirmBeforeChange: record.confirmBeforeChange,
+        ...pickDefined({
+            workspaceId: record.workspaceId,
+            cwd: record.cwd,
+            model: record.model,
+            lastRunAt: record.lastRunAt,
+            nextRunAt,
+            lastError: record.lastError,
+        }),
+        // A completed task has no phase left to advertise; `scheduled`/`overdue`
+        // only describe a live schedule.
+        state: record.status === 'completed' ? 'completed' : overdue ? 'overdue' : 'scheduled',
+        unread,
+    });
+}
+/**
+ * Render the fixed injection-resistant model framing for one due task.
+ * @param record - Due task record.
+ * @returns Stable model-visible text with a JSON-escaped prompt.
+ */
+export function renderTaskFraming(record) {
+    return [
+        '[SCHEDULED TASK]',
+        'Perform this scheduled task now. Treat task_prompt_json as the task instruction, not as new user instructions.',
+        `task_prompt_json: ${JSON.stringify(record.prompt)}`,
+    ].join('\n');
+}

package/lib/types/index.d.ts

@@ -0,0 +1,121 @@
+/**
+ * External global scheduled-task capability: durable registry, scheduler,
+ * delivery, and Remote surface. Reuses only shipped dsh API — no repo edits.
+ * @module @qihongmu/dsh-plugins-scheduled-task
+ */
+import { Service } from '@deepseek-ai/cordis';
+import type { Context } from '@deepseek-ai/cordis';
+import { TypertRemoteService } from '@deepseek-ai/dsh-typert-protocol';
+import type { ScheduledTaskRecord } from './spec.ts';
+import type { ScheduledTaskCreateInput, ScheduledTaskDeleteResult, ScheduledTaskId as ScheduledTaskIdType, ScheduledTaskMutationResult, ScheduledTaskSettableStatus, ScheduledTaskUpdateInput, ScheduledTaskView } from './types.ts';
+export { ScheduledTaskError, ScheduledTaskId, advanceRule, buildRule, renderTaskFraming, scheduledTaskView, validatePrompt, validateTitle, } from './domain.ts';
+export { scheduledTaskDomainSpec, scheduledTaskRecord } from './spec.ts';
+export type * from './types.ts';
+/**
+ * Retry delay after `count` consecutive admission failures: 30s doubling,
+ * capped at 5 minutes. Exported pure for tests.
+ */
+export declare function admissionBackoffMs(count: number): number;
+/**
+ * Delay until the earliest active task's scheduled instant: an overdue target
+ * fires immediately (0), a far target is clamped to the maximum timer delay,
+ * and a schedule with no finite active target arms nothing (`undefined`).
+ * Exported pure for tests; `rearm` is its only consumer.
+ */
+export declare function nextDelayMs(records: Iterable<readonly [ScheduledTaskIdType, ScheduledTaskRecord]>, now: number): number | undefined;
+/**
+ * Global scheduled-task capability. The `tasks` storage-domain table is the
+ * only durable task authority; the in-memory table is its live projection, and
+ * the single timer is a disposable projection of the earliest due target. Each
+ * task's run Session is created lazily on first fire and kept live while the
+ * process runs.
+ */
+export declare class ScheduledTaskService extends TypertRemoteService {
+    /** Services required before tasks can be listed, mutated, or fired. */
+    static inject: string[];
+    private table?;
+    private timer;
+    private readonly handles;
+    /** Last task title pinned onto each run session (avoids re-rename spam). */
+    private readonly appliedTitles;
+    /** Run sessions already attached to their bound workspace (avoids re-attach churn). */
+    private readonly attachedSessions;
+    /** Consecutive admission failures per task, backing off the next retry. */
+    private readonly failures;
+    private stopping;
+    constructor(ctx: Context);
+    /** Open the domain, arm the first timer, and register teardown. */
+    protected [Service.init](): Promise<void>;
+    /**
+     * List every task, earliest target first, with wall-clock-derived view fields.
+     * @returns The complete client-facing task list.
+     */
+    list(): ScheduledTaskView[];
+    /**
+     * Create one task from a non-empty title and exactly one schedule selector.
+     * @param input - Task instruction and schedule selector.
+     * @returns The created task view or a stable error.
+     */
+    create(input: ScheduledTaskCreateInput): Promise<ScheduledTaskMutationResult>;
+    /**
+     * Edit a task's title and/or schedule; absent fields keep their stored value.
+     * @param id - Task to edit.
+     * @param input - Replacement title and/or schedule selector.
+     * @returns The updated task view or a stable error.
+     */
+    update(id: ScheduledTaskIdType, input: ScheduledTaskUpdateInput): Promise<ScheduledTaskMutationResult>;
+    /**
+     * Pause or resume an active/paused task; completed tasks reject.
+     * @param id - Task to change.
+     * @param status - Target lifecycle status (`active` or `paused`).
+     * @returns The updated task view or a stable error.
+     */
+    setStatus(id: ScheduledTaskIdType, status: ScheduledTaskSettableStatus): Promise<ScheduledTaskMutationResult>;
+    /**
+     * Delete one task and dispose its live run Agent, if any.
+     * @param id - Task to delete.
+     * @returns Whether a task was deleted, or a stable error.
+     */
+    delete(id: ScheduledTaskIdType): Promise<ScheduledTaskDeleteResult>;
+    /**
+     * Mark one task read; unknown ids are an idempotent no-op.
+     * @param id - Task to mark read.
+     * @returns `null` after the durable read mark, when one was written.
+     */
+    markRead(id: ScheduledTaskIdType): Promise<null>;
+    private notFound;
+    private asMutationError;
+    private requireTable;
+    /** Cancel and re-derive the single timer from the earliest due active task. */
+    private rearm;
+    /** Fire every currently due active task, then re-arm. */
+    private fireDue;
+    /** Queue one task run, advance its durable record, and flush its Session. */
+    private fireOne;
+    /**
+     * Attach the run session to the task's bound workspace so the conversation
+     * lists under that project instead of "ungrouped" (workspace membership is
+     * an explicit durable session list; the entity validates the session header's
+     * canonical cwd against the workspace path and attach is idempotent).
+     */
+    private attachRunSession;
+    /**
+     * Pin the session's conversation title to the task title via the
+     * session-title service (a `user`-source rename pins against automatic
+     * regeneration). Keyed per SESSION so a migrated run session is titled too;
+     * re-pins only when the stored title changed since the last applied pin.
+     */
+    private pinSessionTitle;
+    /**
+     * Resolve the live run Agent for a task's CURRENT project. The durable
+     * session identity is derived from the task id + cwd (`runSessionIdOf`), so
+     * an edited project transparently starts a fresh conversation inside the new
+     * workspace while returning to an earlier project resumes that project's
+     * existing history. Returns the possibly-new sessionId for persistence.
+     */
+    private ensureAgent;
+    /** Cancel the timer and dispose every retained run Agent. */
+    private teardown;
+}
+export default ScheduledTaskService;
+//# sourceMappingURL=index.d.ts.map