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

package/src/client/locales.ts

@@ -14,6 +14,10 @@ export const zh = {
   '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/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
@@ -109,6 +112,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 +161,7 @@ export class BoardController {
     return {
       tasks: this.tasks,
       boardOpen: this.boardOpen,
+      archiveView: this.archiveView,
       selectedTaskId: this.selectedTaskId,
       executionOptions: this.executionOptions,
     }
@@ -190,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
@@ -239,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 ---------------------------------------------------------------
 
   /**
@@ -269,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

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