@linxin666/dsh-client-ui-task-board 0.1.16 → 0.1.18

package/src/core/controller.ts

@@ -19,10 +19,11 @@ 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'
-import { applyUpdateTask } from './use-cases/task-update.ts'
+import { applyUpdateTask, type TaskUpdatePatch } from './use-cases/task-update.ts'
 
 /** The sessions face the controller needs for navigation awareness. */
 export interface SessionsControllerFace {
@@ -47,11 +48,38 @@ export interface ControllerDeps {
   reconcileDebounceMs?: number
 }
 
+/** One workspace option the execution-target pickers offer. */
+export interface ExecutionWorkspaceOption {
+  workspaceId: string
+  /** Display label (workspace title; the wiring falls back to the path). */
+  title: string
+}
+
+/** One agent-preset option the execution-target pickers offer. */
+export interface ExecutionPresetOption {
+  id: string
+  name?: string
+  description?: string
+  /** Why this preset cannot compose a session; the pickers disable it. */
+  broken?: string
+  isDefault: boolean
+}
+
+/** The execution-target option sets the UI feeds into the controller. */
+export interface ExecutionOptionsSnapshot {
+  workspaces: readonly ExecutionWorkspaceOption[]
+  presets: readonly ExecutionPresetOption[]
+}
+
 /** Immutable controller snapshot for UI subscriptions. */
 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
 }
 
 /** The selected task (resolved from the ledger), or undefined. */
@@ -84,7 +112,9 @@ 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>()
   private disposers: Array<() => void> = []
   private readonly now: () => number
@@ -131,7 +161,9 @@ export class BoardController {
     return {
       tasks: this.tasks,
       boardOpen: this.boardOpen,
+      archiveView: this.archiveView,
       selectedTaskId: this.selectedTaskId,
+      executionOptions: this.executionOptions,
     }
   }
 
@@ -163,6 +195,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
@@ -186,11 +232,20 @@ export class BoardController {
     return task
   }
 
-  updateTask(id: string, patch: Partial<Pick<TaskRecord, 'title' | 'description' | 'prompt'>>): void {
+  updateTask(id: string, patch: TaskUpdatePatch): void {
     this.tasks = [...applyUpdateTask(this.tasks, id, patch, this.now())]
     this.persistAndNotify()
   }
 
+  /**
+   * Replace (a part of) the picker option sets the UI feeds (workspace list
+   * and agent-preset roster come from the runtime, not the ledger).
+   */
+  setExecutionOptions(patch: Partial<ExecutionOptionsSnapshot>): void {
+    this.executionOptions = { ...this.executionOptions, ...patch }
+    this.notify()
+  }
+
   moveTask(id: string, status: TaskStatus): void {
     this.tasks = this.tasks.map(task => task.id === id ? withStatus(task, status, this.now()) : task)
     this.persistAndNotify()
@@ -203,6 +258,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 ---------------------------------------------------------------
 
   /**
@@ -233,6 +311,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

@@ -15,19 +15,40 @@
  */
 import type { ExecutionRecord, TaskRecord } from './tasks.ts'
 
+/** One list-row summary the execution service reads (the narrow slice of a SessionSummary). */
+export interface ExecutionSessionSummary {
+  running: boolean
+  completed?: boolean
+  /** Empty-log bit: the preset can only be recomposed while the session is blank. */
+  blank?: boolean
+  /** The preset the session currently runs (absent on deployments without presets). */
+  agentPreset?: string
+}
+
 /** The narrow sessions face the service needs. */
 export interface SessionsExecutionFace {
   list: {
     getSnapshot(): {
       /** Baseline arrival lifecycle — 'pending' until the host list has loaded. */
       phase: 'pending' | 'ready'
-      byId: Record<string, { running: boolean; completed?: boolean }>
+      byId: Record<string, ExecutionSessionSummary>
     }
     subscribe(fn: () => void): () => void
   }
   binding(id: string): { session: SessionDriver } | undefined
+  /** Record a host-confirmed preset switch so the list label moves immediately. */
+  noteAgentPreset?(sessionId: string, agentPreset: string): void
+}
+
+/** The narrow agent-preset wire face the service needs (`agentPreset.select`). */
+export interface PresetsExecutionFace {
+  /** Recompose a blank session's agent from a preset. */
+  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: {
@@ -57,6 +78,12 @@ export interface SessionDriver {
     content: readonly unknown[],
     mode: 'queue',
   ): Promise<{ ok: true } | { ok: false; error: unknown }>
+  /**
+   * Admit one slash-command line against the session's agent (the
+   * `/permission <id>` mechanism). `matched` reports whether a command
+   * claimed the line.
+   */
+  command(line: string): Promise<{ ok: true; matched: boolean } | { ok: false; error: unknown }>
   getSnapshot(): { running: boolean; lastAgentError: string | null; turnEnds: ReadonlyMap<number, number> }
   subscribe(fn: () => void): () => void
 }
@@ -65,6 +92,8 @@ export interface SessionDriver {
 export interface ExecutionEnvironment {
   sessions: SessionsExecutionFace
   workspaces: WorkspacesExecutionFace
+  /** Agent-preset wire face; absent on deployments without preset support. */
+  presets?: PresetsExecutionFace
   /** Raw-history reader for failure detection of never-opened sessions. */
   history?: HistoryExecutionFace
 }
@@ -80,6 +109,19 @@ function messageOf(error: unknown): string {
   return String(error)
 }
 
+/**
+ * Whether a rejected preset switch actually means "the session already runs
+ * this preset" (the host's agent-preset-conflict with a matching
+ * existingPreset). A blank-session reuse race can produce this even though
+ * the requested composition is in place.
+ */
+function presetAlreadyRuns(error: unknown, mode: string): boolean {
+  if (typeof error !== 'object' || error === null) return false
+  const details = (error as { details?: unknown }).details
+  if (typeof details !== 'object' || details === null) return false
+  return (details as { existingPreset?: unknown }).existingPreset === mode
+}
+
 /** Whether a `turn/end` payload closed the turn with an error reason. */
 function isErrorTurnEnd(data: unknown): boolean {
   if (typeof data !== 'object' || data === null) return false
@@ -98,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) {}
 
@@ -106,14 +158,24 @@ export class ExecutionService {
     execution: ExecutionRecord,
     onEvent: (event: ExecutionEvent) => void,
   ): Promise<void> {
+    const settleFailed = (error: string): void => {
+      onEvent({ kind: 'settled', taskId: task.id, executionId: execution.id, outcome: 'failed', error })
+    }
     try {
-      const sessionId = await this.connectSession()
+      const sessionId = await this.connectSession(task.workspaceId)
       onEvent({ kind: 'started', taskId: task.id, executionId: execution.id, sessionId })
       const driver = this.driverOf(sessionId)
       if (driver === undefined) {
-        onEvent({ kind: 'settled', taskId: task.id, executionId: execution.id, outcome: 'failed', error: 'execution session is not ready' })
+        settleFailed('execution session is not ready')
         return
       }
+      // Task-pinned execution targets are applied BEFORE any prompt: a preset
+      // can only be recomposed while the session is blank, and the permission
+      // command must run before the task's turn starts. A rejected target
+      // fails the run without sending the prompt — running the task under
+      // different settings than it declared would be worse than not running.
+      if (!await this.applyMode(driver, task, sessionId, settleFailed)) return
+      if (!await this.applyPermission(driver, task, settleFailed)) return
       // Best-effort rename so the execution is recognizable in the session list.
       await driver.rename(task.title).catch(() => { /* rename is cosmetic */ })
       // Baseline the turn counter BEFORE the prompt round-trip: a turn that
@@ -122,21 +184,118 @@ export class ExecutionService {
       const baseline = driver.getSnapshot().turnEnds.size
       const accepted = await this.sendPrompt(driver, task)
       if (!accepted.ok) {
-        onEvent({
-          kind: 'settled', taskId: task.id, executionId: execution.id, outcome: 'failed',
-          error: messageOf(accepted.error),
-        })
+        settleFailed(messageOf(accepted.error))
         return
       }
       this.watchForSettlement(driver, task.id, execution.id, onEvent, baseline)
     } catch (error) {
-      onEvent({
-        kind: 'settled', taskId: task.id, executionId: execution.id, outcome: 'failed',
-        error: messageOf(error),
-      })
+      settleFailed(messageOf(error))
     }
   }
 
+  /**
+   * Recompose the execution session's agent from the task-pinned preset.
+   * No-op when the task pins none or the session already runs it; fails the
+   * run when the session is no longer blank, the preset face is missing, or
+   * the wire refuses.
+   */
+  private async applyMode(
+    driver: SessionDriver,
+    task: TaskRecord,
+    sessionId: string,
+    settleFailed: (error: string) => void,
+  ): Promise<boolean> {
+    const mode = task.mode
+    if (mode === undefined || mode === '') return true
+    const summary = this.env.sessions.list.getSnapshot().byId[sessionId]
+    if (summary?.blank === false) {
+      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
+    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.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
+        // case with agent-preset-conflict (existingPreset === requested).
+        // The requested composition is already in place, so count it as
+        // applied instead of failing the run.
+        if (presetAlreadyRuns(result.error, mode)) {
+          this.env.sessions.noteAgentPreset?.(sessionId, mode)
+          return true
+        }
+        settleFailed(`agent preset switch to ${mode} rejected: ${messageOf(result.error)}`)
+        return false
+      }
+    } catch (error) {
+      settleFailed(`agent preset switch to ${mode} failed: ${messageOf(error)}`)
+      return false
+    }
+    this.env.sessions.noteAgentPreset?.(sessionId, mode)
+    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
+   * admission is rejected or no command claimed the line.
+   */
+  private async applyPermission(
+    driver: SessionDriver,
+    task: TaskRecord,
+    settleFailed: (error: string) => void,
+  ): Promise<boolean> {
+    const permission = task.permission
+    if (permission === undefined) return true
+    const line = `/permission ${permission}`
+    try {
+      const result = await driver.command(line)
+      if (!result.ok) {
+        settleFailed(`permission command rejected: ${messageOf(result.error)}`)
+        return false
+      }
+      if (!result.matched) {
+        settleFailed(`permission command not recognized: ${line}`)
+        return false
+      }
+    } catch (error) {
+      settleFailed(`permission command failed: ${messageOf(error)}`)
+      return false
+    }
+    return true
+  }
+
   /**
    * Inspect a reloaded/background task that was left 'running' and emit a
    * settled event when its session already finished.
@@ -198,8 +357,16 @@ export class ExecutionService {
     }
   }
 
-  private async connectSession(): Promise<string> {
+  private async connectSession(taskWorkspaceId: string | undefined): Promise<string> {
     const workspace = this.env.workspaces.list.getSnapshot()
+    if (taskWorkspaceId !== undefined && taskWorkspaceId !== '') {
+      // A task-pinned workspace must exist in the list: connecting an
+      // unknown id would only defer the failure into the wire.
+      if (!workspace.items.some(item => item.workspaceId === taskWorkspaceId)) {
+        throw new Error(`task workspace is not available: ${taskWorkspaceId}`)
+      }
+      return this.env.workspaces.connectWorkspace(taskWorkspaceId)
+    }
     const workspaceId = workspace.recentWorkspaceId ?? workspace.items[0]?.workspaceId
     if (workspaceId === undefined) {
       throw new Error('no workspace available to run the task in')

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

@@ -14,8 +14,7 @@
  * localStorage backend.
  */
 import { isValidCron } from './schedule.ts'
-import type { ScheduleRule, TaskRecord, TaskStatus } from './tasks.ts'
-import { isTaskStatus } from './tasks.ts'
+import { isTaskPermission, isTaskStatus, type ScheduleRule, type TaskRecord, type TaskPermission, type TaskStatus } from './tasks.ts'
 
 /** Persistence seam for the task ledger. */
 export interface TaskStore {
@@ -64,6 +63,9 @@ function isTaskRecordShape(value: unknown): value is Omit<TaskRecord, 'status'>
   if (typeof record.prompt !== 'string') return false
   if (typeof record.createdAt !== 'number') return false
   if (typeof record.updatedAt !== 'number') return false
+  if (record.workspaceId !== undefined && typeof record.workspaceId !== 'string') return false
+  if (record.mode !== undefined && typeof record.mode !== 'string') return false
+  if (record.permission !== undefined && typeof record.permission !== 'string') return false
   if (!Array.isArray(record.executions)) return false
   for (const execution of record.executions) {
     if (typeof execution !== 'object' || execution === null) return false
@@ -78,6 +80,11 @@ function isTaskRecordShape(value: unknown): value is Omit<TaskRecord, 'status'>
   return true
 }
 
+/** Collapse a blank persisted target string to undefined (clears the pin). */
+function normalizeTargetId(value: string | undefined): string | undefined {
+  return value !== undefined && value.trim() === '' ? undefined : value
+}
+
 /** A task record is structurally valid if it round-trips through the UI. */
 export function isTaskRecord(value: unknown): value is TaskRecord {
   return isTaskRecordShape(value) && isTaskStatus(value.status)
@@ -136,6 +143,13 @@ export function parseLedger(raw: string | null): TaskRecord[] {
     // clear a malformed persisted rule rather than leave it in the row.
     const task: TaskRecord = { ...row, status: normalizeStatus(row.status) }
     task.schedule = normalizeSchedule(row.schedule)
+    // Execution targets are normalized like the schedule: blank strings
+    // clear the pin and unknown permission strings from a future version
+    // 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)
   }
   return tasks

package/src/core/tasks.ts

@@ -64,6 +64,41 @@ export interface TaskRecord {
   executions: ExecutionRecord[]
   /** Optional scheduled-run rule (absent on tasks without a schedule). */
   schedule?: ScheduleRule
+  /**
+   * Workspace the execution must run in (a workspace-list id); absent means
+   * the recent-workspace fallback at execution time.
+   */
+  workspaceId?: string
+  /**
+   * Agent preset the execution session must be composed from (an
+   * `agentPreset.list` id); absent means the deployment default.
+   */
+  mode?: string
+  /**
+   * Permission preset applied to the execution session through the
+   * `/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
+
+/** One permission preset id. */
+export type TaskPermission = typeof TASK_PERMISSIONS[number]
+
+/** Whether an unknown value is a known permission preset id. */
+export function isTaskPermission(value: unknown): value is TaskPermission {
+  return typeof value === 'string' && (TASK_PERMISSIONS as readonly string[]).includes(value)
 }
 
 /** Input for creating a task. */
@@ -71,6 +106,18 @@ export interface NewTaskInput {
   title: string
   description: string
   prompt: string
+  /** Workspace the execution must run in; empty/absent = the recent workspace. */
+  workspaceId?: string
+  /** Agent preset the execution session must be composed from; empty/absent = deployment default. */
+  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. */
@@ -103,6 +150,12 @@ export function canMoveManually(_from: TaskStatus, to: TaskStatus): boolean {
   return (MANUAL_STATUSES as readonly TaskStatus[]).includes(to)
 }
 
+/** Normalize one optional execution-target string: trim; blank collapses to undefined. */
+function normalizeTargetId(value: string | undefined): string | undefined {
+  const trimmed = value?.trim()
+  return trimmed === undefined || trimmed === '' ? undefined : trimmed
+}
+
 /** Create a task from user input. */
 export function createTask(input: NewTaskInput, now: number, id: string): TaskRecord {
   return {
@@ -114,6 +167,9 @@ export function createTask(input: NewTaskInput, now: number, id: string): TaskRe
     createdAt: now,
     updatedAt: now,
     executions: [],
+    workspaceId: normalizeTargetId(input.workspaceId),
+    mode: normalizeTargetId(input.mode),
+    permission: isTaskPermission(input.permission) ? input.permission : undefined,
   }
 }
 

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] }
 }