@deepseek-ai/dsh-client-ui-schedule 0.1.7-alpha.2 → 0.1.7-rc.2

package/lib/index.js

@@ -1,6 +1,6 @@
 //#region lib/types/index.js
 /**
-* Read-only Schedule catalog plugin, node half. The empty apply keeps the
+* Schedule catalog plugin, node half. The empty apply keeps the
 * optional browser feature addressable from the host-owned Loader overlay.
 */
 /** Host plugin body — Schedule catalog behavior exists only in the browser entry. */

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

@@ -0,0 +1,17 @@
+/** Calendar glyph for the date row's picker trigger. */
+import type { ReactNode } from 'react';
+/** Inputs of the calendar glyph, matching the product icon set's props. */
+export interface CalendarIconProps {
+    /** Extra class for layout placement; color rides currentColor. */
+    readonly className?: string | undefined;
+}
+/**
+ * Draw the 14px calendar outline the Date row's trigger carries.
+ *
+ * The shared product icon set has no calendar glyph, so this package draws the
+ * one its own picker needs, at that set's regular 1px stroke.
+ * @param props - extra class for layout placement.
+ * @returns the decorative glyph.
+ */
+export declare function IconCalendarOutlineRegular({ className }: CalendarIconProps): ReactNode;
+//# sourceMappingURL=CalendarIcon.d.ts.map

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

@@ -0,0 +1,28 @@
+/** Catalog query states shared by the task list, the detail, and the task tab. */
+import type { ReactNode } from 'react';
+import type { PropsLocale } from '@deepseek-ai/dsh-client-ui-slots';
+/** Props of the catalog states: query state, shown content, and the retry action. */
+export type CatalogFeedbackProps = PropsLocale<'schedule.manager'> & {
+    /** Catalog query state; loading and a failed read each render their own state. */
+    readonly status: 'loading' | 'ready' | 'error';
+    /**
+     * Whether catalog content is on screen: shown content keeps a compact
+     * failure notice beside it, while an empty panel centers its states.
+     */
+    readonly populated: boolean;
+    /** Reload the catalog after a query failure. */
+    readonly onRetry: () => Promise<void>;
+};
+/**
+ * Render the catalog's loading and query-failure states.
+ *
+ * An empty panel centers a bare spinner while loading and the failure with its
+ * retry; a panel that already shows content keeps a compact notice for a failed
+ * refresh, and stays silent while a refresh loads, so the retained rows remain
+ * readable. Deletion outcomes are not catalog states: the app-wide toast
+ * announces them.
+ * @param props - query state, whether content is shown, the retry action, and localized copy.
+ * @returns the applicable states, or nothing while the catalog is ready.
+ */
+export declare function CatalogFeedback({ status, populated, onRetry, t }: CatalogFeedbackProps): ReactNode;
+//# sourceMappingURL=CatalogFeedback.d.ts.map

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

@@ -0,0 +1,33 @@
+import type { ReactNode, RefObject } from 'react';
+import type { PropsLocale } from '@deepseek-ai/dsh-client-ui-slots';
+/** Row copy of the task manager namespace, as the pickers receive it. */
+type Translate = PropsLocale<'schedule.manager'>['t'];
+/** Inputs of the clock picker. */
+export interface ClockPickerProps {
+    /** Whether the panel is showing. */
+    readonly open: boolean;
+    /** The row's trigger button, which anchors the panel. */
+    readonly anchorRef: RefObject<HTMLButtonElement | null>;
+    /** The staged clock text. */
+    readonly value: string;
+    /** Stage one picked `HH:MM:SS` clock. */
+    readonly onPick: (time: string) => void;
+    /** Dismiss the panel. */
+    readonly onClose: () => void;
+    /**
+     * Whether the panel offers the seconds column (default true). A cron rule has
+     * no seconds field, so its form hides the column; a pick then keeps the staged
+     * clock's own seconds.
+     */
+    readonly seconds?: boolean;
+    /** Row copy. */
+    readonly t: Translate;
+}
+/**
+ * Render the clock panel: hours, minutes, and optionally seconds, one scrolling column each.
+ * @param props - open state, the trigger, the staged clock, the pick and close callbacks, the seconds-column switch, and row copy.
+ * @returns the anchored panel while open, and nothing while closed.
+ */
+export declare function ClockPicker({ open, anchorRef, value, onPick, onClose, seconds, t }: ClockPickerProps): ReactNode;
+export {};
+//# sourceMappingURL=ClockPicker.d.ts.map

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

@@ -0,0 +1,27 @@
+import type { ReactNode, RefObject } from 'react';
+import type { PropsLocale } from '@deepseek-ai/dsh-client-ui-slots';
+/** Row copy of the task manager namespace, as the pickers receive it. */
+type Translate = PropsLocale<'schedule.manager'>['t'];
+/** Inputs of the date picker. */
+export interface DatePickerProps {
+    /** Whether the panel is showing. */
+    readonly open: boolean;
+    /** The row's trigger button, which anchors the panel. */
+    readonly anchorRef: RefObject<HTMLButtonElement | null>;
+    /** The staged ISO date. */
+    readonly value: string;
+    /** Stage one picked ISO date. */
+    readonly onPick: (date: string) => void;
+    /** Dismiss the panel. */
+    readonly onClose: () => void;
+    /** Row copy. */
+    readonly t: Translate;
+}
+/**
+ * Render the month panel: one localized heading row over weeks of day cells.
+ * @param props - open state, the trigger, the staged date, the pick and close callbacks, and row copy.
+ * @returns the anchored panel while open, and nothing while closed.
+ */
+export declare function DatePicker({ open, anchorRef, value, onPick, onClose, t }: DatePickerProps): ReactNode;
+export {};
+//# sourceMappingURL=DatePicker.d.ts.map

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

@@ -0,0 +1,47 @@
+/**
+ * Transient outcome notice for schedule deletions.
+ *
+ * Every deletion — the Tasks page detail, the session task tab, and the
+ * Session-header popover — reports its settled outcome into one store, and one
+ * `shell.overlay` entry renders it as the app-wide banner. The surfaces keep no
+ * in-place deletion notice of their own, so an outcome outlives the panel or
+ * tab that asked for it.
+ */
+import type { ReactNode } from 'react';
+import type { HostObservable, InjectFace, PropsLocale, PropsRuntime } from '@deepseek-ai/dsh-client-ui-slots';
+import type { CatalogDeleteOutcome } from './catalog-source.ts';
+/** One reported deletion outcome; `seq` keys the banner so a re-show restarts it. */
+export interface DeleteToastState {
+    readonly kind: 'deleted' | 'deleteFailed';
+    readonly seq: number;
+}
+/** Store the deletion wiring reports into and the overlay entry reads. */
+export interface DeleteToastSource {
+    /** Current notice for the overlay entry, or null while none shows. */
+    readonly hooks: {
+        readonly toast: HostObservable<DeleteToastState | null>;
+    };
+    /**
+     * Show the notice of one settled deletion; 'pending' raises nothing because
+     * the deletion already in flight reports its own outcome.
+     * @param outcome - resolution of `CatalogInjected.onDelete`.
+     */
+    readonly report: (outcome: CatalogDeleteOutcome) => void;
+    /** Clear the shown notice. */
+    readonly dismiss: () => void;
+}
+/**
+ * Create the one deletion-outcome store the overlay entry shows.
+ * @returns the observable notice with its report and dismiss actions.
+ */
+export declare function createDeleteToastSource(): DeleteToastSource;
+/** Props of the `shell.overlay` entry: the notice store and localized copy. */
+export type ScheduleDeleteToastProps = PropsRuntime<'shell.overlay'> & PropsLocale<'schedule.manager'> & InjectFace<Omit<DeleteToastSource, 'report'>>;
+/**
+ * Render the current deletion notice: a success banner for a confirmed
+ * deletion, a warning for one that could not be confirmed, or nothing.
+ * @param props - the notice hook, its dismissal, and the locale seat.
+ * @returns the banner on display, or null.
+ */
+export declare function ScheduleDeleteToast({ useToast, dismiss, t }: ScheduleDeleteToastProps): ReactNode;
+//# sourceMappingURL=DeleteToast.d.ts.map

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

@@ -0,0 +1,29 @@
+import type { RemoteResult } from '@deepseek-ai/dsh-api-remotes/client';
+import type { PropsLocale } from '@deepseek-ai/dsh-client-ui-slots';
+import type { ScheduleDeliveryHistoryRequest, ScheduleDeliveryHistoryResult } from '@deepseek-ai/dsh-schedule/client';
+/** Read saved records without opening or activating the original Session. */
+export interface DeliveryHistoryInjected {
+    /**
+     * Read a newest-first page for the exact task and Session.
+     * @param request - Task binding, required page size, and optional older-page cursor.
+     * @returns Remote success or failure; transport exceptions may reject the promise.
+     */
+    readonly loadHistory: (request: ScheduleDeliveryHistoryRequest) => Promise<RemoteResult<ScheduleDeliveryHistoryResult>>;
+}
+type Cursor = ScheduleDeliveryHistoryRequest['before'];
+type Props = DeliveryHistoryInjected & PropsLocale<'schedule.manager'> & {
+    id: ScheduleDeliveryHistoryRequest['id'];
+    sessionId: ScheduleDeliveryHistoryRequest['sessionId'];
+    latestMessageId: Cursor;
+    /** IANA zone of the task's own wall-clock rule; undefined for a one-shot or interval task. */
+    timeZone?: string | undefined;
+};
+/**
+ * Render immutable saved deliveries; the parent keys this view by task and Session.
+ * Refreshes supersede pending older pages, and unmount ignores both late outcomes.
+ * @param props - Exact task binding, latest receipt identity, Remote callback, task zone, and locale.
+ * @returns Saved records and explicit loading, failure, and pagination actions.
+ */
+export declare function DeliveryHistory({ id, sessionId, latestMessageId, timeZone, loadHistory, t }: Props): import("react").JSX.Element;
+export {};
+//# sourceMappingURL=DeliveryHistory.d.ts.map

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

@@ -0,0 +1,27 @@
+import type { ReactNode, RefObject } from 'react';
+/** Inputs of the picker shell. */
+export interface PickerPopoverProps {
+    /** Whether the panel is mounted. */
+    readonly open: boolean;
+    /** The row's trigger button, which anchors the panel and counts as inside for dismissal. */
+    readonly anchorRef: RefObject<HTMLElement | null>;
+    /** Accessible name of the panel. */
+    readonly label: string;
+    /** Layout class of this picker's contents.
+     * (`| undefined` for exactOptionalPropertyTypes: the CSS module types every class as optional.) */
+    readonly className: string | undefined;
+    /** Dismiss the panel. */
+    readonly onClose: () => void;
+    /** The picker's columns or month grid. */
+    readonly children: ReactNode;
+}
+/**
+ * Render one picker panel into `document.body`, fixed below its trigger.
+ *
+ * The panel is a portal, so an ancestor's `overflow` cannot crop it, and a
+ * pointerdown outside both the trigger and the panel dismisses it.
+ * @param props - open state, the trigger, the panel name and layout class, the dismissal callback, and the contents.
+ * @returns the panel while open, and nothing while closed.
+ */
+export declare function PickerPopover({ open, anchorRef, label, className, onClose, children }: PickerPopoverProps): ReactNode;
+//# sourceMappingURL=PickerPopover.d.ts.map

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

@@ -1,16 +1,15 @@
-import type { ScheduleRecord } from '@deepseek-ai/dsh-schedule/client';
-import type { PropsLocale, PropsRuntime, TranslateNS } from '@deepseek-ai/dsh-client-ui-slots';
+import type { InjectFace, PropsLocale, PropsRuntime } from '@deepseek-ai/dsh-client-ui-slots';
+import type { ScheduleId } from '@deepseek-ai/dsh-schedule/client';
+import type { CatalogInjected } from './catalog-source.ts';
 import { NS } from './locales.ts';
 /** Full props for the Session-header Schedule catalog action. */
-export type ScheduleCatalogActionProps = PropsRuntime<'conversation.session.header.actions'> & PropsLocale<typeof NS>;
-/** Pick the largest exact whole unit without rounding the durable interval. */
-export declare function formatScheduleFrequency(record: ScheduleRecord, t: TranslateNS<typeof NS>): string;
-/** Format the durable UTC target in the browser's current locale and time zone. */
-export declare function formatScheduleLocalTime(scheduledAt: string, locale?: string): string;
-/** Human relative target using the largest natural clock unit. */
-export declare function formatScheduleRelative(scheduledAt: string, now: number, t: TranslateNS<typeof NS>): string;
-/** Overdue records first, then ascending target time; exact ties stay stable. */
-export declare function orderScheduleRecords(records: readonly ScheduleRecord[], now: number): ScheduleRecord[];
-/** Read-only current-Session active reminder catalog. */
-export declare function ScheduleCatalogAction({ useSession, useProjection, t }: ScheduleCatalogActionProps): import("react").JSX.Element | null;
+export type ScheduleCatalogActionProps = PropsRuntime<'conversation.session.header.utilities'> & PropsLocale<typeof NS> & InjectFace<CatalogInjected & {
+    /**
+     * Show one task's detail in the right Sidebar for this entry's Session.
+     * @param id - Task chosen by the Session entry.
+     */
+    readonly openTaskDetail: (id: ScheduleId) => void;
+}>;
+/** Current-Session reminder catalog with durable deletion. */
+export declare function ScheduleCatalogAction({ useSession, useCatalog, onDelete, onRetry, openTaskDetail, t, }: ScheduleCatalogActionProps): import("react").JSX.Element | null;
 //# sourceMappingURL=ScheduleCatalogAction.d.ts.map

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

@@ -0,0 +1,37 @@
+import type { InjectFace, PropsLocale } from '@deepseek-ai/dsh-client-ui-slots';
+import type { ToolCallViewProps } from '@deepseek-ai/dsh-client-ui-tool/client';
+import type { ScheduleId, ScheduleRecord } from '@deepseek-ai/dsh-schedule/client';
+/** Task navigation the card receives from its Turn-tail registration. */
+export interface ScheduleCreateCardInjected {
+    /**
+     * Show one created task's detail in the right Sidebar.
+     * @param id - Task created by this call.
+     */
+    readonly openTaskDetail: (id: ScheduleId) => void;
+}
+/** Props of the `schedule_create` transcript card. */
+export type ScheduleCreateCardProps = ToolCallViewProps & PropsLocale<'schedule.manager'> & InjectFace<ScheduleCreateCardInjected> & {
+    readonly currentTask?: ScheduleRecord | null;
+};
+/**
+ * Fields one card reads.
+ *
+ * The keyed Tool seat also carries the owner's file opener, image loader, and
+ * workspace facts; this card reads none of them, so the Turn tail that renders
+ * it supplies these fields alone and a template that starts reading another
+ * owner field fails to compile here.
+ */
+export type ScheduleCreateCardInput = Pick<ScheduleCreateCardProps, 'callId' | 'toolName' | 'block' | 'openTaskDetail' | 't' | 'currentTask'>;
+/**
+ * Render one `schedule_create` call as the created task's card.
+ *
+ * A settled result yields the task's title, its localized frequency, and the
+ * button that opens that task's right-Sidebar detail. A running call, a failed
+ * creation, or a replayed result with no complete task renders its title and
+ * raw result text with no open action, so the card never presents an identity
+ * it does not have.
+ * @param props - the settled card payload, injected task navigation, and copy.
+ * @returns the created task's transcript card.
+ */
+export declare function ScheduleCreateCard({ block, toolName, openTaskDetail, t, currentTask }: ScheduleCreateCardInput): import("react").JSX.Element;
+//# sourceMappingURL=ScheduleCreateCard.d.ts.map

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

@@ -0,0 +1,36 @@
+import type { ReactNode } from 'react';
+import type { HostObservable, InjectFace, PropsLocale, PropsRuntime } from '@deepseek-ai/dsh-client-ui-slots';
+import type { ScheduleCatalogEntry } from '@deepseek-ai/dsh-schedule/client';
+import type { CatalogSnapshot } from './catalog-source.ts';
+import { type TaskDetailInjected } from './TaskDetail.tsx';
+import type { TaskTabBindings } from './task-tab-bindings.ts';
+/** The Host task catalog the body, its chip, and the Tasks page all read. */
+export interface ScheduleTaskCatalogInjected {
+    /** Shared Host task catalog with its query and deletion state. */
+    readonly hooks: {
+        readonly catalog: HostObservable<CatalogSnapshot<ScheduleCatalogEntry>>;
+    };
+}
+/** The provider-owned recovery a restored tab page resolves its task through. */
+export interface ScheduleTaskBindingInjected {
+    /** Durable binding from one task tab page to the task it last showed. */
+    readonly taskBindings: TaskTabBindings;
+}
+/** Everything the task tab's body needs injected. */
+export interface ScheduleTaskTabInjected extends TaskDetailInjected, ScheduleTaskCatalogInjected, ScheduleTaskBindingInjected {
+}
+/** Props of the task tab's body: the tab it draws, localized copy, and its catalog face. */
+export type ScheduleTaskTabProps = PropsRuntime<'sidebar.right.pane.tab'> & PropsLocale<'schedule.manager'> & InjectFace<ScheduleTaskTabInjected>;
+/**
+ * Render the single task named by this tab's navigation parameters or by the
+ * binding those parameters last wrote.
+ *
+ * When neither names a task, the body reports the catalog feedback until a read
+ * requested after the baseline for the current navigation succeeds without the
+ * task; the missing-task state then covers both an unbound restored tab and a
+ * navigated tab whose task is gone.
+ * @param props - tab information, the Host task catalog, localized copy, and action callbacks.
+ * @returns the task's detail, or its centered loading, query-failure, or missing-task state.
+ */
+export declare function ScheduleTaskTab(props: ScheduleTaskTabProps): ReactNode;
+//# sourceMappingURL=ScheduleTaskTab.d.ts.map

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

@@ -0,0 +1,21 @@
+/**
+ * The task tab's chip: the shown task's stored title, or the detail label while
+ * the shared catalog has no row for it yet. Registered under
+ * `sidebar.right.pane.tab.title`; without it the chip would show the constant
+ * text the definition captured at open time, which names no task.
+ *
+ * A restored record carries no navigation parameters, so the chip resolves the
+ * same provider-owned binding its body does and keeps naming the shown task.
+ */
+import type { ReactNode } from 'react';
+import type { InjectFace, PropsLocale, PropsRuntime } from '@deepseek-ai/dsh-client-ui-slots';
+import type { ScheduleTaskBindingInjected, ScheduleTaskCatalogInjected } from './ScheduleTaskTab.tsx';
+/** Props of the task tab's chip: the tab it names and the catalog row it reads. */
+export type ScheduleTaskTabTitleProps = PropsRuntime<'sidebar.right.pane.tab.title'> & PropsLocale<'schedule.manager'> & InjectFace<ScheduleTaskCatalogInjected & ScheduleTaskBindingInjected>;
+/**
+ * Render the clock glyph and the named task's stored title as the chip text.
+ * @param props - tab information, the Host task catalog, the tab bindings, and localized copy.
+ * @returns the clock glyph followed by the task's stored title, or the detail label without a catalog row.
+ */
+export declare function ScheduleTaskTabTitle({ sessionId, useTabInfo, useCatalog, taskBindings, t }: ScheduleTaskTabTitleProps): ReactNode;
+//# sourceMappingURL=ScheduleTaskTabTitle.d.ts.map

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

@@ -0,0 +1,25 @@
+import type { InjectFace, PropsLocale, PropsRuntime } from '@deepseek-ai/dsh-client-ui-slots';
+import type { ScheduleCatalogEntry, ScheduleId } from '@deepseek-ai/dsh-schedule/client';
+import type { CatalogInjected } from './catalog-source.ts';
+/** Task navigation the turn row receives from its list registration. */
+export interface ScheduleTurnCardInjected extends Pick<CatalogInjected<ScheduleCatalogEntry>, 'hooks' | 'onRetry'> {
+    /**
+     * Show one created task's detail in the right Sidebar.
+     * @param id - Task created by this Turn.
+     */
+    readonly openTaskDetail: (id: ScheduleId) => void;
+}
+/** Props of the created-task row of one Turn tail. */
+export type ScheduleTurnCardProps = PropsRuntime<'conversation.chat.turnTail'> & InjectFace<ScheduleTurnCardInjected> & PropsLocale<'schedule.manager'>;
+/**
+ * Render the tasks one Turn created as standalone cards beneath its closing
+ * prose.
+ *
+ * The Turn tail is a list seat independent of the Turn's process disclosure,
+ * so the cards stay visible while the Tool group is collapsed. Every list entry
+ * renders for every Turn, so this one narrows its own Turn here.
+ * @param props - closing Turn owner currency, turn-tail navigation, and copy.
+ * @returns one created-task card per settled `schedule_create` result, or null when the Turn created none.
+ */
+export declare function ScheduleTurnCard(props: ScheduleTurnCardProps): import("react").JSX.Element | null;
+//# sourceMappingURL=ScheduleTurnCard.d.ts.map

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

@@ -0,0 +1,34 @@
+/**
+ * Scheduled-task section of the Sidebar Session-row hover card.
+ *
+ * The row's own card already carries the Session title, its relative time, and
+ * the trailing status line; this seat contributes the Session's active tasks
+ * between them. It is mounted only while the card is open, and it projects the
+ * one shared Host task catalog onto the hovered Session.
+ */
+import type { InjectFace, PropsLocale, PropsRuntime } from '@deepseek-ai/dsh-client-ui-slots';
+import { type SessionScheduleCatalogObservable } from './session-schedule-state.ts';
+import { NS } from './locales.ts';
+/** Most task rows one hover card shows before it reports the omitted remainder. */
+export declare const SESSION_HOVER_TASK_LIMIT = 2;
+/** Injected share of the Session-row hover-card task section: the shared Host task catalog. */
+export interface SessionScheduleHoverInjected {
+    /** One catalog shared by every row; the renderer binds it to the `useCatalog` selector hook. */
+    readonly hooks: {
+        readonly catalog: SessionScheduleCatalogObservable;
+    };
+}
+/** Full props of the Session-row hover-card task section. */
+export type SessionScheduleHoverProps = PropsRuntime<'sidebar.session.row.hover'> & PropsLocale<typeof NS> & InjectFace<SessionScheduleHoverInjected>;
+/**
+ * Render up to {@link SESSION_HOVER_TASK_LIMIT} overdue-first task rows.
+ *
+ * The reference clock is sampled once per mount: the card is a long-hover
+ * preview, so its "next run" text must not drift while the pointer rests.
+ * @param props.sessionId - Session this row shows.
+ * @param props.useCatalog - selector hook over the shared Host task catalog.
+ * @param props.t - Schedule catalog locale seat.
+ * @returns the task rows plus an omission line, or nothing without an active task.
+ */
+export declare function SessionScheduleHover({ sessionId, useCatalog, t, }: SessionScheduleHoverProps): import("react").JSX.Element | null;
+//# sourceMappingURL=SessionScheduleHover.d.ts.map

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

@@ -0,0 +1,31 @@
+/**
+ * Sidebar Session-row clock mark: one Session's active scheduled-task
+ * indicator, seated in the row's leading 16px cell before the title.
+ *
+ * The row offers that cell to this seat only while its own primary state is
+ * idle, so an approval request, a new message, or live activity keeps the
+ * row's state dot in the same cell and never mounts the mark. The mark
+ * projects the one shared Host task catalog onto this Session; it activates,
+ * retains, and unarchives nothing, and it never reads a Session log.
+ */
+import type { InjectFace, PropsLocale, PropsRuntime } from '@deepseek-ai/dsh-client-ui-slots';
+import { type SessionScheduleCatalogObservable } from './session-schedule-state.ts';
+import { NS } from './locales.ts';
+/** Injected share of the Session-row clock mark: the shared Host task catalog. */
+export interface SessionScheduleMarkInjected {
+    /** One catalog shared by every row; the renderer binds it to the `useCatalog` selector hook. */
+    readonly hooks: {
+        readonly catalog: SessionScheduleCatalogObservable;
+    };
+}
+/** Full props of the Session-row clock mark. */
+export type SessionScheduleMarkProps = PropsRuntime<'sidebar.session.row.leading'> & PropsLocale<typeof NS> & InjectFace<SessionScheduleMarkInjected>;
+/**
+ * Render the clock mark while this Session's active tasks are non-empty.
+ * @param props.sessionId - Session this row shows.
+ * @param props.useCatalog - selector hook over the shared Host task catalog.
+ * @param props.t - Schedule catalog locale seat.
+ * @returns the mark, or nothing while the read is unresolved, failed, ended, or empty.
+ */
+export declare function SessionScheduleMark({ sessionId, useCatalog, t, }: SessionScheduleMarkProps): import("react").JSX.Element | null;
+//# sourceMappingURL=SessionScheduleMark.d.ts.map

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

@@ -0,0 +1,158 @@
+import type { ReactNode } from 'react';
+import type { PropsLocale, PropsRuntime } from '@deepseek-ai/dsh-client-ui-slots';
+import type { ScheduleCatalogEntry, ScheduleId } from '@deepseek-ai/dsh-schedule/client';
+import type { SessionId } from '@deepseek-ai/dsh-session/types';
+import { type DeliveryHistoryInjected } from './DeliveryHistory.tsx';
+import type { CatalogDeleteOutcome, CatalogSnapshot } from './catalog-source.ts';
+import type { TaskTimingInjected, TimingDraft } from './task-timing.ts';
+/** The two views of one task's detail: its rule, or its saved delivery records. */
+export type TaskDetailTab = 'rule' | 'records';
+/** One recurrence choice a retained task can be switched to. */
+type RuleKind = 'daily' | 'weekdays' | 'weekly' | 'every' | 'once' | 'cron';
+/** ISO weekdays of the weekly choice in display order, Monday through Sunday. */
+declare const WEEKDAYS: readonly [1, 2, 3, 4, 5, 6, 7];
+/** One ISO weekday of the weekly choice. */
+type Weekday = (typeof WEEKDAYS)[number];
+/**
+ * Deletion, name/instruction/timing updates, saved-history, and original-Session
+ * actions one task's detail calls.
+ */
+export interface TaskDetailInjected extends DeliveryHistoryInjected, TaskTimingInjected {
+    /**
+     * Delete one retained task through its original Session binding.
+     * @param id - Task shown in this detail.
+     * @returns The deletion's outcome after the Remote acknowledgement and
+     * authoritative refresh; the wiring reports it as the app-wide toast.
+     */
+    readonly onDelete: (id: ScheduleId) => Promise<CatalogDeleteOutcome>;
+    /**
+     * Reload the catalog after a query failure or an acknowledged timing update,
+     * and from a surface that needs a read newer than its own record.
+     * @param since - request ordinal the caller last observed, 0 to share any read in flight.
+     * @returns Resolution after publishing the read result; failures remain in catalog state.
+     */
+    readonly onRetry: (since?: number) => Promise<void>;
+    /**
+     * Open an available, unarchived original conversation after rechecking current metadata.
+     * @param id - Session bound to the shown task.
+     */
+    readonly onOpenSession: (id: SessionId) => void;
+}
+/** One task's detail, as the Tasks page and the task tab both compose it. */
+export type TaskDetailProps = TaskDetailInjected & PropsLocale<'schedule.manager'> & Pick<PropsRuntime<'main'>, 'useSessions' | 'useWorkspaces'> & {
+    /** Task shown; an authoritative catalog row refreshes on its own, without an edit draft. */
+    readonly task: ScheduleCatalogEntry;
+    /** Whether an authoritative catalog row backs the shown task; a draft alone disables deletion. */
+    readonly authoritative: boolean;
+    /** Element id shared by the detail panels and any control that points at them. */
+    readonly id: string;
+    /** Catalog query state; loading keeps every action visible and disabled. */
+    readonly status: 'loading' | 'ready' | 'error';
+    /** Tasks with a deletion in flight. */
+    readonly deleting: readonly ScheduleId[];
+    /**
+     * Report the shown task so its owner retains it while an update is pending
+     * or failed, or while a confirmed deletion awaits the refreshed catalog.
+     */
+    readonly onEditState: (task: ScheduleCatalogEntry | null) => void;
+    /** Active detail view; the owner resets it to Rules when it selects another task. */
+    readonly tab: TaskDetailTab;
+    /** Select the active detail view. */
+    readonly onTabChange: (tab: TaskDetailTab) => void;
+    /** Task whose deletion confirmation the owner asked for, or null when none is open. */
+    readonly confirmId: ScheduleId | null;
+    /** Ask for one task's deletion confirmation, or dismiss it with null. */
+    readonly onConfirm: (id: ScheduleId | null) => void;
+    /**
+     * Leave the shown task once the refreshed catalog confirms its deletion:
+     * the Tasks page clears its selection and the session task tab closes.
+     */
+    readonly onDeleted: () => void;
+    /** Close this detail; a view with no list to return to omits the control. */
+    readonly onClose?: () => void;
+    /** Session whose Sidebar hosts this detail; a task linked to it omits the redundant original-Session entry. */
+    readonly withinSession?: SessionId;
+};
+/** One task detail's editing state, as its Tasks page or task tab owns it. */
+export interface TaskDetailController {
+    /** Catalog row the shown id resolves to, or undefined when the read has no such row. */
+    readonly record: ScheduleCatalogEntry | undefined;
+    /** Task to show: the catalog row, or the draft a pending or failed mutation retained. */
+    readonly task: ScheduleCatalogEntry | undefined;
+    /** Element id shared by the detail panels and any control that points at them. */
+    readonly id: string;
+    /** Task whose deletion confirmation is open, or null when none is. */
+    readonly confirmId: ScheduleId | null;
+    /** Ask for one task's deletion confirmation, or dismiss it with null. */
+    readonly setConfirmId: (id: ScheduleId | null) => void;
+    /** Select the active detail view. */
+    readonly setTab: (tab: TaskDetailTab) => void;
+    /** Props the shared detail element takes, without the task it shows. */
+    readonly props: Omit<TaskDetailProps, 'task' | 'authoritative' | 'onClose' | 'onDeleted'>;
+}
+/**
+ * Own the editing state one task detail shares across both of its owners.
+ *
+ * The shown task is the catalog row for `taskId`, or the draft a mutation
+ * pending against that row retained after the row left the catalog. The view,
+ * the confirmation, and the draft all reset when `taskId` changes, so one
+ * task's draft never carries into another.
+ * @param injected - detail actions, localized copy, and framework readers.
+ * @param catalog - the owner's authoritative task catalog snapshot.
+ * @param taskId - task the owner selected, or undefined when it selected none.
+ * @returns the shown task and catalog row, its element id, its confirmation, and the detail props.
+ */
+export declare function useTaskDetail(injected: TaskDetailInjected & PropsLocale<'schedule.manager'> & Pick<PropsRuntime<'main'>, 'useSessions' | 'useWorkspaces'>, catalog: CatalogSnapshot<ScheduleCatalogEntry>, taskId: ScheduleId | undefined): TaskDetailController;
+/**
+ * Render one task's rule or saved deliveries with confirm-first deletion and its original Session.
+ *
+ * A deletion this detail confirmed settles with the refreshed catalog: once
+ * that refresh reports the row gone, the detail calls `onDeleted` and its owner
+ * leaves the task. The app-wide toast, not this detail, announces the outcome.
+ * @param props - task, catalog state, detail view, confirmation, localized copy, and action callbacks.
+ * @returns the detail region, its deletion confirmation dialog, and the linked Session entry.
+ */
+export declare function TaskDetail({ task, authoritative, id, status, deleting, onDelete, onRetry, onUpdateTiming, loadHistory, onOpenSession, onEditState, tab, onTabChange, confirmId, onConfirm, onDeleted, onClose, withinSession, useSessions, useWorkspaces, t, }: TaskDetailProps): ReactNode;
+/** Values one task's detail stages, seeded from one stored record. */
+interface RuleShown {
+    /** Task name the heading control edits. */
+    readonly title: string;
+    /** Reminder instruction the instruction control edits. */
+    readonly prompt: string;
+    /** Recurrence choice the rows edit. */
+    readonly kind: RuleKind;
+    /** Native time inputs the choice edits. */
+    readonly draft: TimingDraft;
+    /** ISO weekday set the weekly choice edits; other choices never read it. */
+    readonly weekdays: readonly Weekday[];
+}
+/**
+ * Merge one refreshed authoritative record into a staged draft.
+ *
+ * Three cases, because a rule kind and the fields that describe it are one
+ * value. The Monday-to-Friday choice and the weekly choice state the same Host
+ * weekly rule, so the comparisons below fold them together and only the day set
+ * tells them apart.
+ *
+ * The draft stages another kind than the stored record. Its fields describe a
+ * rule the refreshed record does not state, so the draft keeps them whole.
+ *
+ * The draft stages the stored kind, and the refreshed record changed that kind.
+ * The two rules cannot be mixed, so the draft is kept whole when the user edited
+ * it and the refreshed rule is adopted whole when the user did not.
+ *
+ * All three kinds agree. Only here can one field differ legitimately on each
+ * side, so the fields merge on their own: a field the user changed keeps the
+ * draft value and every other field takes the refreshed record, which is what
+ * carries a concurrent remote timing edit into an unrelated local edit.
+ *
+ * The name and the instruction merge field by field in every case: another
+ * client's rename reaches this detail even while a rule change is staged.
+ * @param authoritative - values of the refreshed record.
+ * @param draft - values the detail currently shows.
+ * @param stored - authoritative values the draft was compared against.
+ * @returns the merged values.
+ */
+export declare function mergeRuleDraft(authoritative: RuleShown, draft: RuleShown, stored: RuleShown): RuleShown;
+export {};
+//# sourceMappingURL=TaskDetail.d.ts.map

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

@@ -0,0 +1,11 @@
+import type { PropsRuntime } from '@deepseek-ai/dsh-client-ui-slots';
+/**
+ * Render the clock glyph at the size the sidebar asks for; the sidebar owns
+ * its accessible navigation label. The glyph is the row's direct icon child,
+ * as on every other panel row: an inline wrapper makes it the baseline of a
+ * line box inside the row's glyph slot, which lifts it above the label.
+ * @param props - the sidebar's icon share: the requested edge and whether the panel is selected.
+ * @returns decorative clock icon.
+ */
+export declare function TaskManagerIcon({ size }: PropsRuntime<'sidebar.panellist'>): import("react").JSX.Element;
+//# sourceMappingURL=TaskManagerIcon.d.ts.map