@linxin666/dsh-client-ui-task-board 0.4.4 → 0.4.6

package/lib/types/client/locales.d.ts

@@ -25,7 +25,6 @@ export declare const zh: {
     'board.status.failed': string;
     'board.runs': string;
     'board.pending': string;
-    'board.updated': string;
     'board.created': string;
     'board.hostError': string;
     'board.hostError.notMounted': string;
@@ -106,6 +105,22 @@ export declare const zh: {
     'board.tagFilter': string;
     'board.tagFilterClear': string;
     'board.tagEmpty': string;
+    'board.tagManage': string;
+    'tags.title': string;
+    'tags.hint': string;
+    'tags.empty': string;
+    'tags.usage': string;
+    'tags.rename': string;
+    'tags.renameLabel': string;
+    'tags.delete': string;
+    'tags.deleteTitle': string;
+    'tags.deleteConfirm': string;
+    'tags.deleteOk': string;
+    'tags.save': string;
+    'tags.mergeHint': string;
+    'tags.renameFailed': string;
+    'tags.deleteFailed': string;
+    'tags.done': string;
     'detail.permissionPending': string;
     'detail.permissionConfirm': string;
     'detail.permissionConfirmed': string;
@@ -121,6 +136,8 @@ export declare const zh: {
     'new.archiveOriginal': string;
     'detail.prompt': string;
     'detail.description': string;
+    'detail.expand': string;
+    'detail.collapse': string;
     'detail.execution': string;
     'detail.noExecution': string;
     'detail.run': string;
@@ -133,6 +150,7 @@ export declare const zh: {
     'detail.noSession': string;
     'detail.executionStarted': string;
     'detail.execution.initiator': string;
+    'detail.execution.external': string;
     'detail.executionEnded': string;
     'detail.result.succeeded': string;
     'detail.result.failed': string;
@@ -144,6 +162,9 @@ export declare const zh: {
     'delete.cancel': string;
     'status.move.backlog': string;
     'status.move.todo': string;
+    'status.move.running': string;
+    'status.move.done': string;
+    'status.move.failed': string;
     'exec.error.noWorkspace': string;
     'exec.error.promptRejected': string;
     'run.failed': string;
@@ -172,7 +193,34 @@ export declare const zh: {
     'detail.schedule.duration.hours': string;
     'detail.schedule.duration.minutes': string;
     'detail.schedule.duration.seconds': string;
+    'detail.schedule.mode': string;
+    'detail.schedule.mode.cron': string;
+    'detail.schedule.mode.once': string;
+    'detail.schedule.at': string;
+    'detail.schedule.atHint': string;
+    'detail.schedule.atInvalid': string;
+    'detail.schedule.plannedAt': string;
+    'detail.schedule.zoneOnceHint': string;
+    'detail.schedule.maxRuns': string;
+    'detail.schedule.maxRunsUnlimited': string;
+    'detail.schedule.maxRunsValue': string;
+    'detail.schedule.maxRunsCustom': string;
+    'detail.schedule.maxRunsInvalid': string;
+    'detail.schedule.runs': string;
+    'detail.schedule.runsUnlimited': string;
+    'detail.schedule.remaining': string;
+    'detail.schedule.cancel': string;
+    'detail.schedule.ended': string;
+    'detail.schedule.skipped': string;
+    'detail.schedule.stop.fired': string;
+    'detail.schedule.stop.limit': string;
+    'detail.schedule.stop.no-target': string;
+    'detail.schedule.stop.missed': string;
+    'detail.schedule.stop.busy': string;
+    'detail.schedule.stop.permission': string;
+    'detail.schedule.stop.launch-failed': string;
     'card.scheduled': string;
+    'card.scheduledOnce': string;
     'new.workspace': string;
     'new.agentPreset': string;
     'new.permission': string;
@@ -203,11 +251,14 @@ export declare const zh: {
     'exec.reuseSessionHint': string;
     'exec.goalRun': string;
     'exec.goalRunHint': string;
+    'exec.skipVerification': string;
+    'exec.skipVerificationHint': string;
     'detail.executionSettings': string;
     'exec.hint': string;
     'settings.title': string;
     'settings.description': string;
     'settings.enabled': string;
+    'settings.enabledCardHint': string;
     'settings.enabledHint': string;
     'settings.announceToAgent': string;
     'settings.announceToAgentHint': string;
@@ -232,9 +283,105 @@ export declare const zh: {
     'settings.unsaved': string;
     'settings.saveFailed': string;
     'settings.invalidNumber': string;
+    'settings.sessionPollSeconds': string;
+    'settings.sessionPollSecondsHint': string;
     'settings.maxSubtaskDepth': string;
     'settings.maxSubtaskDepthHint': string;
     'settings.maxSubtaskDepthOption': string;
+    'settings.runBehaviorTitle': string;
+    'settings.runBehaviorCardHint': string;
+    'settings.goalRunGlobal': string;
+    'settings.goalRunGlobalHint': string;
+    'settings.goalRunGlobalDisabledTaskOption': string;
+    'settings.goalVerificationTitle': string;
+    'settings.goalVerification': string;
+    'settings.goalVerificationCardHint': string;
+    'settings.goalVerificationHint': string;
+    'settings.goalVerificationModel': string;
+    'settings.goalVerificationModelHint': string;
+    'settings.goalVerificationModelInherit': string;
+    'settings.goalVerificationModelInheritUnknown': string;
+    'settings.goalVerificationEffort': string;
+    'settings.goalVerificationEffortHint': string;
+    'settings.goalVerificationEffortInherit': string;
+    'settings.goalVerificationEffortInheritUnknown': string;
+    'settings.goalVerificationResolved': string;
+    'settings.goalVerificationResolvedModel': string;
+    'settings.goalVerificationResolvedEffort': string;
+    'settings.goalVerificationResolvedNoEffort': string;
+    'settings.goalVerificationResolvedSource': string;
+    'settings.goalVerificationSourceInherit': string;
+    'settings.goalVerificationSourceExplicit': string;
+    'settings.goalVerificationResolvedPreset': string;
+    'settings.goalVerificationRouteMissing': string;
+    'settings.goalVerificationEffortFallback': string;
+    'settings.goalVerificationEffortFallbackNone': string;
+    'settings.goalVerificationModelInvalid': string;
+    'running.executing': string;
+    'running.verifying': string;
+    'running.repairing': string;
+    'running.verificationPassed': string;
+    'running.verificationFailed': string;
+    'running.verificationInvalid': string;
+    'verify.title': string;
+    'verify.status.passed': string;
+    'verify.status.failed': string;
+    'verify.status.exception': string;
+    'verify.status.verifying': string;
+    'verify.status.pending': string;
+    'verify.status.off': string;
+    'verify.status.invalid': string;
+    'verify.status.invalidHeld': string;
+    'verify.attemptInvalid': string;
+    'verify.invalidReason.missing-finding': string;
+    'verify.invalidReason.unlocatable-quote': string;
+    'verify.invalidReason.baseline-finding': string;
+    'verify.invalidReason.vacuous-finding': string;
+    'verify.invalidReason.insufficient-evidence': string;
+    'verify.invalidReason.unknown': string;
+    'verify.invalidCounts': string;
+    'verify.invalidDetail': string;
+    'verify.criterionFindings': string;
+    'verify.criterionFinding': string;
+    'verify.criterionFindingFull': string;
+    'verify.location.task': string;
+    'verify.location.trajectory': string;
+    'verify.location.workspace': string;
+    'verify.location.baseline': string;
+    'verify.location.unknown': string;
+    'verify.detailRemoved': string;
+    'verify.cleanup.cleaned': string;
+    'verify.cleanup.pending': string;
+    'verify.cleanup.failed': string;
+    'verify.cleanup.audit': string;
+    'verify.cleanup.stage.quality': string;
+    'verify.cleanup.stage.invalid': string;
+    'verify.cleanup.stage.exception': string;
+    'verify.cleanup.stage.budget': string;
+    'verify.summary': string;
+    'verify.criteria': string;
+    'verify.criterion': string;
+    'verify.rounds': string;
+    'verify.judge': string;
+    'verify.judgeNoEffort': string;
+    'verify.judgeInherited': string;
+    'verify.attempt': string;
+    'verify.attemptException': string;
+    'verify.counts': string;
+    'verify.findings': string;
+    'verify.noFindings': string;
+    'verify.evidence': string;
+    'verify.workspaceEvidence': string;
+    'verify.usage': string;
+    'verify.usageIncomplete': string;
+    'verify.finalFailure': string;
+    'verify.applicability.disabled': string;
+    'verify.applicability.goalUnavailable': string;
+    'verify.applicability.skipped': string;
+    'verify.applicability.teamMember': string;
+    'verify.applicability.goalDisabled': string;
+    'verify.effortFallback': string;
+    'verify.thresholdValue': string;
     'detail.parent': string;
     'detail.parent.open': string;
     'detail.subtasks': string;
@@ -258,6 +405,25 @@ export declare const zh: {
     'card.subtasksFailed': string;
     'card.subtasksRunning': string;
     'card.subtasksBreakdown': string;
+    'card.result.succeeded': string;
+    'card.result.failed': string;
+    'card.result.cancelled': string;
+    'card.declared': string;
+    'card.declaredHint': string;
+    'card.openSession': string;
+    'card.tagsLabel': string;
+    'card.time.created': string;
+    'card.time.started': string;
+    'card.time.settled': string;
+    'card.time.archived': string;
+    'card.time.updated': string;
+    'board.density.compact': string;
+    'board.density.comfortable': string;
+    'board.group.today': string;
+    'board.group.week': string;
+    'board.group.earlier': string;
+    'board.group.expand': string;
+    'board.group.collapse': string;
     'board.hideSubtasks': string;
     'board.showSubtasks': string;
     'board.subtaskFilterHint': string;
@@ -265,6 +431,7 @@ export declare const zh: {
 /** en dictionary, complete against the zh key set. */
 export declare const en: Record<keyof typeof zh, string>;
 /** The dictionary key union. */
+/** The dictionary key union. */
 export type TaskBoardKey = keyof typeof zh;
 /** The settings-card slice of the task-board dictionary. */
 export type SettingsCardKey = TaskBoardKey;

package/lib/types/client/native-panel.d.ts

@@ -1,23 +1,7 @@
-/**
- * Native panel registration for the task board.
- *
- * The board is an official-style center-column panel, not a DOM takeover: it
- * contributes a row into the sidebar shell's own global panel list
- * (`sidebar.panellist`) and its page into the layout's keyed `main` slot. The
- * shell then owns the row box, the label, the active highlight, the collapsed
- * rail, the panel switch and the window-chrome interplay exactly as it does for
- * the shipped Plugins and Schedule pages, so the board renders through the same
- * container the desktop application's Plugins page uses.
- *
- * Both registrations go through `ctx.slots.inject`, which fires only once the
- * owning shell entry has declared the seat: load order between this plugin and
- * ui-layout / ui-sidebar therefore does not matter, and neither does a shell
- * that cannot serve the seats (the callback simply never runs).
- *
- * @module @linxin666/dsh-client-ui-task-board/client
- */
+import type { ReactNode } from 'react';
 import type { Context as ClientContext } from '@deepseek-ai/cordis';
 import { TASK_BOARD_PANEL_ID, type BoardController } from '../core/controller.ts';
+import { type SlotRenderBinding } from './seats.tsx';
 /** The panel id shared by the sidebar row and the main-slot occupant. */
 export { TASK_BOARD_PANEL_ID };
 /**
@@ -45,9 +29,11 @@ export declare function TaskBoardPanelIcon({ size }: {
  * @param props - the framework main-slot share plus this entry's injected face.
  * @returns the board page.
  */
-export declare function TaskBoardPanel({ controller }: {
+export declare function TaskBoardPanel({ controller, renderSlot }: {
     controller: BoardController;
-}): React.ReactElement;
+    /** Child-slot renderer the registration declares (detail + card decoration). */
+    renderSlot?: SlotRenderBinding;
+}): ReactNode;
 /**
  * Register the board's sidebar row and center-column page.
  *

package/lib/types/client/plugin-card-seat.d.ts

@@ -78,6 +78,11 @@ export interface PluginCardSeat {
     label?: () => string;
     /** Locale namespace the card renders with. */
     locale: string;
+    /**
+     * Child slots this card declares and renders. Forwarded to whichever seat
+     * the host renders; absent for a card that declares none.
+     */
+    children?: Record<string, unknown>;
     /** Business-face factory of the registration. */
     inject?: () => object;
     /**

package/lib/types/client/schedule-zone.d.ts

@@ -1,3 +1,5 @@
+import { type ScheduleRule, type ScheduleStopReason } from '../core/tasks.ts';
+import { type TaskBoardKey } from './locales.ts';
 /** One selectable zone, in the order the picker shows it. */
 export interface ZoneChoice {
     /** Canonical IANA id, or `''` for the Host-zone entry. */
@@ -32,6 +34,54 @@ export declare function zoneChoices(hostTimeZone: string | undefined, storedTime
  * @returns localized relative wording.
  */
 export declare function relativeTimeLabel(targetMs: number, now: number): string;
+/**
+ * The `datetime-local` input value for an instant, read in an explicit zone:
+ * `YYYY-MM-DDTHH:mm`. Uses the shared engine's zone reader, so the editor
+ * shows the same wall clock the Host schedules by.
+ * @param epochMs - the instant to render.
+ * @param timeZone - zone to read it in; absent uses the Host zone.
+ * @returns the input value.
+ */
+export declare function zonedInputValue(epochMs: number, timeZone?: string): string;
+/**
+ * Parse a `datetime-local` input value back to an instant, read in an explicit
+ * zone. Returns undefined when the text is not a whole calendar wall clock or
+ * names one the zone skips (a spring-forward gap), so the editor can refuse an
+ * unusable instant instead of silently moving it.
+ * @param value - the input text.
+ * @param timeZone - zone to interpret it in; absent uses the Host zone.
+ * @returns the instant, or undefined when it is not a usable wall clock.
+ */
+export declare function parseZonedInput(value: string, timeZone?: string): number | undefined;
+/**
+ * The default instant a new one-shot editor opens on: the next whole hour,
+ * rendered in the zone the rule will be read in.
+ * @param now - reference instant.
+ * @param timeZone - zone the rule is read in.
+ * @returns the input value for a near-future default.
+ */
+export declare function defaultZonedInputValue(now: number, timeZone?: string): string;
+/**
+ * The editor's run-cap option for a stored cap: the two named presets, the
+ * unlimited entry, or a custom value the editor shows in its own field.
+ * @param maxRuns - the stored cap, when any.
+ * @returns the select option value.
+ */
+export declare function runCapOption(maxRuns: number | undefined): string;
+/** The locale key describing why a rule stopped or skipped an occurrence. */
+export declare function stopReasonKey(reason: ScheduleStopReason): TaskBoardKey;
+/**
+ * The run-budget line: how many scheduled executions the Host opened and how
+ * many remain. Derived from the counter and the cap rather than stored, so the
+ * display cannot drift from the ledger.
+ * @param rule - the schedule rule.
+ * @returns localized wording.
+ */
+export declare function budgetLabel(rule: ScheduleRule): string;
+/** The line describing a rule that stopped itself, or undefined while it may still fire. */
+export declare function endedLabel(rule: ScheduleRule): string | undefined;
+/** The line describing the last skipped occurrence, or undefined when none. */
+export declare function skippedLabel(rule: ScheduleRule): string | undefined;
 /**
  * The full next-run label: the absolute wall clock in the schedule's own zone,
  * plus the relative distance in parentheses. Showing both matters because a

package/lib/types/client/seats.d.ts

@@ -0,0 +1,18 @@
+import type { ReactNode } from 'react';
+import { type TaskBoardCardDecorationProps, type TaskBoardDetailSectionProps, type TaskBoardSettingsSectionProps } from '../core/extension.ts';
+/** The three provider seats, adapted to plain render functions. */
+export interface TaskBoardSeats {
+    detailSection: (props: TaskBoardDetailSectionProps) => ReactNode;
+    settingsSection: (props: TaskBoardSettingsSectionProps) => ReactNode;
+    cardDecoration: (props: TaskBoardCardDecorationProps) => ReactNode;
+}
+/** Nothing registered: every seat renders empty. */
+export declare const EMPTY_TASK_BOARD_SEATS: TaskBoardSeats;
+/** The framework `renderSlot` binding shape (key + owner props share). */
+export type SlotRenderBinding = (key: string, owner: Record<string, unknown>) => ReactNode;
+/** Adapt one framework renderSlot binding to the board's seat interface. */
+export declare function seatsFromRenderSlot(renderSlot: SlotRenderBinding | undefined): TaskBoardSeats;
+/** Provider the board's registered components wrap their subtree in. */
+export declare const TaskBoardSeatsProvider: import("react").Provider<TaskBoardSeats>;
+/** Read the current seat set (empty when no board registration is above). */
+export declare function useTaskBoardSeats(): TaskBoardSeats;

package/lib/types/client/service.d.ts

@@ -0,0 +1,32 @@
+/**
+ * The board's browser-half extension service (`taskBoard`).
+ *
+ * It gives a provider's browser half the client capability face from the
+ * contract: dispatch over the board's same-origin action channel, card
+ * visibility predicates, and a subscription to the board mirror. The board
+ * controller is attached and detached as the master switch mounts and unmounts
+ * the UI, so the service can be provided before any controller exists.
+ *
+ * @module dsh-task-board/client/service
+ */
+import type { BoardController } from '../core/controller.ts';
+import type { TaskBoardClientFace, TaskBoardClientMirror, TaskBoardExtensionActionRequest, TaskBoardVisibilityPredicate } from '../core/extension.ts';
+export declare class TaskBoardClientService implements TaskBoardClientFace {
+    private controller;
+    private enabled;
+    private unsubscribeController;
+    /** Predicates registered before the controller exists, replayed on attach. */
+    private readonly pendingVisibility;
+    private readonly listeners;
+    /** Bind the live board controller (called when the UI mounts). */
+    attach(controller: BoardController): void;
+    /** Release the current controller (called when the UI unmounts). */
+    detach(): void;
+    /** Apply the board's master switch. */
+    setEnabled(enabled: boolean): void;
+    dispatch(request: TaskBoardExtensionActionRequest): Promise<boolean>;
+    registerVisibility(predicate: TaskBoardVisibilityPredicate): () => void;
+    subscribe(callback: (mirror: TaskBoardClientMirror) => void): () => void;
+    snapshot(): TaskBoardClientMirror;
+    private notify;
+}

package/lib/types/client/settings-form.d.ts

@@ -134,6 +134,8 @@ export declare class CardForm<T> {
     private readonly disposeForm;
     private disposed;
     private saving;
+    /** A save asked for while one was in flight; it runs once the first settles (#1754). */
+    private saveQueued;
     private failed;
     private failedReason;
     /** @param scope - the bound configuration form for this card's namespace. */
@@ -167,6 +169,20 @@ export declare class CardForm<T> {
      * the user can correct them instead of retyping.
      * @returns settlement after the mutation and the read-back.
      */
+    /**
+     * Run one save, and re-run it once if another was asked for while this one
+     * was still in flight.
+     *
+     * A save is a Host round trip that also drives the profile reconcile, and
+     * the Host runs that write inside one exclusive transaction. Answering a
+     * press that arrives mid-flight by returning immediately dropped the edit
+     * with no explanation, which is the "the save button stops working after a
+     * few rounds" report (#1754). Serializing instead means a save pressed while
+     * another is still settling runs against the settled state - which is what
+     * the operator meant by pressing it again.
+     * @returns settlement after the mutation and the read-back.
+     */
+    requestSave(): Promise<void>;
     save(): Promise<void>;
     /**
      * Every staged edit a save would write. An entry whose draft is not a value

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

@@ -13,8 +13,10 @@
  */
 import type { TaskStore } from './store.ts';
 import { type NewTaskInput, type TaskRecord, type TaskStatus } from './tasks.ts';
+import { type SetSchedulePatch } from './use-cases/task-schedule.ts';
 import { type TaskUpdatePatch } from './use-cases/task-update.ts';
 import type { TaskBoardAction, TaskBoardEventPayload, TaskBoardParseDraft, TaskBoardParseRequest, TaskBoardSnapshot } from '../protocol.ts';
+import type { TaskBoardExtensionActionRequest, TaskBoardVisibilityPredicate } from './extension.ts';
 export interface TaskBoardTransport {
     bootstrap(legacy: readonly TaskRecord[]): Promise<TaskBoardSnapshot>;
     state(): Promise<TaskBoardSnapshot>;
@@ -110,7 +112,7 @@ export interface ExecutionOptionsSnapshot {
  * (revision/scheduler/power); a full snapshot also carries the deployment
  * constants the UI reads (session default permission, subtask depth).
  */
-export type HostMirror = Pick<TaskBoardSnapshot, 'revision' | 'scheduler' | 'power' | 'sessionDefaultPermission' | 'maxSubtaskDepth' | 'teamRunAvailable'>;
+export type HostMirror = Pick<TaskBoardSnapshot, 'revision' | 'scheduler' | 'power' | 'sessionDefaultPermission' | 'maxSubtaskDepth' | 'teamRunAvailable' | 'goalRunEnabled' | 'extensions'>;
 /** Immutable controller snapshot for UI subscriptions. */
 export interface ControllerSnapshot {
     tasks: readonly TaskRecord[];
@@ -127,6 +129,15 @@ export interface ControllerSnapshot {
     canParseTask?: boolean;
     transportError?: string;
     host?: HostMirror;
+    /**
+     * Provider card-visibility predicates, in registration order. A task shows
+     * only while every predicate accepts it; providers hide their own off-board
+     * cards here instead of the board hard-coding a provider rule. Optional so a
+     * hand-built snapshot (tests, a shell-less composition) defaults to visible.
+     */
+    visibility?: readonly TaskBoardVisibilityPredicate[];
+    /** Read-only summaries published by running extensions, keyed by extension id. */
+    extensions?: Readonly<Record<string, unknown>>;
 }
 /** The selected task (resolved from the ledger), or undefined. */
 export declare function selectedTaskOf(snapshot: ControllerSnapshot): TaskRecord | undefined;
@@ -150,6 +161,8 @@ export declare class BoardController {
     private readonly taskQueues;
     private transportError;
     private hostState;
+    /** Provider visibility predicates (immutable array; replaced on change). */
+    private visibility;
     private remoteSubscribed;
     private remoteInitialization;
     /** @param deps - store and the sessions navigation face. */
@@ -159,6 +172,16 @@ export declare class BoardController {
     /** Stop all subscriptions and drop retained state (idempotent). */
     dispose(): void;
     getSnapshot(): ControllerSnapshot;
+    /**
+     * Register one card-visibility predicate. The returned disposer removes it;
+     * both changes notify subscribers so the board re-renders.
+     */
+    registerVisibility(predicate: TaskBoardVisibilityPredicate): () => void;
+    /**
+     * Deliver one provider action through the board's same-origin channel. A
+     * board without a Host transport (the legacy in-memory path) refuses it.
+     */
+    dispatchExtension(request: TaskBoardExtensionActionRequest): Promise<boolean>;
     subscribe(fn: () => void): () => void;
     /** Whether production mutations are confirmed by the Host transport. */
     isHostBacked(): boolean;
@@ -251,19 +274,31 @@ export declare class BoardController {
     /** Restore an archived task back onto the board (same status column). */
     restoreTask(id: string): boolean;
     /**
-     * Update a task's schedule rule. A blank or invalid cron expression is
-     * rejected (returns false, state untouched). When the rule ends up enabled
-     * the next run instant is computed immediately; a disabled rule carries no
-     * next-run instant. Delegates the domain transition to the schedule use case.
+     * Rename one label across the whole ledger; a name already in use merges the
+     * two labels. Host-backed: the ledger owns the transition and confirms it, so
+     * the board's label row reflects whether the Host accepted the edit.
+     * @returns true when the edit was accepted by the authority.
+     */
+    renameTag(from: string, to: string): Promise<boolean>;
+    /**
+     * Remove one label from every task that carries it, board and archive alike —
+     * the board's label row is drawn from the whole ledger, so a label left on an
+     * archived card would come straight back.
+     * @returns true when the edit was accepted by the authority.
+     */
+    deleteTag(name: string): Promise<boolean>;
+    /**
+     * Update a task's schedule rule. An unusable plan (blank or invalid cron, a
+     * one-shot with no future instant, a non-positive run cap) is rejected
+     * (returns false, state untouched). When the rule ends up enabled the next
+     * run instant is computed immediately — a one-shot's next instant IS its
+     * planned instant — and a disabled rule carries none. Delegates the domain
+     * transition to the schedule use case.
      * @param id - the task to schedule.
      * @param patch - fields to change (absent fields keep their current value).
-     * @returns true when applied, false when rejected (invalid cron / unknown task).
+     * @returns true when applied, false when rejected (unknown task / unusable plan).
      */
-    setSchedule(id: string, patch: {
-        enabled?: boolean;
-        cron?: string;
-        timeZone?: string | null;
-    }): boolean;
+    setSchedule(id: string, patch: SetSchedulePatch): boolean;
     /**
      * Legacy pure-controller seam retained for migration-focused tests. The
      * production browser never rolls schedules; the Host ledger owns them.