@linxin666/dsh-client-ui-task-board 0.1.17 → 0.1.19

package/src/client/board/TaskDetail.tsx

@@ -9,6 +9,7 @@ import type { BoardController } from '../../core/controller.ts'
 import { isValidCron } from '../../core/schedule.ts'
 import { MANUAL_STATUSES, TASK_PERMISSIONS, type ExecutionRecord, type TaskPermission, type TaskRecord, type TaskStatus } from '../../core/tasks.ts'
 import { t, type TaskBoardKey } from '../locales.ts'
+import { SCHEDULE_PRESETS } from '../schedule-presets.ts'
 import css from '../board.module.css'
 import { ConfirmDialog } from './ConfirmDialog.tsx'
 import { formatTime } from './TaskCard.tsx'
@@ -58,14 +59,6 @@ function ExecutionRow({ execution, onOpen }: { execution: ExecutionRecord; onOpe
   )
 }
 
-/** Common scheduled-run presets (cron → locale label). */
-const SCHEDULE_PRESETS: ReadonlyArray<{ cron: string; label: TaskBoardKey }> = [
-  { cron: '0 9 * * *', label: 'detail.schedule.preset.daily9' },
-  { cron: '0 * * * *', label: 'detail.schedule.preset.hourly' },
-  { cron: '*/10 * * * *', label: 'detail.schedule.preset.tenMin' },
-  { cron: '0 9 * * 1', label: 'detail.schedule.preset.weeklyMon9' },
-]
-
 /** The execution-target editor: workspace / mode / permission pickers. */
 function ExecutionSettingsSection({ controller, task }: { controller: BoardController; task: TaskRecord }) {
   const [options, setOptions] = useState(controller.getSnapshot().executionOptions)
@@ -324,6 +317,31 @@ export function TaskDetail({ controller, task }: { controller: BoardController;
           >
             {current.executions.length === 0 ? t('detail.run') : t('detail.rerun')}
           </button>
+          {current.archivedAt !== undefined ? (
+            <button
+              type="button"
+              className={css.primaryButton}
+              onClick={() => {
+                controller.restoreTask(current.id)
+                controller.closeTask()
+              }}
+            >
+              {t('detail.restore')}
+            </button>
+          ) : (
+            (current.status === 'done' || current.status === 'failed') && (
+              <button
+                type="button"
+                className={css.ghostButton}
+                onClick={() => {
+                  controller.archiveTask(current.id)
+                  controller.closeTask()
+                }}
+              >
+                {t('detail.archive')}
+              </button>
+            )
+          )}
           <button
             type="button"
             className={css.dangerButton}
@@ -333,6 +351,7 @@ export function TaskDetail({ controller, task }: { controller: BoardController;
           </button>
           <span className={css.detailMeta}>
             {t('board.created')} {formatTime(current.createdAt)}
+            {current.archivedAt !== undefined && ` · ${t('detail.archivedAt', { time: formatTime(current.archivedAt) })}`}
           </span>
         </footer>
       </div>

package/src/client/board.module.css

@@ -18,6 +18,8 @@
   inset: 0;
   display: none;
   z-index: 60;
+  container-name: task-board-view;
+  container-type: inline-size;
   /* Opaque backdrop: the conversation subtree stays mounted under the view.
      Even if the hide rule below were defeated by a stronger host inline
      style, this background keeps sticky code-block banners (host z-index 6)
@@ -103,6 +105,7 @@ html[data-dsh-taskboard-active]:not([data-dsh-ssh-active]) [class*='centerCol']
 .board {
   display: flex;
   flex-direction: column;
+  box-sizing: border-box;
   height: 100%;
   min-width: 0;
   min-height: 0;
@@ -128,6 +131,12 @@ html[data-dsh-taskboard-active]:not([data-dsh-ssh-active]) [class*='centerCol']
   white-space: nowrap;
 }
 
+.backButton {
+  display: inline-flex;
+  align-items: center;
+  gap: 4px;
+}
+
 .search {
   flex: 0 1 260px;
   min-width: 120px;
@@ -148,10 +157,38 @@ html[data-dsh-taskboard-active]:not([data-dsh-ssh-active]) [class*='centerCol']
 
 .columns {
   display: grid;
-  grid-template-columns: repeat(5, minmax(0, 1fr));
+  grid-auto-flow: column;
+  grid-auto-columns: minmax(220px, 1fr);
   gap: 12px;
   flex: 1;
   min-height: 0;
+  overflow-x: auto;
+  overflow-y: hidden;
+  overscroll-behavior-inline: contain;
+  padding-bottom: 6px;
+  scrollbar-color: var(--dsw-alias-border-l3) var(--dsw-alias-interactive-bg-hover);
+  scrollbar-width: thin;
+}
+
+.columns::-webkit-scrollbar {
+  height: 10px;
+}
+
+.columns::-webkit-scrollbar-track {
+  background: var(--dsw-alias-interactive-bg-hover);
+  border-radius: 999px;
+}
+
+.columns::-webkit-scrollbar-thumb {
+  background: var(--dsw-alias-border-l3);
+  background-clip: content-box;
+  border: 2px solid transparent;
+  border-radius: 999px;
+}
+
+.columns::-webkit-scrollbar-thumb:hover {
+  background: var(--dsw-alias-border-l4);
+  background-clip: content-box;
 }
 
 .column {
@@ -770,6 +807,36 @@ html[data-dsh-taskboard-active]:not([data-dsh-ssh-active]) [class*='centerCol']
   color: var(--dsw-alias-label-tertiary);
 }
 
+/* --- constrained board containers ------------------------------------------ */
+
+@container task-board-view (max-width: 720px) {
+  .board {
+    gap: 10px;
+    padding: 10px;
+  }
+
+  .columns {
+    gap: 10px;
+  }
+}
+
+@container task-board-view (max-width: 600px) {
+  .boardHeader {
+    flex-wrap: wrap;
+    gap: 8px;
+  }
+
+  .search {
+    flex: 1 1 calc(100% - 72px);
+    min-width: 0;
+  }
+
+  .boardHeader > button {
+    flex: 1 1 0;
+    min-width: max-content;
+  }
+}
+
 /* -----------------------------------------------------------------------------
  * Polish pass: complete interaction states (hover / active / focus-visible /
  * disabled), unified 120ms motion, and reduced-motion fallback.

package/src/client/index.ts

@@ -92,13 +92,19 @@ export function apply(ctx: ClientContext): void {
   const binder = ctx.get('webUiSettings') ?? ctx.settingsScope
   const settingsScope = binder.bind<TaskBoardSettings>({ namespace: TASK_BOARD_NS })
   const settingsCard = new TaskBoardSettingsCardController(settingsScope)
-  ctx.slots.inject('web-ui.plugin.item', () => ctx.slots.register({
-    name: 'web-ui.plugin.item',
-    id: 'task-board',
-    order: 110,
-    locale: NS,
-    inject: () => settingsCard.inject(),
-  }, TaskBoardSettingsCard))
+  ctx.slots.inject('web-ui.plugin.item', () => {
+    const unregister = ctx.slots.register({
+      name: 'web-ui.plugin.item',
+      id: 'task-board',
+      order: 110,
+      locale: NS,
+      inject: () => settingsCard.inject(),
+    }, TaskBoardSettingsCard)
+    return () => {
+      settingsCard.dispose()
+      unregister()
+    }
+  })
 
   // The sidebar entry and board view mount once the settings scope settles;
   // while the scope is still loading, the composition default is unknown, so
@@ -178,6 +184,9 @@ export function apply(ctx: ClientContext): void {
     // not-yet-ready runtime; tab visibility recovery ticks immediately.
     const scheduler = new SchedulerService({
       tasks: () => controller.getSnapshot().tasks,
+      // Re-read the persisted ledger before every fire decision: a task
+      // deleted in another tab must never fire from a stale in-memory copy.
+      refresh: () => controller.reloadFromStore(),
       now: () => Date.now(),
       runTask: id => controller.runTask(id),
       applySchedule: (id, nextRunAt, lastTriggeredAt) =>

package/src/client/locales.ts

@@ -9,11 +9,15 @@
 export const zh = {
   'entry.label': '任务看板',
   'board.title': '任务看板',
-  'board.close': '返回对话',
+  'board.close': '返回会话',
   'board.new': '新建任务',
   'board.search': '筛选任务…',
   'board.empty': '这个状态还没有任务',
   'board.filterAll': '全部',
+  'board.archive': '归档',
+  'board.archiveView': '归档 ({count})',
+  'board.backToBoard': '返回看板',
+  'archive.empty': '没有已归档的任务',
   'board.status': '状态',
   'board.status.backlog': '待规划',
   'board.status.todo': '待办',
@@ -41,6 +45,9 @@ export const zh = {
   'detail.run': '执行',
   'detail.rerun': '重新执行',
   'detail.delete': '删除',
+  'detail.archive': '归档',
+  'detail.restore': '恢复',
+  'detail.archivedAt': '已归档 · {time}',
   'detail.viewSession': '查看会话',
   'detail.noSession': '暂无会话',
   'detail.executionStarted': '已启动',
@@ -120,6 +127,10 @@ export const en: Record<keyof typeof zh, string> = {
   'board.search': 'Filter tasks…',
   'board.empty': 'No tasks in this column',
   'board.filterAll': 'All',
+  'board.archive': 'Archive',
+  'board.archiveView': 'Archived ({count})',
+  'board.backToBoard': 'Back to board',
+  'archive.empty': 'No archived tasks',
   'board.status': 'Status',
   'board.status.backlog': 'Backlog',
   'board.status.todo': 'To Do',
@@ -147,6 +158,9 @@ export const en: Record<keyof typeof zh, string> = {
   'detail.run': 'Run',
   'detail.rerun': 'Run Again',
   'detail.delete': 'Delete',
+  'detail.archive': 'Archive',
+  'detail.restore': 'Restore',
+  'detail.archivedAt': 'Archived · {time}',
   'detail.viewSession': 'View Session',
   'detail.noSession': 'No session',
   'detail.executionStarted': 'Started',

package/src/client/schedule-presets.ts

@@ -0,0 +1,13 @@
+/**
+ * Shared scheduled-run presets for the schedule editors (the new-task dialog
+ * and the task detail panel): cron expression → locale label.
+ */
+import type { TaskBoardKey } from './locales.ts'
+
+/** Common scheduled-run presets (cron → locale label). */
+export const SCHEDULE_PRESETS: ReadonlyArray<{ cron: string; label: TaskBoardKey }> = [
+  { cron: '0 9 * * *', label: 'detail.schedule.preset.daily9' },
+  { cron: '0 * * * *', label: 'detail.schedule.preset.hourly' },
+  { cron: '*/10 * * * *', label: 'detail.schedule.preset.tenMin' },
+  { cron: '0 9 * * 1', label: 'detail.schedule.preset.weeklyMon9' },
+]

package/src/client/settings-card.module.css

@@ -42,6 +42,15 @@
   outline-offset: -2px;
 }
 
+.headerStatic {
+  width: 100%;
+  border-radius: 12px;
+  align-items: center;
+  gap: 12px;
+  padding: 14px 16px;
+  display: flex;
+}
+
 .headText {
   flex-direction: column;
   flex: 1;

package/src/client/settings-form.ts

@@ -234,6 +234,9 @@ export class CardForm<T> {
   private readonly specs: Map<string, FieldSpec>
   private readonly staged = new Map<string, StagedEdit>()
   private readonly listeners = new Set<() => void>()
+  /** The scope subscription installed in the constructor; released by dispose(). */
+  private readonly disposeScope: () => void
+  private disposed = false
   private saving = false
   private failed = false
   private failedReason: string | undefined
@@ -244,7 +247,18 @@ export class CardForm<T> {
     specs: FieldSpec[],
   ) {
     this.specs = new Map(specs.map(spec => [spec.field, spec]))
-    scope.subscribe(() => { this.publish() })
+    this.disposeScope = scope.subscribe(() => { this.publish() })
+  }
+
+  /**
+   * Release the scope subscription and every bound store listener. The card
+   * must call this on teardown; later calls are no-ops.
+   */
+  dispose(): void {
+    if (this.disposed) return
+    this.disposed = true
+    this.disposeScope()
+    this.listeners.clear()
   }
 
   /** Publish a projection of this form, rebuilt whenever the scope or a draft changes. */

package/src/core/controller.ts

@@ -19,6 +19,7 @@ import {
   settleExecution, startExecution, withStatus,
   type NewTaskInput, type TaskRecord, type TaskStatus,
 } from './tasks.ts'
+import { applyArchiveTask, applyRestoreTask } from './use-cases/task-archive.ts'
 import { applyCreateTask } from './use-cases/task-create.ts'
 import { applyDeleteTask } from './use-cases/task-delete.ts'
 import { applyScheduleNextRun as applyScheduleRollForward, applySetSchedule } from './use-cases/task-schedule.ts'
@@ -74,6 +75,8 @@ export interface ExecutionOptionsSnapshot {
 export interface ControllerSnapshot {
   tasks: readonly TaskRecord[]
   boardOpen: boolean
+  /** True when the board shows the archive view instead of the columns. */
+  archiveView: boolean
   selectedTaskId: string | undefined
   /** Picker option sets (workspace list + agent-preset roster). */
   executionOptions: ExecutionOptionsSnapshot
@@ -86,6 +89,10 @@ export function selectedTaskOf(snapshot: ControllerSnapshot): TaskRecord | undef
 }
 
 function randomUuid(): string {
+  const randomUUID = globalThis.crypto?.randomUUID
+  if (randomUUID !== undefined) {
+    return randomUUID.call(globalThis.crypto!)
+  }
   const bytes = globalThis.crypto?.getRandomValues(new Uint8Array(16))
   if (bytes === undefined) {
     // Non-secure fallback (tests, odd environments).
@@ -109,6 +116,7 @@ function currentOf(sessions: SessionsControllerFace): string | undefined {
 export class BoardController {
   private tasks: TaskRecord[] = []
   private boardOpen = false
+  private archiveView = false
   private selectedTaskId: string | undefined
   private executionOptions: ExecutionOptionsSnapshot = { workspaces: [], presets: [] }
   private listeners = new Set<() => void>()
@@ -157,6 +165,7 @@ export class BoardController {
     return {
       tasks: this.tasks,
       boardOpen: this.boardOpen,
+      archiveView: this.archiveView,
       selectedTaskId: this.selectedTaskId,
       executionOptions: this.executionOptions,
     }
@@ -190,6 +199,20 @@ export class BoardController {
     else this.openBoard()
   }
 
+  /**
+   * Switch between the kanban columns and the archive view. Leaving the
+   * archive view with an archived task still selected closes the selection —
+   * the detail overlay must not linger over a task that is off-board.
+   */
+  toggleArchiveView(): void {
+    this.archiveView = !this.archiveView
+    if (!this.archiveView && this.selectedTaskId !== undefined) {
+      const selected = this.tasks.find(task => task.id === this.selectedTaskId)
+      if (selected?.archivedAt !== undefined) this.selectedTaskId = undefined
+    }
+    this.notify()
+  }
+
   openTask(id: string): void {
     if (this.tasks.some(task => task.id === id)) {
       this.selectedTaskId = id
@@ -239,6 +262,29 @@ export class BoardController {
     this.persistAndNotify()
   }
 
+  /**
+   * Archive a settled task (done/failed). Running or on-board-unsettled
+   * tasks are refused so the runner keeps exclusive ownership of their
+   * lifecycle.
+   * @returns true when applied.
+   */
+  archiveTask(id: string): boolean {
+    const { tasks, archived } = applyArchiveTask(this.tasks, id, this.now())
+    if (!archived) return false
+    this.tasks = [...tasks]
+    this.persistAndNotify()
+    return true
+  }
+
+  /** Restore an archived task back onto the board (same status column). */
+  restoreTask(id: string): boolean {
+    const { tasks, archived } = applyRestoreTask(this.tasks, id, this.now())
+    if (!archived) return false
+    this.tasks = [...tasks]
+    this.persistAndNotify()
+    return true
+  }
+
   // --- scheduling ---------------------------------------------------------------
 
   /**
@@ -269,6 +315,18 @@ export class BoardController {
     this.persistAndNotify()
   }
 
+  /**
+   * Reload the ledger from the persisted store without notifying subscribers.
+   * The scheduler calls this before every tick so a task deleted in another
+   * tab (or a stale in-memory copy) can never be fired from this tab: the
+   * fire decision and the subsequent roll-forward both run on the freshest
+   * persisted truth. Deliberately silent — same-origin external changes still
+   * reach subscribers through the storage-event subscription.
+   */
+  reloadFromStore(): void {
+    this.tasks = this.deps.store.load()
+  }
+
   /**
    * Jump to an execution's session transcript. Selecting the session changes
    * `current`, which closes the board (the conversation view takes over).

package/src/core/execution.ts

@@ -46,6 +46,9 @@ export interface PresetsExecutionFace {
   select(sessionId: string, agentPreset: string): Promise<{ ok: true } | { ok: false; error: unknown }>
 }
 
+/** Settled result of one agent-preset switch, shared by concurrent waiters. */
+type PresetSelectResult = { ok: true } | { ok: false; error: unknown }
+
 /** The narrow workspaces face the service needs. */
 export interface WorkspacesExecutionFace {
   list: {
@@ -137,6 +140,16 @@ function isErrorTurnEnd(data: unknown): boolean {
  *   every failure path is reported as a settled event.
  */
 export class ExecutionService {
+  /**
+   * In-flight preset switches keyed by `sessionId\u0000mode`. The session
+   * list mirror can lag behind a just-applied switch, so concurrent runs
+   * against one blank session would otherwise each issue the same select
+   * RPC (an amplified storm); sharing one in-flight call keeps the wire to
+   * a single request. The settled entry is forgotten so a later run can
+   * switch again.
+   */
+  private readonly presetSwitches = new Map<string, Promise<PresetSelectResult>>()
+
   /** @param env - the runtime faces (real or fake). */
   constructor(private readonly env: ExecutionEnvironment) {}
 
@@ -199,13 +212,18 @@ export class ExecutionService {
       settleFailed(`cannot switch agent preset to ${mode}: the execution session is not blank`)
       return false
     }
+    // Fast path: the list mirror already reports the pinned preset. The
+    // mirror can lag a just-applied switch, though, so this guard alone is
+    // not enough under concurrent runs — `switchPreset` below dedupes the
+    // wire call for the lag window.
     if (summary?.agentPreset === mode) return true
-    if (this.env.presets === undefined) {
+    const presets = this.env.presets
+    if (presets === undefined) {
       settleFailed(`this deployment does not support agent presets (task asks for ${mode})`)
       return false
     }
     try {
-      const result = await this.env.presets.select(sessionId, mode)
+      const result = await this.switchPreset(presets, sessionId, mode)
       if (!result.ok) {
         // A list race can leave the summary without the preset label even
         // though the blank session already runs it; the wire answers that
@@ -227,6 +245,27 @@ export class ExecutionService {
     return true
   }
 
+  /**
+   * One in-flight `select` per (session, preset): concurrent runs against
+   * the same blank session share the same wire call instead of each issuing
+   * a duplicate RPC. The entry is removed once the call settles, so a later
+   * run (after a shared failure, say) issues a fresh switch.
+   */
+  private switchPreset(
+    presets: PresetsExecutionFace,
+    sessionId: string,
+    mode: string,
+  ): Promise<PresetSelectResult> {
+    const key = `${sessionId}\u0000${mode}`
+    const inflight = this.presetSwitches.get(key)
+    if (inflight !== undefined) return inflight
+    const attempt = presets.select(sessionId, mode).finally(() => {
+      if (this.presetSwitches.get(key) === attempt) this.presetSwitches.delete(key)
+    })
+    this.presetSwitches.set(key, attempt)
+    return attempt
+  }
+
   /**
    * Apply the task-pinned permission preset through the `/permission <id>`
    * slash command. No-op when the task pins none; fails the run when the

package/src/core/scheduler.ts

@@ -9,6 +9,11 @@
  * a task still running at its due instant is skipped by the controller's
  * runTask guard and simply waits for the next cron match.
  *
+ * A deleted task can never fire again from a stale in-memory copy: every
+ * tick first re-reads the persisted ledger through the optional `refresh`
+ * hook (the controller reloads its store), so the fire decision and the
+ * subsequent roll-forward both run on the freshest persisted truth.
+ *
  * The ticker is controlled: `start` arms a single interval guarded by an
  * idempotence check (a second start while running is a no-op, so wiring can
  * never leak a duplicate timer), and `stop`/`dispose` clear the timer and
@@ -25,6 +30,13 @@ import type { TaskRecord } from './tasks.ts'
 export interface SchedulerDeps {
   /** Read the current task ledger (the controller snapshot). */
   tasks(): readonly TaskRecord[]
+  /**
+   * Re-sync the task ledger from its persisted source before the tick decides
+   * what is due. The wiring passes the controller's store reload so a task
+   * deleted elsewhere can never be fired from a stale in-memory copy.
+   * Optional: absent in pure in-memory harnesses.
+   */
+  refresh?: () => void
   /** Clock; defaults to Date.now in the controller wiring. */
   now(): number
   /** Trigger one task's real execution (the controller's runTask); resolves
@@ -112,6 +124,9 @@ export class SchedulerService {
   async tick(): Promise<void> {
     if (this.disposed) return
     if (this.deps.ready !== undefined && !this.deps.ready()) return
+    // Freshest persisted truth before any fire decision: a task deleted in
+    // another tab (or a stale in-memory copy) must never be triggered.
+    this.deps.refresh?.()
     const now = this.deps.now()
     for (const task of this.deps.tasks()) {
       const schedule = task.schedule

package/src/core/store.ts

@@ -148,6 +148,7 @@ export function parseLedger(raw: string | null): TaskRecord[] {
     // fall back to the session default instead of dropping the row.
     task.workspaceId = normalizeTargetId(row.workspaceId)
     task.mode = normalizeTargetId(row.mode)
+    task.archivedAt = typeof row.archivedAt === 'number' && Number.isFinite(row.archivedAt) ? row.archivedAt : undefined
     task.permission = isTaskPermission(row.permission) ? row.permission as TaskPermission : undefined
     tasks.push(task)
   }

package/src/core/tasks.ts

@@ -79,8 +79,17 @@ export interface TaskRecord {
    * `/permission <id>` slash command; absent leaves the session default.
    */
   permission?: TaskPermission
+  /**
+   * When the task was archived (ms epoch). Archived tasks keep their status
+   * and execution history but leave the main board; absent means on-board.
+   */
+  archivedAt?: number
 }
 
+/** Statuses a settled task may be archived from. */
+export const ARCHIVABLE_STATUSES: readonly TaskStatus[] = ['done', 'failed']
+
+
 /** Permission presets a task may pin on its execution session (the `/permission <id>` ids). */
 export const TASK_PERMISSIONS = ['read-only', 'workspace-write', 'danger-full-access'] as const
 
@@ -103,6 +112,12 @@ export interface NewTaskInput {
   mode?: string
   /** Permission preset applied to the execution session; absent = session default. */
   permission?: TaskPermission
+  /**
+   * Optional scheduled-run rule requested at creation time (the new-task
+   * dialog): an enable flag plus a 5-field cron expression. The create use
+   * case arms it only when enabled and the expression is valid.
+   */
+  schedule?: { enabled: boolean; cron: string }
 }
 
 /** The five kanban columns, in display order. */

package/src/core/use-cases/task-archive.ts

@@ -0,0 +1,48 @@
+/**
+ * Archive/restore task use case: move a settled (done/failed) task off the
+ * main board and back. Purely a marker transition — the task keeps its
+ * status, execution history and transcript references, so archiving never
+ * loses traceability and restoring lands it in the exact column it left.
+ */
+import type { TaskRecord } from '../tasks.ts'
+import { ARCHIVABLE_STATUSES } from '../tasks.ts'
+
+/** Result of an archive transition. */
+export interface ArchiveTaskResult {
+  /** The next ledger. */
+  tasks: readonly TaskRecord[]
+  /** Whether the archive was applied (false = unknown task / not archivable). */
+  archived: boolean
+}
+
+/**
+ * Archive one task: only settled statuses (done/failed) can be archived;
+ * a running or not-yet-settled task stays on the board (its runner still
+ * owns its lifecycle). Already-archived tasks are a no-op.
+ */
+export function applyArchiveTask(
+  tasks: readonly TaskRecord[],
+  id: string,
+  now: number,
+): ArchiveTaskResult {
+  let applied = false
+  const next = tasks.map(task => {
+    if (task.id !== id || task.archivedAt !== undefined) return task
+    if (!(ARCHIVABLE_STATUSES as readonly string[]).includes(task.status)) return task
+    applied = true
+    return { ...task, archivedAt: now, updatedAt: now }
+  })
+  return { tasks: next, archived: applied }
+}
+
+/** Restore one task back onto the main board (clears the archive marker). */
+export function applyRestoreTask(tasks: readonly TaskRecord[], id: string, now: number): ArchiveTaskResult {
+  let applied = false
+  const next = tasks.map(task => {
+    if (task.id !== id || task.archivedAt === undefined) return task
+    applied = true
+    const { archivedAt: _archived, ...rest } = task
+    return { ...rest, updatedAt: now }
+  })
+  return { tasks: next, archived: applied }
+}

package/src/core/use-cases/task-create.ts

@@ -3,7 +3,8 @@
  * title. Pure ledger transition (no persistence or notify — the controller
  * orchestrates those), so it is unit-testable without any runtime face.
  */
-import { createTask, type NewTaskInput, type TaskRecord } from '../tasks.ts'
+import { isValidCron, nextRunAtMs } from '../schedule.ts'
+import { createTask, withSchedule, type NewTaskInput, type TaskRecord } from '../tasks.ts'
 
 /** Result of a create transition: the new task (when accepted) + the next ledger. */
 export interface CreateTaskResult {
@@ -17,7 +18,7 @@ export interface CreateTaskResult {
  * Apply a create against the current ledger. Returns the new task and the
  * appended ledger, or the unchanged ledger when the title is blank.
  * @param tasks - current ledger.
- * @param input - raw user input (title/description/prompt).
+ * @param input - raw user input (title/description/prompt + optional schedule).
  * @param now - clock instant (ms epoch).
  * @param id - minted task id.
  */
@@ -28,6 +29,14 @@ export function applyCreateTask(
   id: string,
 ): CreateTaskResult {
   if (input.title.trim() === '') return { task: undefined, tasks }
-  const task = createTask(input, now, id)
+  let task = createTask(input, now, id)
+  // Arm the requested schedule (new-task dialog): only an enabled rule with
+  // a valid cron is applied; blank, invalid, or disabled requests leave the
+  // task unscheduled.
+  const requested = input.schedule
+  if (requested?.enabled === true && requested.cron.trim() !== '' && isValidCron(requested.cron)) {
+    const cron = requested.cron.trim()
+    task = withSchedule(task, { enabled: true, cron, nextRunAt: nextRunAtMs(cron, now) }, now)
+  }
   return { task, tasks: [...tasks, task] }
 }