@qilin-agent/schedule 3.1.7 → 3.1.9

package/lib/types/types.d.ts

@@ -1,6 +1,6 @@
 /**
  * Durable and model-facing Schedule value types.
- * @module @qilin-agent/schedule
+ * @module @qilin-agent/schedule/types
  */
 import type { SessionId } from '@qilin-agent/session/types';
 import type { MessageId } from '@qilin-agent/llm/brand';
@@ -155,59 +155,34 @@ export interface LegacyEveryScheduleRecord extends Omit<EveryScheduleRecord, 'ti
     readonly title?: string;
 }
 /**
- * Frozen Session event and fold vocabulary; daily rules belong only to Host storage.
+ * Frozen historical Session-event record types, independent of Host task storage.
  *
  * A version-1 event written before titles existed persists no `title` member, so
- * `after`, `at`, and `every` decode without one and stay readable. The Host task
- * record requires the member and never persists a record without it.
+ * `after`, `at`, and `every` retain that absence. These events never become Host
+ * tasks; every Host task record requires a title.
  */
 export type LegacyScheduleRecord = LegacyAfterScheduleRecord | LegacyAtScheduleRecord | LegacyEveryScheduleRecord;
 /** Recurring Host task variants. */
-export type RecurringScheduleRecord = EveryScheduleRecord | DailyScheduleRecord | WeeklyScheduleRecord | CronScheduleRecord;
-/** Reminder rule and target, stored with its original Session binding. */
-export type ScheduleRecord = OneShotScheduleRecord | RecurringScheduleRecord;
-/** Durable Session inbox delivery acknowledgment, not model execution completion. */
-export interface ScheduleDeliveryReceipt {
-    /** Canonical UTC target of the delivered occurrence. */
-    readonly scheduledAt: string;
-    /** Canonical UTC time sampled after Session persistence acknowledged delivery. */
-    readonly deliveredAt: string;
-    /** Identity of the delivered message, shared by tasks in one recurring batch. */
-    readonly messageId: MessageId;
-}
-/** Saved inbox delivery with its immutable sent prompt when recorded by this Host. */
-export interface ScheduleDeliveryRecord extends ScheduleDeliveryReceipt {
-    /** Prompt sent for this occurrence; unavailable for legacy receipts. */
-    readonly prompt?: string;
-}
-/** Browser-safe retained reminder with its original Session binding. */
-export type ScheduleCatalogEntry = ScheduleRecord & {
-    /** Session receiving this reminder when it becomes due. */
-    readonly sessionId: SessionId;
-    /** Inactive reminders remain visible but never schedule another delivery. */
-    readonly status: 'active' | 'inactive';
-    /** Most recent durably acknowledged inbox delivery, when available. */
-    readonly lastDelivery?: ScheduleDeliveryReceipt;
-};
-/** Creates one durable reminder record. */
+export type RecurringScheduleRecord = EveryScheduleRecord | DailyScheduleRecord | WeeklyScheduleRecord | CronScheduleRecord | RRuleScheduleRecord;
+/** Historical Session-local reminder creation. */
 export interface ScheduleCreateChange {
     readonly version: 1;
     readonly operation: 'create';
     readonly schedule: LegacyScheduleRecord;
 }
-/** Deletes one currently active reminder. */
+/** Historical Session-local reminder deletion. */
 export interface ScheduleDeleteChange {
     readonly version: 1;
     readonly operation: 'delete';
     readonly id: ScheduleId;
 }
-/** Records that one active one-shot reminder entered the durable dispatch history. */
+/** Historical one-shot reminder dispatch. */
 export interface OneShotScheduleDispatchChange {
     readonly version: 1;
     readonly operation: 'dispatch';
     readonly id: ScheduleId;
 }
-/** Records one fixed-rate decision and advances directly past missed occurrences. */
+/** Historical fixed-rate reminder dispatch. */
 export interface EveryScheduleDispatchChange {
     readonly version: 1;
     readonly operation: 'dispatch';
@@ -215,21 +190,10 @@ export interface EveryScheduleDispatchChange {
     /** Wall-clock decision time used to select the latest due occurrence. */
     readonly acceptedAt: string;
 }
-/** Durable dispatch shapes supported by the current rule set. */
+/** Frozen dispatch variants in historical Session logs. */
 export type ScheduleDispatchChange = OneShotScheduleDispatchChange | EveryScheduleDispatchChange;
-/** Strict version-1 durable Schedule mutation union. */
+/** Frozen version-1 Schedule mutation union retained in Session event types. */
 export type ScheduleChange = ScheduleCreateChange | ScheduleDeleteChange | ScheduleDispatchChange;
-/** Current delivery timing derived from the durable record and wall clock. */
-export type ScheduleState = 'scheduled' | 'overdue';
-/** Host-driven delivery resumes the original Session when needed. */
-export type ScheduleDeliveryMode = 'host';
-/** Complete model-facing view of one active reminder. */
-export type ScheduleView = ScheduleRecord & {
-    /** Whether the target remains in the future. */
-    readonly state: ScheduleState;
-    /** Reminder delivery never leaves the owning session. */
-    readonly deliveryMode: ScheduleDeliveryMode;
-};
 /** Stable error returned for an empty, over-long, or untrimmed reminder prompt or title. */
 export interface InvalidPromptError {
     readonly code: 'invalid_prompt';
@@ -260,28 +224,26 @@ export interface TimeOutOfRangeError {
     readonly code: 'time_out_of_range';
     readonly message: string;
 }
-/** Stable error returned when a fixed-rate rule runs more often than supported. */
+/** Stable error returned when a fixed-rate or RRULE rule runs more often than supported. */
 export interface FrequencyTooHighError {
     readonly code: 'frequency_too_high';
     readonly message: string;
 }
-/** Stable fallback that does not disclose an internal exception. */
-export interface InternalScheduleError {
-    readonly code: 'internal_error';
-    readonly message: string;
-}
 /** Stable error returned when the target Session belongs to subagent routing, which never receives reminder delivery. */
 export interface SubagentSessionError {
     readonly code: 'subagent_session';
     readonly message: string;
 }
-/** v1 Schedule management error union; new codes join as additional members. */
+/** Stable fallback that does not disclose an internal exception. */
+export interface InternalScheduleError {
+    readonly code: 'internal_error';
+    readonly message: string;
+}
+/** Schedule management error union. */
 export type ScheduleToolError = InvalidPromptError | InvalidSelectorError | InvalidRuleError | InvalidTimeZoneError | NotFutureError | TimeOutOfRangeError | FrequencyTooHighError | SubagentSessionError | InternalScheduleError;
-/** Canonical `schedule_create` value. */
-export type ScheduleCreateValue = ScheduleView | ScheduleToolError;
-/** Canonical `schedule_list` value. */
-export type ScheduleListValue = ScheduleView[] | ScheduleToolError;
-/** Successful `schedule_delete` value, including the non-mutating not-found result. */
+/** Input failure codes; every member except `internal_error` of the management error union. */
+export type ScheduleInputErrorCode = Exclude<ScheduleToolError['code'], 'internal_error'>;
+/** Deletion outcome, including the non-mutating not-found result. */
 export type ScheduleDeleteResult = {
     readonly id: ScheduleId;
     readonly deleted: true;
@@ -290,54 +252,34 @@ export type ScheduleDeleteResult = {
     readonly deleted: false;
     readonly code: 'schedule_not_found';
 };
-/** Canonical `schedule_delete` value. */
-export type ScheduleDeleteValue = ScheduleDeleteResult | ScheduleToolError;
-declare module '@qilin-agent/workspace/types' {
-    interface SessionActivityKindMap {
-        /** A scheduled follow-up for this session is still active. */
-        schedule: true;
-    }
-}
-declare module '@qilin-agent/session/types' {
-    interface SessionEventMap {
-        /**
-         * Versioned Schedule mutation. The owning package validates the complete
-         * session-local transition stream before accepting a candidate event.
-         */
-        'schedule/change': ScheduleChange;
-    }
-}
-/** Reminder creation selector, shared by the model consumer and Host service. */
-export interface ScheduleCreateRequest {
-    /** Non-empty reminder text. */
-    prompt: string;
-    /** Required task name of at most 120 characters, non-empty after trimming; names the card, detail heading, and task lists. */
-    title: string;
-    /** Relative one-shot delay in seconds. */
-    after_seconds?: number;
-    /** Absolute one-shot target. */
-    at?: AtInput;
-    /** Fixed recurrence interval in seconds. */
-    every_seconds?: number;
-    /** Daily wall-clock time in an explicit IANA zone. */
-    daily?: DailyInput;
-    /** Weekly wall-clock time and explicit ISO weekday set in an IANA zone. */
-    weekly?: WeeklyInput;
-    /** Five-field cron expression evaluated in an explicit IANA zone. */
-    cron?: CronInput;
-}
-/** Session-scoped task list, without Agent activation. */
-export interface ScheduleListRequest {
-    /** Original Session binding. */
-    sessionId: SessionId;
+/** Configured limits applied when appending one task's delivery receipt. */
+export interface DeliveryRetentionBounds {
+    /** Retained window in days, measured back from the acknowledgment being appended. */
+    readonly days: number;
+    /** Maximum retained records per task; the newest survive. */
+    readonly records: number;
 }
-/** Delete request identifying a task within its original Session binding. */
-export interface ScheduleDeleteRequest extends ScheduleListRequest {
-    /** Task to remove. */
-    id: ScheduleId;
+/** RFC 5545 timing with an explicit DTSTART anchor and zone. */
+export interface RRuleScheduleRecord {
+    readonly kind: 'rrule';
+    /** Host-generated canonical identity. */
+    readonly id: ScheduleId;
+    /** Task name; already trimmed, non-empty, and at most 120 characters. */
+    readonly title: string;
+    /** Trimmed instruction sent when an occurrence becomes due. */
+    readonly prompt: string;
+    /** One normalized DTSTART line and one RRULE line. */
+    readonly rrule: string;
+    /** Next unaccepted occurrence while active, or the final accepted occurrence when ended. */
+    readonly scheduledAt: string;
 }
-/** Timing-only edit; it may select a different recurrence kind than the stored record, and one-shot targets use an absolute `at`. */
-export type ScheduleTimingChange = {
+/** Current timing records; every kind is authoritative and uses the normal evaluator. */
+export type ScheduleRecord = OneShotScheduleRecord | RecurringScheduleRecord;
+/** Timing accepted by the shared management API. */
+export type ScheduleTiming = {
+    readonly kind: 'after';
+    readonly after_seconds: number;
+} | {
     readonly kind: 'at';
     readonly at: AtInput;
 } | {
@@ -352,65 +294,262 @@ export type ScheduleTimingChange = {
 } | {
     readonly kind: 'cron';
     readonly cron: CronInput;
+} | {
+    readonly kind: 'rrule';
+    readonly rrule: string;
 };
-/** Replacement task name and instruction carried by one compare-and-update request. */
-export interface ScheduleUpdateContent {
-    /** Task name of at most 120 characters, non-empty after trimming; omitted keeps the stored name. */
-    readonly title?: string;
-    /** Reminder instruction, non-empty after trimming; omitted keeps the stored instruction. */
-    readonly prompt?: string;
-}
-/** Compare-and-update request within the original Session binding. */
-export interface ScheduleUpdateRequest extends ScheduleDeleteRequest, ScheduleUpdateContent {
-    /** Complete record observed when editing began, including the committed target. */
-    readonly expected: ScheduleRecord;
-    /** New timing; its kind may differ from the stored record's kind, and an omitted value keeps the committed target. */
-    readonly change?: ScheduleTimingChange;
+/** Values used when a target creates a Session. */
+export interface ScheduleSessionCreateSpec {
+    /** Project directory of the created Session, which joins the Workspace registered there; omission uses the Host project directory. */
+    readonly cwd?: string;
+    /** Agent preset of the created Session; omission uses the default preset. */
+    readonly agentPreset?: string;
+}
+/** Stored delivery destination; it is independent of the Session that manages the task. */
+export type ScheduleTarget = {
+    /** Every occurrence goes to one existing Session. */
+    readonly kind: 'session';
+    /** Session that receives each delivery. */
+    readonly sessionId: SessionId;
+} | {
+    /** The first delivery creates one Session; later deliveries go to that Session. */
+    readonly kind: 'new_once';
+    /** Reserved at creation; the first delivery creates it and the target becomes `session`. */
+    readonly sessionId: SessionId;
+    /** Values used to create the reserved Session. */
+    readonly create: ScheduleSessionCreateSpec;
+} | {
+    /** Every delivery creates a fresh Session. */
+    readonly kind: 'new';
+    /** Values used to create each Session. */
+    readonly create: ScheduleSessionCreateSpec;
+};
+/** Destination accepted by create and edit; the Host reserves the `new_once` Session id. */
+export type ScheduleTargetRequest = {
+    /** Deliver to one existing Session that is not a delegated child. */
+    readonly kind: 'session';
+    /** Existing Session that receives each delivery. */
+    readonly sessionId: SessionId;
+} | {
+    /** Create one Session at the first delivery. */
+    readonly kind: 'new_once';
+    /** Creation values; omission uses the Host defaults. */
+    readonly create?: ScheduleSessionCreateSpec;
+} | {
+    /** Create a fresh Session at each delivery. */
+    readonly kind: 'new';
+    /** Creation values; omission uses the Host defaults. */
+    readonly create?: ScheduleSessionCreateSpec;
+};
+/** Durable Session inbox delivery acknowledgment, not model execution completion. */
+export interface ScheduleDeliveryReceipt {
+    /** Canonical UTC target of the delivered occurrence. */
+    readonly scheduledAt: string;
+    /** Canonical UTC time sampled after Session persistence acknowledged delivery. */
+    readonly deliveredAt: string;
+    /** Identity of the delivered message, shared by tasks in one recurring batch. */
+    readonly messageId: MessageId;
+    /** Session that durably accepted the delivered message. */
+    readonly targetSessionId: SessionId;
 }
-/** Non-mutating compare-and-update outcome: unknown, inactive, or changed since the read. */
-export interface ScheduleUpdateMiss {
-    readonly id: ScheduleId;
-    readonly updated: false;
-    readonly code: 'schedule_not_found' | 'schedule_ended' | 'schedule_conflict';
+/** Saved inbox delivery with its immutable sent prompt when recorded by this Host. */
+export interface ScheduleDeliveryRecord extends ScheduleDeliveryReceipt {
+    /** Prompt sent for this occurrence; unavailable for legacy receipts. */
+    readonly prompt?: string;
 }
-/** Successful current record, non-mutating lookup/conflict failure, or invalid name/instruction/timing. */
-export type ScheduleUpdateResult = {
+/** Bounded newest-first query over the saved deliveries of one task. */
+export interface ScheduleDeliveryHistoryRequest {
+    /** Task whose saved deliveries are read. */
     readonly id: ScheduleId;
-    readonly updated: boolean;
-    readonly record: ScheduleRecord;
-} | ScheduleUpdateMiss | ScheduleToolError;
-/** Canonical `schedule_update` value: the committed record as a view, or the non-mutating lookup/conflict result. */
-export type ScheduleUpdateValue = ScheduleView | ScheduleUpdateMiss | ScheduleToolError;
-/** Explicitly bounded saved-delivery query within one Session binding. */
-export interface ScheduleDeliveryHistoryRequest extends ScheduleDeleteRequest {
     /** Required safe-integer page size from 1 through 100. */
-    limit: number;
+    readonly limit: number;
     /** Message identity of the oldest entry in the previous page; excluded from this page. */
-    before?: MessageId;
+    readonly before?: MessageId;
 }
-/** Configured limits applied when appending one task's delivery receipt. */
-export interface DeliveryRetentionBounds {
-    /** Retained window in days, measured back from the acknowledgment being appended. */
-    readonly days: number;
-    /** Maximum retained records per task; the newest survive. */
-    readonly records: number;
-}
-/** Newest-first saved deliveries, or a non-mutating task/cursor lookup failure. */
-export type ScheduleDeliveryHistoryResult = {
+/** One newest-first page of saved deliveries. */
+export interface ScheduleDeliveryHistoryPage {
+    /** Task whose saved deliveries this page lists. */
     readonly id: ScheduleId;
+    /** Saved deliveries, newest first. */
     readonly records: ScheduleDeliveryRecord[];
-    /** Whether earlier delivery records may be unavailable; missing receipts are never reconstructed. */
+    /** Whether deliveries before the saved records may exist; the Host never reconstructs them. */
     readonly earlierRecordsUnavailable: boolean;
-    /** True only after an append removed saved records; absent legacy evidence is false. */
+    /** Whether a retention limit removed saved records; legacy history without that fact is false. */
     readonly earlierRecordsPruned: boolean;
-    /** Current Host retention configuration, also used by the delivery writer. */
+    /** Current Host retention limits; the delivery writer applies the same limits. */
     readonly retention: DeliveryRetentionBounds;
-    /** Oldest returned message identity, present only when older saved records remain. */
+    /** Cursor for the next page; present only when older saved records remain. */
     readonly nextBefore?: MessageId;
-} | {
+}
+/** Non-mutating miss: the task or the page cursor does not exist. */
+export interface ScheduleDeliveryHistoryMiss {
+    /** Requested task identity. */
     readonly id: ScheduleId;
+    /** `delivery_cursor_not_found` means `before` names no saved record of this task. */
     readonly code: 'schedule_not_found' | 'delivery_cursor_not_found';
+}
+/** One saved-delivery page, or a non-mutating lookup miss. */
+export type ScheduleDeliveryHistoryResult = ScheduleDeliveryHistoryPage | ScheduleDeliveryHistoryMiss;
+/** Browser-safe Host task state. */
+export type ScheduleCatalogEntry = ScheduleRecord & {
+    /** Destination of the next delivery. */
+    readonly target: ScheduleTarget;
+    /**
+     * Sessions told about later changes while their Agent is live: the creating and editing Agent Sessions and each
+     * existing or reserved target Session. Sessions created by a `new` target are excluded.
+     */
+    readonly involvedSessionIds: SessionId[];
+    /** Only `active` tasks have a timer obligation; `paused` and `ended` tasks stay visible. */
+    readonly status: 'active' | 'paused' | 'ended';
+    /** Canonical UTC creation time. */
+    readonly createdAt?: string;
+    /** Canonical UTC time of the latest stored change; editors send it back as `expectedUpdatedAt`. */
+    readonly updatedAt?: string;
+    /**
+     * The latest delivery is queued or running in its reused target Session; a `new` target, whose deliveries run beside one
+     * another, never sets it.
+     */
+    readonly executionActive?: true;
+    /** End of the minimum delivery interval, present while it remains in the future. */
+    readonly deliveryFloorEndsAt?: string;
+    /** Most recent durably acknowledged inbox delivery, when available. */
+    readonly lastDelivery?: ScheduleDeliveryReceipt;
 };
+/** Host task creation request. */
+export interface ScheduleCreateRequest {
+    /** Task name of at most 120 characters, non-empty after trimming. */
+    readonly title: string;
+    /** Instruction sent at each occurrence; non-empty after trimming. */
+    readonly prompt: string;
+    /** Authoritative typed timing with at least one future occurrence. */
+    readonly timing: ScheduleTiming;
+    /** Delivery destination; omission creates one Session at first delivery and reuses it. */
+    readonly target?: ScheduleTargetRequest;
+}
+/** Host-wide task list request. */
+export interface ScheduleListRequest {
+    /** `true` lists only active tasks; `false` lists only paused and ended tasks; omission lists all tasks. */
+    readonly active?: boolean;
+    /** Page size from 1 through 500; the default is 100. */
+    readonly limit?: number;
+    /** Number of sorted tasks to skip; the default is 0. */
+    readonly offset?: number;
+}
+/** One page of the Host-wide task list; active tasks come first, ordered by next occurrence. */
+export interface ScheduleListResult {
+    /** Tasks in this page. */
+    readonly items: ScheduleCatalogEntry[];
+    /** Number of tasks in this page. */
+    readonly shown: number;
+    /** Number of tasks that match the filter. */
+    readonly total: number;
+    /** Applied page size. */
+    readonly limit: number;
+    /** Applied offset. */
+    readonly offset: number;
+}
+/** Read one task by canonical identity. */
+export interface ScheduleViewRequest {
+    /** Task to read. */
+    readonly id: ScheduleId;
+}
+/** Non-mutating miss for an unknown task identity. */
+export interface ScheduleNotFoundResult {
+    /** Requested task identity. */
+    readonly id: ScheduleId;
+    /** Lookup miss discriminator. */
+    readonly code: 'schedule_not_found';
+}
+/** Current task state, or a lookup miss. */
+export type ScheduleViewResult = ScheduleCatalogEntry | ScheduleNotFoundResult;
+/** Fields changed together by one atomic update; an omitted field keeps its stored value. */
+export interface SchedulePatch {
+    /** Replacement task name. */
+    readonly title?: string;
+    /** Replacement instruction. */
+    readonly prompt?: string;
+    /** Replacement timing; a changed rule recomputes the next occurrence. */
+    readonly timing?: ScheduleTiming;
+    /** Replacement destination. */
+    readonly target?: ScheduleTargetRequest;
+    /** `false` pauses the task; `true` resumes a recurrence from its first future occurrence. */
+    readonly active?: boolean;
+}
+/** One closed edit operation. */
+export type ScheduleEditRequest = {
+    /** Task to change. */
+    readonly id: ScheduleId;
+    /** Apply `patch` as one atomic change. */
+    readonly action: 'update';
+    /** Fields to change; at least one member is required. */
+    readonly patch: SchedulePatch;
+    /** `updatedAt` value that the editor read; a different stored value returns `schedule_conflict`. */
+    readonly expectedUpdatedAt?: string | null;
+} | {
+    /** Task to remove. */
+    readonly id: ScheduleId;
+    /** Remove the task and its saved deliveries. */
+    readonly action: 'delete';
+    /** `updatedAt` value that the editor read; a different stored value returns `schedule_conflict`. */
+    readonly expectedUpdatedAt?: string | null;
+};
+/** Non-mutating refusal: the stored task changed after the editor read it. */
+export interface ScheduleConflictResult {
+    /** Requested task identity. */
+    readonly id: ScheduleId;
+    /** Optimistic revision mismatch discriminator. */
+    readonly code: 'schedule_conflict';
+}
+/** Updated task state, a completed deletion, or a non-mutating miss or conflict. */
+export type ScheduleEditResult = ScheduleCatalogEntry | Extract<ScheduleDeleteResult, {
+    readonly deleted: true;
+}> | ScheduleNotFoundResult | ScheduleConflictResult;
+/** Manual execution request from the human task manager. */
+export interface ScheduleRunRequest {
+    /** Task to run now. */
+    readonly id: ScheduleId;
+}
+/** Non-mutating refusal: one execution of this task already owns its admission slot. */
+export interface ScheduleExecutionPendingResult {
+    /** Requested task identity. */
+    readonly id: ScheduleId;
+    /** Consolidated execution discriminator. */
+    readonly code: 'schedule_execution_pending';
+}
+/** Task state after a manual delivery, or a non-mutating miss or refusal. */
+export type ScheduleRunResult = ScheduleCatalogEntry | ScheduleNotFoundResult | ScheduleExecutionPendingResult;
+declare module '@qilin-agent/typert-protocol' {
+    interface RemoteErrorDetailsMap {
+        /** The Schedule request failed validation before it was stored. */
+        'schedule/input-invalid': {
+            readonly code: ScheduleInputErrorCode;
+        };
+        /** A delivery or run reached a `session` target that the Workspace registry lists as archived. */
+        'schedule/target-archived': {
+            readonly sessionId: SessionId;
+        };
+    }
+}
+/** Successful Host-wide removal of every ended task, whether or not any remained. */
+export interface ScheduleDeleteInactiveResult {
+    /** Ended task rows this call removed; zero when the Host held none. */
+    readonly deleted: number;
+}
+declare module '@qilin-agent/workspace/types' {
+    interface SessionActivityKindMap {
+        /** A scheduled follow-up for this session is still active. */
+        schedule: true;
+    }
+}
+declare module '@qilin-agent/session/types' {
+    interface SessionEventMap {
+        /**
+         * Historical version-1 Session-local reminder mutation. New tasks live in Host storage;
+         * these events remain inert and never populate the Host task store.
+         */
+        'schedule/change': ScheduleChange;
+    }
+}
 declare module '@qilin-agent/kylin' {
     interface Events {
         /** Durable task set changed; clients refetch global task and Session-active catalogs.

package/lib/types/types.js

@@ -1,6 +1,6 @@
 /**
  * Durable and model-facing Schedule value types.
- * @module @qilin-agent/schedule
+ * @module @qilin-agent/schedule/types
  */
 export {};
 //# sourceMappingURL=types.js.map

package/lib/types/update.d.ts

@@ -1,26 +1,21 @@
-import type { ScheduleRecord, ScheduleTimingChange, ScheduleUpdateContent, ScheduleUpdateResult } from './types.ts';
+import type { ScheduleId, SchedulePatch, ScheduleRecord, ScheduleTiming } from './types.ts';
 /**
- * Title one update must either keep or replace.
- *
- * A decoded record always carries a stored title. A record value without a
- * valid one is refused with the durable decode error instead of deriving a name.
- * @param record - Current active Host record.
- * @returns The stored title; a missing, blank, untrimmed, or over-long title throws ScheduleLogError.
+ * Construct a current record with one authoritative timing kind and a future committed target.
+ * @param id - Host-generated task identity.
+ * @param title - Required user-facing task title.
+ * @param prompt - Non-empty instruction delivered at each occurrence.
+ * @param value - Exactly one typed timing selector.
+ * @param now - Explicit acceptance time in epoch milliseconds.
+ * @returns A validated record with its first future occurrence.
  */
-export declare function retainedTitle(record: ScheduleRecord): string;
+export declare function createScheduleRecord(id: ScheduleId, title: string, prompt: string, value: ScheduleTiming, now: number): ScheduleRecord;
 /**
- * Compare the complete observed record and resolve one name, instruction, and timing update
- * using a single queue-time sample.
- *
- * An omitted change, name, or instruction keeps the stored value. A supplied name or
- * instruction never re-anchors the schedule on its own; an equivalent normalized timing
- * change keeps the committed target too.
- * @param current - Current active Host record.
- * @param expected - Untrusted complete record observed by the caller.
- * @param change - Strict timing selector, whose kind may differ from the current record's kind, or undefined to keep timing.
- * @param now - Single wall-clock sample from the accepted FIFO slot.
- * @param content - Untrusted replacement name and instruction; each omitted field keeps its stored value.
- * @returns Current/new record or a bounded input/conflict result; unrelated failures throw.
+ * Keep unchanged timing and committed targets, or re-arm through the same constructor as creation.
+ * @param current - Stored record before the edit.
+ * @param patch - Descriptive fields and optional typed timing replacement.
+ * @param now - Explicit edit acceptance time in epoch milliseconds.
+ * @param resume - Whether to find a future occurrence for unchanged timing.
+ * @returns The retained or revised authoritative timing record.
  */
-export declare function resolveScheduleUpdate(current: ScheduleRecord, expected: ScheduleRecord, change: ScheduleTimingChange | undefined, now: number, content?: ScheduleUpdateContent): ScheduleUpdateResult;
+export declare function updateScheduleRecord(current: ScheduleRecord, patch: SchedulePatch, now: number, resume: boolean): ScheduleRecord;
 //# sourceMappingURL=update.d.ts.map