@deepseek-ai/dsh-client-ui-schedule 0.2.2-alpha.2 → 0.2.2-alpha.3

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

@@ -15,9 +15,9 @@ export interface ClockPickerProps {
     /** 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.
+     * Whether the panel offers the seconds column (default true). A daily rule
+     * names only its hour and minute, so its form hides the column; a pick then
+     * keeps the staged clock's own seconds.
      */
     readonly seconds?: boolean;
     /** Row copy. */

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

@@ -1,11 +1,12 @@
 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';
+import type { SessionId } from '@deepseek-ai/dsh-session/types';
 /** 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.
+     * Read a newest-first page of one task's saved deliveries.
+     * @param request - Task, 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>>;
@@ -13,17 +14,22 @@ export interface DeliveryHistoryInjected {
 type Cursor = ScheduleDeliveryHistoryRequest['before'];
 type Props = DeliveryHistoryInjected & PropsLocale<'schedule.manager'> & {
     id: ScheduleDeliveryHistoryRequest['id'];
-    sessionId: ScheduleDeliveryHistoryRequest['sessionId'];
+    /** Open the Session that accepted one delivery. */
+    onOpenSession: (id: SessionId) => void;
+    /** Display titles of known Sessions, by id. */
+    sessionTitles: Readonly<Record<string, string>>;
+    /** Sessions that a delivery's open button may open. */
+    availableSessionIds: readonly string[];
     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.
+ * Render immutable saved deliveries; the parent keys this view by task.
  * 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.
+ * @param props - Task, latest receipt identity, Remote callback, Session links, 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 declare function DeliveryHistory({ id, latestMessageId, timeZone, loadHistory, onOpenSession, sessionTitles, availableSessionIds, t, }: Props): import("react").JSX.Element;
 export {};
 //# sourceMappingURL=DeliveryHistory.d.ts.map

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

@@ -0,0 +1,12 @@
+/** Display the Host's effective admission interval before selecting per-run conversations. */
+import { type ReactNode } from 'react';
+import type { PropsLocale } from '@deepseek-ai/dsh-client-ui-slots';
+import type { HostTaskActions } from './TaskDetail.tsx';
+/** Read the configured interval through an injected action; failed reads stay visible and retryable.
+ * @param props - The failure-contained read action and task-manager translations.
+ * @returns The configured interval, a loading indicator, or a retryable failure.
+ */
+export declare function NewSessionLimit({ load, t }: PropsLocale<'schedule.manager'> & {
+    readonly load: HostTaskActions['loadNewSessionInterval'];
+}): ReactNode;
+//# sourceMappingURL=NewSessionLimit.d.ts.map

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

@@ -0,0 +1,22 @@
+import type { ReactNode } from 'react';
+import type { PropsLocale } from '@deepseek-ai/dsh-client-ui-slots';
+import type { TaskMenuEntry } from './TaskMenu.tsx';
+/** A labelled menu row using the current task detail's trigger, portal, and keyboard behavior. */
+export declare function RuleSelectRow({ label, value, current, items, disabled, onChange, onDismiss, header, listClassName }: {
+    readonly label: string;
+    readonly value: string;
+    readonly current: string;
+    readonly items: readonly TaskMenuEntry[];
+    readonly disabled: boolean;
+    readonly onChange: (value: string) => void;
+    readonly onDismiss?: () => void;
+    readonly header?: ReactNode;
+    readonly listClassName?: string | undefined;
+}): ReactNode;
+/** The current task detail's searchable, localized zone menu with recent choices. */
+export declare function RuleZoneRow({ value, disabled, onChange, t }: PropsLocale<'schedule.manager'> & {
+    readonly value: string;
+    readonly disabled: boolean;
+    readonly onChange: (value: string) => void;
+}): ReactNode;
+//# sourceMappingURL=RuleSelectRow.d.ts.map

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

@@ -1,9 +1,9 @@
 import type { InjectFace, PropsLocale, PropsRuntime } from '@deepseek-ai/dsh-client-ui-slots';
-import type { ScheduleId } from '@deepseek-ai/dsh-schedule/client';
+import type { ScheduleId, ScheduleCatalogEntry } 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.utilities'> & PropsLocale<typeof NS> & InjectFace<CatalogInjected & {
+export type ScheduleCatalogActionProps = PropsRuntime<'conversation.session.header.utilities'> & PropsLocale<typeof NS> & InjectFace<CatalogInjected<ScheduleCatalogEntry> & {
     /**
      * Show one task's detail in the right Sidebar for this entry's Session.
      * @param id - Task chosen by the Session entry.

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

@@ -4,6 +4,7 @@ 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';
+import type { TaskEditorStoreProps } from './editor-store.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. */
@@ -20,7 +21,7 @@ export interface ScheduleTaskBindingInjected {
 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>;
+export type ScheduleTaskTabProps = PropsRuntime<'sidebar.right.pane.tab'> & TaskEditorStoreProps & PropsLocale<'schedule.manager'> & InjectFace<ScheduleTaskTabInjected>;
 /**
  * Render the single task named by this tab's navigation parameters or by the
  * binding those parameters last wrote.

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

@@ -1,60 +1,79 @@
 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 { ScheduleCatalogEntry, ScheduleCreateRequest, ScheduleEditRequest, 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';
+import type { TaskEditorStoreProps } from './editor-store.ts';
+/** Localized reason the Host refused an edit, or reason the wiring could not confirm it. */
+export type HostEditFailure = 'host.saveError' | 'host.conflict' | 'host.notFuture' | 'host.invalidRule' | 'detail.missing';
+/** Localized reason the Host refused a run, or reason the wiring could not confirm it. */
+export type HostRunFailure = 'host.runError' | 'host.executionPending' | 'detail.missing';
+/** Creation keeps a failed draft and never creates or activates its destination Session. */
+export type TaskCreateOutcome = {
+    readonly created: ScheduleCatalogEntry;
+} | {
+    readonly failed: 'host.createError' | 'host.notFuture' | 'host.invalidRule';
+};
+/** Target-based mutations supplied by the owning plugin's Remote wiring. */
+export interface HostTaskActions {
+    /**
+     * Apply one edit and refresh the catalog after the Host answers.
+     * @param request - task, change, and the `updatedAt` value that the change started from.
+     * @returns `saved`, or the localized reason the edit did not take effect.
+     */
+    readonly edit: (request: ScheduleEditRequest) => Promise<'saved' | {
+        readonly failed: HostEditFailure;
+    }>;
+    /**
+     * Queue one run now and refresh the catalog after the Host answers.
+     * @param id - task to run.
+     * @returns `queued`, or the localized reason the run did not start.
+     */
+    readonly run: (id: ScheduleId) => Promise<'queued' | {
+        readonly failed: HostRunFailure;
+    }>;
+    /** Read the configured minimum new-conversation interval; undefined means the read failed. */
+    readonly loadNewSessionInterval: () => Promise<number | undefined>;
+}
 /** 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 {
+/** Deletion, Host edit and run, saved-history, and linked-Session actions one task's detail calls. */
+export interface TaskDetailInjected extends DeliveryHistoryInjected {
+    /** Host-owned edit, run, and new-Session interval actions. */
+    readonly hostActions: HostTaskActions;
     /**
-     * Delete one retained task through its original Session binding.
+     * Delete one task.
      * @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,
+     * Reload the catalog after a query failure or an acknowledged edit,
      * 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.
+     * Open an available, unarchived linked conversation after rechecking current metadata.
+     * @param id - Session linked 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;
+type TaskDetailCommonProps = TaskDetailInjected & TaskEditorStoreProps & PropsLocale<'schedule.manager'> & Pick<PropsRuntime<'main'>, 'useSessions' | 'useWorkspaces'> & {
     /** 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. */
+    /** Catalog query state; loading disables saved-task actions. */
     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.
+     * Retain a task while a confirmed deletion and its catalog refresh settle.
      */
-    readonly onEditState: (task: ScheduleCatalogEntry | null) => void;
+    readonly onRetainTask: (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. */
@@ -64,95 +83,51 @@ export type TaskDetailProps = TaskDetailInjected & PropsLocale<'schedule.manager
     /** 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.
+     * Leave the shown task once the Host applied its deletion and the catalog refresh after it
+     * settled: 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. */
+/** New and existing tasks use the same editable page; only submission and saved-task actions differ. */
+export type TaskDetailProps = TaskDetailCommonProps & ({
+    readonly task: ScheduleCatalogEntry;
+    readonly authoritative: boolean;
+    readonly onCreateTask?: never;
+    readonly onCreated?: never;
+} | {
+    readonly task?: undefined;
+    readonly authoritative?: never;
+    readonly onCreateTask: (request: ScheduleCreateRequest) => Promise<TaskCreateOutcome>;
+    readonly onCreated: (task: ScheduleCatalogEntry) => void;
+});
+/** One task detail's selected tab, confirmation, and retained catalog row. */
 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. */
+    /** Task to show: the catalog row, an unsaved draft's baseline, or a confirmed deletion's retained row. */
     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'>;
+    readonly props: Omit<TaskDetailCommonProps, 'onClose' | 'onDeleted'>;
 }
 /**
- * Own the editing state one task detail shares across both of its owners.
+ * Own selected-task state shared by the Tasks page and task tabs.
  *
- * 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.
+ * The shown task comes from the catalog, an unsaved form's CAS baseline, or a
+ * confirmed deletion. The view and confirmation reset when selection changes;
+ * the entry's store retains unsaved fields by task identity.
  * @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;
+export declare function useTaskDetail(injected: TaskDetailInjected & TaskEditorStoreProps & 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.
+ * Render one new or existing task's editable rule or saved deliveries.
+ * @param props - Task, catalog state, detail view, confirmation, locale, and actions.
+ * @returns The detail region and its deletion confirmation dialog.
  */
-export declare function mergeRuleDraft(authoritative: RuleShown, draft: RuleShown, stored: RuleShown): RuleShown;
+export declare function TaskDetail(props: TaskDetailProps): ReactNode;
 export {};
 //# sourceMappingURL=TaskDetail.d.ts.map

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

@@ -0,0 +1,54 @@
+/** Fields shared by manual creation and editing inside the existing Rules view. */
+import type { ReactNode } from 'react';
+import type { PropsLocale } from '@deepseek-ai/dsh-client-ui-slots';
+import type { WorkspaceSnapshot } from '@deepseek-ai/dsh-api-workspace-controller/client';
+import type { ScheduleCatalogEntry, SchedulePatch, ScheduleTargetRequest } from '@deepseek-ai/dsh-schedule/client';
+import type { TimingDraft } from './editor-timing.ts';
+import type { TaskManagerKey } from './task-manager-locales.ts';
+/** Local form values; only Save writes a task. */
+export interface TaskEditorDraft extends TimingDraft {
+    readonly title: string;
+    readonly prompt: string;
+    readonly target: 'session' | 'new_once' | 'new';
+    readonly sessionId: string;
+    readonly cwd: string;
+}
+/** Registered Workspaces offered as the directory of a created Session. */
+interface ProjectChoices {
+    readonly items: readonly {
+        readonly value: string;
+        readonly label: string;
+    }[];
+    /** Directory a new destination starts with: the default Workspace, else the first listed one, else empty. */
+    readonly defaultCwd: string;
+}
+/** Label Workspaces as the Workspace list does and select the directory a new destination starts with. */
+export declare function projectChoices(workspaces: WorkspaceSnapshot['items'], defaultName: string): ProjectChoices;
+/** Initialize a new task without creating or activating a Session. */
+export declare function newTaskDraft(): TaskEditorDraft;
+/** Seed an edit without normalizing unsupported stored rules. */
+export declare function taskDraft(task: ScheduleCatalogEntry): TaskEditorDraft;
+/**
+ * Validate the form while retaining untouched stored timing.
+ * @param draft - Current form values.
+ * @param changes - Existing task patch; omitted validates a new timing as well.
+ * @returns First correction key, `incomplete` for missing required fields, or undefined when valid.
+ */
+export declare function taskDraftIssue(draft: TaskEditorDraft, changes?: SchedulePatch): TaskManagerKey | 'incomplete' | undefined;
+/** Only meaningful field changes enter the CAS edit; untouched timing is never rewritten. */
+export declare function taskDraftPatch(draft: TaskEditorDraft, original: ScheduleCatalogEntry, intervalFromNow?: boolean): SchedulePatch;
+/** Reapply changed field groups only after the user chooses to review a newer revision. */
+export declare function reapplyTaskDraft(draft: TaskEditorDraft, latest: ScheduleCatalogEntry, changes: SchedulePatch): TaskEditorDraft;
+/** Resolve the explicit destination, preserving an existing preset when the project is unchanged. */
+export declare function draftTarget(draft: TaskEditorDraft, original?: ScheduleCatalogEntry): ScheduleTargetRequest;
+/** Render manual creation and inline edits with the existing task rule controls. */
+export declare function TaskEditorFields({ draft, onChange, projects, disabled, original, t }: {
+    readonly draft: TaskEditorDraft;
+    readonly onChange: (draft: TaskEditorDraft) => void;
+    readonly projects: ProjectChoices;
+    readonly disabled: boolean;
+    readonly original?: ScheduleCatalogEntry | undefined;
+    readonly t: PropsLocale<'schedule.manager'>['t'];
+}): ReactNode;
+export {};
+//# sourceMappingURL=TaskEditorFields.d.ts.map

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

@@ -1,5 +1,7 @@
 import type { HostObservable, InjectFace, PropsLocale, PropsRuntime } from '@deepseek-ai/dsh-client-ui-slots';
-import type { ScheduleCatalogEntry } from '@deepseek-ai/dsh-schedule/client';
+import type { ScheduleCatalogEntry, ScheduleCreateRequest } from '@deepseek-ai/dsh-schedule/client';
+import type { TaskCreateOutcome } from './TaskDetail.tsx';
+import type { TaskEditorStoreProps } from './editor-store.ts';
 import type { CatalogSnapshot } from './catalog-source.ts';
 import { type TaskDetailInjected } from './TaskDetail.tsx';
 /** Injected catalog and task actions for the management page. */
@@ -10,7 +12,7 @@ export interface TaskManagerInjected extends TaskDetailInjected {
     };
     /**
      * Start a new Session, where a reminder is created by asking the model to
-     * schedule it. The page deliberately has no creation form of its own.
+     * schedule it, using the existing new-conversation action.
      */
     readonly onNewTask: () => void;
     /**
@@ -23,11 +25,13 @@ export interface TaskManagerInjected extends TaskDetailInjected {
      * @returns resolution after the outcome is reported.
      */
     readonly onClearEnded: () => Promise<void>;
+    /** Create a task directly through the Host, without a model request. */
+    readonly onCreateTask: (request: ScheduleCreateRequest) => Promise<TaskCreateOutcome>;
 }
 /** Root-scoped task catalog props derived from the framework and injected actions. */
-export type TaskManagerPageProps = PropsRuntime<'main'> & InjectFace<TaskManagerInjected> & PropsLocale<'schedule.manager'>;
+export type TaskManagerPageProps = PropsRuntime<'main'> & InjectFace<TaskManagerInjected> & TaskEditorStoreProps & PropsLocale<'schedule.manager'>;
 /**
- * Render retained tasks with authoritative deletion and timing-only edits.
+ * Render retained tasks with manual creation, inline editing, and authoritative deletion.
  * @param props - framework catalog snapshot, localized copy, and action callbacks.
  * @returns the searchable task list beside the selected task's detail.
  */

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

@@ -0,0 +1,50 @@
+/** Shared rule controls taken from the existing task detail. */
+import type { ReactNode } from 'react';
+import type { PropsLocale } from '@deepseek-ai/dsh-client-ui-slots';
+type Weekday = 1 | 2 | 3 | 4 | 5 | 6 | 7;
+/**
+ * Render the weekly rule's Weekday row: one pill per weekday, named by the row's
+ * label and toggled in the rule the caller is editing.
+ * @param props.weekdays - weekdays the rule currently selects, as ISO weekday numbers (Monday is 1).
+ * @param props.disabled - whether the rule's controls are read-only.
+ * @param props.t - frequency translator owning the weekday labels.
+ * @param props.rowId - id builder for the row's label, which names the pill group.
+ * @param props.onToggle - toggle one weekday in the rule being edited.
+ * @returns the labelled Weekday row.
+ */
+export declare function RuleWeekdayRow({ weekdays, disabled, t, rowId, onToggle }: {
+    weekdays: readonly number[];
+    disabled: boolean;
+    t: PropsLocale<'schedule.manager'>['t'];
+    rowId: (name: string) => string;
+    onToggle: (weekday: Weekday) => void;
+}): ReactNode;
+/** Inputs of one whole-number stepper of the task rule form. */
+interface RuleStepperProps {
+    /** Id the row's label points at. */
+    readonly id: string;
+    /** Smallest value the field accepts. */
+    readonly min: number;
+    /** Largest value the field accepts. */
+    readonly max: number;
+    /** Staged value. */
+    readonly value: number;
+    /** Whether every edit is blocked. */
+    readonly disabled: boolean;
+    /** Accessible name of the up arrow. */
+    readonly increaseLabel: string;
+    /** Accessible name of the down arrow. */
+    readonly decreaseLabel: string;
+    /** Stage one clamped whole value. */
+    readonly onChange: (value: number) => void;
+}
+/**
+ * One whole-number stepper of the task rule form, such as the repeat interval or
+ * the day of the month. Values clamp to the field's bounds, and an emptied or
+ * fractional input stages nothing, so the staged rule stays valid on every edit.
+ * @param props - bounds, staged value, blocking state, arrow labels, and callback.
+ * @returns the stepper pill.
+ */
+export declare function RuleStepper({ id, min, max, value, disabled, increaseLabel, decreaseLabel, onChange }: RuleStepperProps): ReactNode;
+export {};
+//# sourceMappingURL=TaskRuleControls.d.ts.map

package/lib/types/client/catalog-source.d.ts

@@ -83,9 +83,12 @@ export interface CatalogInjected<Item extends {
  * Mutations retain visible rows until an authoritative list read succeeds, and
  * each deletion resolves with its own outcome for the caller to report.
  * @param deps - Remote calls and invalidation subscriptions.
- * @returns observable catalog and component callbacks.
+ * @returns observable catalog, component callbacks, and acknowledged-creation retention.
  */
 export declare function createCatalogSource<Item extends {
     readonly id: ScheduleId;
-} = ScheduleRecord>(deps: CatalogDependencies<Item>): CatalogInjected<Item>;
+} = ScheduleRecord>(deps: CatalogDependencies<Item>): CatalogInjected<Item> & {
+    /** Retain a Host-confirmed creation until the next successful catalog read. */
+    readonly retainCreated: (record: Item) => void;
+};
 //# sourceMappingURL=catalog-source.d.ts.map

package/lib/types/client/editor-store.d.ts

@@ -0,0 +1,32 @@
+/** Unsaved task forms survive navigation without persisting business records. */
+import { type EngineStoreHandle } from '@deepseek-ai/dsh-client-store';
+import type { PropsStore } from '@deepseek-ai/dsh-client-ui-slots';
+import type { ScheduleCatalogEntry } from '@deepseek-ai/dsh-schedule/client';
+import type { TaskEditorDraft } from './TaskEditorFields.tsx';
+import type { HostEditFailure, TaskCreateOutcome } from './TaskDetail.tsx';
+type EditorFailure = HostEditFailure | Extract<TaskCreateOutcome, {
+    failed: string;
+}>['failed'];
+interface EditorDraft {
+    readonly draft: TaskEditorDraft;
+    readonly base: ScheduleCatalogEntry | undefined;
+    readonly initial?: TaskEditorDraft;
+    readonly pending?: boolean;
+    readonly failure?: EditorFailure;
+}
+interface EditorState {
+    drafts: Record<string, EditorDraft | undefined>;
+}
+declare const editorActions: {
+    setDraft: (state: EditorState, key: string, draft: EditorDraft) => void;
+    clearDraft: (state: EditorState, key: string) => void;
+};
+/**
+ * Declare drafts retained by the framework for one entry's scope.
+ * @returns the entry's store handle.
+ */
+export declare function createEditorStore(): EngineStoreHandle<EditorState, typeof editorActions>;
+/** Framework-bound selectors and actions; components never receive the store itself. */
+export type TaskEditorStoreProps = PropsStore<ReturnType<typeof createEditorStore>>;
+export {};
+//# sourceMappingURL=editor-store.d.ts.map

package/lib/types/client/editor-timing.d.ts

@@ -0,0 +1,47 @@
+/** Lossless guided and Custom editor projections for typed Schedule timing. */
+import type { ScheduleCatalogEntry, ScheduleTiming } from '@deepseek-ai/dsh-schedule/client';
+/** Periods represented by guided controls, plus a lossless advanced editor. */
+export type FrequencyPreset = 'once' | 'minutely' | 'hourly' | 'daily' | 'weekly' | 'monthly' | 'advanced';
+/** Editable values that determine one typed timing selector. */
+export interface TimingDraft {
+    readonly frequency: FrequencyPreset;
+    readonly interval: string;
+    readonly start: string;
+    readonly timeZone: string;
+    readonly rrule: string;
+    /** Stored typed timing, retained in Custom and used to anchor guided edits to the current period. */
+    readonly retainedTiming?: ScheduleTiming;
+    readonly weekdays: readonly number[];
+    /** Day of the month; a month without that day runs on its last day. */
+    readonly monthDay: number;
+    /** Daily `HH:MM` clock time. */
+    readonly dailyTime: string;
+}
+/**
+ * Initial form values for a new schedule.
+ * @returns Guided timing with a one-hour-ahead one-shot default.
+ */
+export declare function defaultTiming(): TimingDraft;
+/**
+ * Format guided timing as DTSTART and RRULE content lines; return advanced text verbatim.
+ * Draft fields and future occurrences require separate validation.
+ * @param draft - Guided timing values or advanced text.
+ * @param intervalFromNow - Use the current minute for intervals and the current period for edited typed recurrences;
+ * false preserves the draft anchor.
+ * @returns RFC 5545 content lines.
+ */
+export declare function rruleFromDraft(draft: TimingDraft, intervalFromNow?: boolean): string;
+/**
+ * Recover only supported form rules; unknown rules remain verbatim in Advanced mode.
+ * @param record - Stored schedule to edit.
+ * @returns Guided values or the original advanced text.
+ */
+export declare function timingFromRecord(record: ScheduleCatalogEntry): TimingDraft;
+/**
+ * Resolve Custom Cron or RRULE text into its distinct management type.
+ * @param draft - Current rule editor values, including any untouched stored timing.
+ * @param intervalFromNow - Whether saves anchor intervals and edited typed recurrences to the current date and time.
+ * @returns Typed timing for the shared Schedule management API.
+ */
+export declare function timingFromDraft(draft: TimingDraft, intervalFromNow?: boolean): ScheduleTiming;
+//# sourceMappingURL=editor-timing.d.ts.map