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

package/src/core/controller.ts

@@ -1,10 +1,9 @@
 /**
  * Board controller: the single owner of task-ledger state and view state.
  *
- * It keeps the ledger in memory, persists every mutation through the
- * {@link TaskStore}, drives real executions through the
- * {@link ExecutionService}, and closes the board view whenever the user
- * navigates to a session (the sessions-list `current` selection changes).
+ * In production it projects the Host ledger and submits confirmed actions;
+ * the legacy store/execution seams remain for v1 migration tests. It also
+ * closes the board whenever the user navigates to a session.
  * Framework-free (structural runtime faces) so the whole orchestration is
  * unit-testable with fakes.
  *
@@ -13,7 +12,7 @@
  * owns only the orchestration seam (state, persistence, notify, execution,
  * navigation, reconciliation).
  */
-import { ExecutionService, type ExecutionEvent } from './execution.ts'
+import type { ExecutionEvent, ExecutionService } from './execution.ts'
 import type { TaskStore } from './store.ts'
 import {
   settleExecution, startExecution, withStatus,
@@ -24,6 +23,14 @@ 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, type TaskUpdatePatch } from './use-cases/task-update.ts'
+import type { TaskBoardAction, TaskBoardSnapshot } from '../protocol.ts'
+
+export interface TaskBoardTransport {
+  bootstrap(legacy: readonly TaskRecord[]): Promise<TaskBoardSnapshot>
+  state(): Promise<TaskBoardSnapshot>
+  action(action: TaskBoardAction): Promise<TaskBoardSnapshot>
+  subscribe(listener: () => void): () => void
+}
 
 /** The sessions face the controller needs for navigation awareness. */
 export interface SessionsControllerFace {
@@ -38,7 +45,8 @@ export interface SessionsControllerFace {
 /** Controller dependencies (all swappable in tests). */
 export interface ControllerDeps {
   store: TaskStore
-  exec: ExecutionService
+  /** Legacy browser execution seam used only by isolated v1 tests. */
+  exec?: ExecutionService
   sessions: SessionsControllerFace
   /** Clock; defaults to Date.now. */
   now?: () => number
@@ -46,6 +54,8 @@ export interface ControllerDeps {
   uuid?: () => string
   /** Debounce (ms) for session-list-changed reconciles; defaults to 350. */
   reconcileDebounceMs?: number
+  /** Host-authoritative transport; absent keeps the legacy in-memory test path. */
+  transport?: TaskBoardTransport
 }
 
 /** One workspace option the execution-target pickers offer. */
@@ -80,6 +90,9 @@ export interface ControllerSnapshot {
   selectedTaskId: string | undefined
   /** Picker option sets (workspace list + agent-preset roster). */
   executionOptions: ExecutionOptionsSnapshot
+  pendingTaskIds: readonly string[]
+  transportError?: string
+  host?: Pick<TaskBoardSnapshot, 'revision' | 'scheduler' | 'power'>
 }
 
 /** The selected task (resolved from the ledger), or undefined. */
@@ -109,6 +122,10 @@ function currentOf(sessions: SessionsControllerFace): string | undefined {
   return sessions.list.getSnapshot().current
 }
 
+function messageOf(error: unknown): string {
+  return error instanceof Error ? error.message : String(error)
+}
+
 /**
  * Board controller (see module doc). All mutations bump the snapshot and
  * persist through the store; UI and DOM mounts subscribe and re-render.
@@ -123,6 +140,12 @@ export class BoardController {
   private disposers: Array<() => void> = []
   private readonly now: () => number
   private readonly uuid: () => string
+  private readonly pendingTaskIds = new Set<string>()
+  private readonly taskQueues = new Map<string, Promise<void>>()
+  private transportError: string | undefined
+  private hostState: Pick<TaskBoardSnapshot, 'revision' | 'scheduler' | 'power'> | undefined
+  private remoteSubscribed = false
+  private remoteInitialization: Promise<boolean> | undefined
 
   /** @param deps - store, execution service, and the sessions navigation face. */
   constructor(private readonly deps: ControllerDeps) {
@@ -135,15 +158,19 @@ export class BoardController {
   /** Load the persisted ledger and start the navigation/status subscriptions. */
   start(): void {
     this.tasks = this.deps.store.load()
-    void this.reconcileRunningTasks()
+    if (this.deps.transport !== undefined) {
+      void this.initializeRemote()
+    } else {
+      void this.reconcileRunningTasks()
+    }
     // A sibling tab may have edited or deleted the ledger (same origin,
     // storage events). Reload on external change so a task deleted in
     // another tab stops firing here — and is never written back by this
     // tab's stale copy (scheduler roll-forward, execution settlement).
-    const unsubscribeExternal = this.deps.store.subscribeExternal?.(() => {
+    const unsubscribeExternal = this.deps.transport === undefined ? this.deps.store.subscribeExternal?.(() => {
       this.tasks = this.deps.store.load()
       this.notify()
-    })
+    }) : undefined
     if (unsubscribeExternal !== undefined) this.disposers.push(unsubscribeExternal)
     this.disposers.push(this.deps.sessions.list.subscribe(() => {
       this.onSessionsChanged()
@@ -168,6 +195,9 @@ export class BoardController {
       archiveView: this.archiveView,
       selectedTaskId: this.selectedTaskId,
       executionOptions: this.executionOptions,
+      pendingTaskIds: [...this.pendingTaskIds],
+      ...(this.transportError === undefined ? {} : { transportError: this.transportError }),
+      ...(this.hostState === undefined ? {} : { host: this.hostState }),
     }
   }
 
@@ -176,6 +206,16 @@ export class BoardController {
     return () => { this.listeners.delete(fn) }
   }
 
+  /** Whether production mutations are confirmed by the Host transport. */
+  isHostBacked(): boolean {
+    return this.deps.transport !== undefined
+  }
+
+  /** Retry initial migration/state synchronization after an explicit Host error. */
+  async retryHostSync(): Promise<boolean> {
+    return await this.initializeRemote()
+  }
+
   // --- view state -------------------------------------------------------------
 
   openBoard(): void {
@@ -229,14 +269,30 @@ export class BoardController {
   // --- task mutations (use-case transitions in core/use-cases) -----------------
 
   createTask(input: NewTaskInput): TaskRecord | undefined {
-    const { task, tasks } = applyCreateTask(this.tasks, input, this.now(), this.uuid())
+    const id = this.uuid()
+    const { task, tasks } = applyCreateTask(this.tasks, input, this.now(), id)
     if (task === undefined) return undefined
     this.tasks = [...tasks]
     this.persistAndNotify()
     return task
   }
 
+  /** Create through the Host and expose the task only after confirmation. */
+  async createTaskConfirmed(input: NewTaskInput): Promise<TaskRecord | undefined> {
+    if (this.deps.transport === undefined) return this.createTask(input)
+    const id = this.uuid()
+    const preview = applyCreateTask(this.tasks, input, this.now(), id).task
+    if (preview === undefined) return undefined
+    return await this.commitRemote({ kind: 'create', id, input }, id)
+      ? this.tasks.find(task => task.id === id)
+      : undefined
+  }
+
   updateTask(id: string, patch: TaskUpdatePatch): void {
+    if (this.deps.transport !== undefined) {
+      void this.commitRemote({ kind: 'update', taskId: id, patch }, id)
+      return
+    }
     this.tasks = [...applyUpdateTask(this.tasks, id, patch, this.now())]
     this.persistAndNotify()
   }
@@ -251,11 +307,19 @@ export class BoardController {
   }
 
   moveTask(id: string, status: TaskStatus): void {
+    if (this.deps.transport !== undefined) {
+      void this.commitRemote({ kind: 'move', taskId: id, status }, id)
+      return
+    }
     this.tasks = this.tasks.map(task => task.id === id ? withStatus(task, status, this.now()) : task)
     this.persistAndNotify()
   }
 
   deleteTask(id: string): void {
+    if (this.deps.transport !== undefined) {
+      void this.commitRemote({ kind: 'delete', taskId: id }, id)
+      return
+    }
     const { tasks, selectionCleared } = applyDeleteTask(this.tasks, this.selectedTaskId, id)
     this.tasks = [...tasks]
     if (selectionCleared) this.selectedTaskId = undefined
@@ -271,6 +335,10 @@ export class BoardController {
   archiveTask(id: string): boolean {
     const { tasks, archived } = applyArchiveTask(this.tasks, id, this.now())
     if (!archived) return false
+    if (this.deps.transport !== undefined) {
+      void this.commitRemote({ kind: 'archive', taskId: id }, id)
+      return true
+    }
     this.tasks = [...tasks]
     this.persistAndNotify()
     return true
@@ -280,7 +348,14 @@ export class BoardController {
   restoreTask(id: string): boolean {
     const { tasks, archived } = applyRestoreTask(this.tasks, id, this.now())
     if (!archived) return false
+    if (this.deps.transport !== undefined) {
+      void this.commitRemote({ kind: 'restore', taskId: id }, id).then(restored => {
+        if (restored && this.selectedTaskId === id) this.closeTask()
+      })
+      return true
+    }
     this.tasks = [...tasks]
+    if (this.selectedTaskId === id) this.selectedTaskId = undefined
     this.persistAndNotify()
     return true
   }
@@ -299,15 +374,18 @@ export class BoardController {
   setSchedule(id: string, patch: { enabled?: boolean; cron?: string }): boolean {
     const { tasks, applied } = applySetSchedule(this.tasks, id, patch, this.now())
     if (!applied) return false
+    if (this.deps.transport !== undefined) {
+      void this.commitRemote({ kind: 'set-schedule', taskId: id, patch }, id)
+      return true
+    }
     this.tasks = [...tasks]
     this.persistAndNotify()
     return true
   }
 
   /**
-   * Roll a task's schedule forward (scheduler callback): persist the next due
-   * instant and the trigger instant of this run. No-op when the task has no
-   * schedule rule (it was deleted mid-tick, for example).
+   * Legacy pure-controller seam retained for migration-focused tests. The
+   * production browser never rolls schedules; the Host ledger owns them.
    */
   applyScheduleNextRun(id: string, nextRunAt: number | undefined, lastTriggeredAt: number | undefined): void {
     const next = applyScheduleRollForward(this.tasks, id, nextRunAt, lastTriggeredAt, this.now())
@@ -316,12 +394,8 @@ export class BoardController {
   }
 
   /**
-   * 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.
+   * Reload the legacy v1 store without notifying subscribers. Production v2
+   * reads Host snapshots instead; this remains only for isolated legacy tests.
    */
   reloadFromStore(): void {
     this.tasks = this.deps.store.load()
@@ -345,7 +419,10 @@ export class BoardController {
    */
   async runTask(id: string): Promise<boolean> {
     const task = this.tasks.find(candidate => candidate.id === id)
-    if (task === undefined || task.status === 'running') return false
+    if (task === undefined || task.archivedAt !== undefined || task.status === 'running') return false
+    if (this.deps.transport !== undefined) {
+      return await this.commitRemote({ kind: 'run', taskId: id }, id)
+    }
     const { task: next, execution } = startExecution(task, this.now(), this.uuid())
     this.tasks = this.tasks.map(candidate => candidate.id === id ? next : candidate)
     this.persistAndNotify()
@@ -354,6 +431,7 @@ export class BoardController {
     // reconciliation must not pre-empt it with a session that has not
     // started a turn yet (its list row is idle, not completed).
     this.activeExecutionIds.add(execution.id)
+    if (this.deps.exec === undefined) throw new Error('legacy execution service is unavailable')
     await this.deps.exec.run(next, execution, (event) => { this.handleExecutionEvent(event) })
     return true
   }
@@ -361,7 +439,11 @@ export class BoardController {
   /** Re-run a settled task: move it back to 'todo' first, then execute. */
   async rerunTask(id: string): Promise<void> {
     const task = this.tasks.find(candidate => candidate.id === id)
-    if (task === undefined) return
+    if (task === undefined || task.archivedAt !== undefined) return
+    if (this.deps.transport !== undefined) {
+      await this.commitRemote({ kind: 'rerun', taskId: id }, id)
+      return
+    }
     if (task.status !== 'running') {
       this.tasks = this.tasks.map(candidate => candidate.id === id ? withStatus(candidate, 'todo', this.now()) : candidate)
       this.persistAndNotify()
@@ -392,7 +474,7 @@ export class BoardController {
     // conversation snapshots stay cold until opened). Coalesce the burst of
     // list notifications into one reconcile pass instead of fanning out a
     // history read per notification; see scheduleReconcile.
-    this.scheduleReconcile()
+    if (this.deps.transport === undefined) this.scheduleReconcile()
     if (!this.boardOpen) return
     const current = currentOf(this.deps.sessions)
     if (current !== this.lastCurrent) this.closeBoard()
@@ -426,6 +508,7 @@ export class BoardController {
 
   /** Settle tasks left 'running' whose sessions already finished. */
   private async reconcileRunningTasks(): Promise<void> {
+    if (this.deps.exec === undefined) return
     if (this.reconcileInFlight) return
     this.reconcileInFlight = true
     try {
@@ -461,8 +544,107 @@ export class BoardController {
   }
 
   private persistAndNotify(): void {
-    this.deps.store.save(this.tasks)
+    if (this.deps.transport === undefined) this.deps.store.save(this.tasks)
+    this.notify()
+  }
+
+  private async commitRemote(action: TaskBoardAction, taskId?: string): Promise<boolean> {
+    const transport = this.deps.transport
+    if (transport === undefined) return true
+    if (taskId === undefined) return await this.performRemote(action)
+    const previous = this.taskQueues.get(taskId) ?? Promise.resolve()
+    const operation = previous.catch(() => {}).then(async () => await this.performRemote(action))
+    const tail = operation.then(() => {}, () => {})
+    this.taskQueues.set(taskId, tail)
+    this.pendingTaskIds.add(taskId)
+    this.notify()
+    try {
+      return await operation
+    } finally {
+      if (this.taskQueues.get(taskId) === tail) {
+        this.taskQueues.delete(taskId)
+        this.pendingTaskIds.delete(taskId)
+        this.notify()
+      }
+    }
+  }
+
+  private async performRemote(action: TaskBoardAction): Promise<boolean> {
+    const transport = this.deps.transport
+    if (transport === undefined) return true
+    this.transportError = undefined
+    this.notify()
+    try {
+      const accepted = this.acceptRemote(await transport.action(action))
+      return accepted || await this.refreshRemote()
+    } catch (error) {
+      await this.refreshRemote(messageOf(error))
+      return false
+    }
+  }
+
+  private async initializeRemote(): Promise<boolean> {
+    if (this.remoteInitialization !== undefined) return await this.remoteInitialization
+    const initialization = this.doInitializeRemote()
+    this.remoteInitialization = initialization
+    try {
+      return await initialization
+    } finally {
+      if (this.remoteInitialization === initialization) this.remoteInitialization = undefined
+    }
+  }
+
+  private async doInitializeRemote(): Promise<boolean> {
+    const transport = this.deps.transport
+    if (transport === undefined) return true
+    try {
+      this.acceptRemote(await transport.bootstrap(this.tasks))
+      if (!this.remoteSubscribed) {
+        this.remoteSubscribed = true
+        this.disposers.push(transport.subscribe(() => { void this.refreshRemote() }))
+      }
+      return true
+    } catch (error) {
+      this.transportError = messageOf(error)
+      this.notify()
+      return false
+    }
+  }
+
+  private async refreshRemote(preserveError?: string): Promise<boolean> {
+    const transport = this.deps.transport
+    if (transport === undefined) return true
+    try {
+      this.acceptRemote(await transport.state())
+      if (preserveError !== undefined) {
+        this.transportError = preserveError
+        this.notify()
+      }
+      return true
+    } catch (error) {
+      this.transportError = preserveError ?? messageOf(error)
+      this.notify()
+      return false
+    }
+  }
+
+  private acceptRemote(snapshot: TaskBoardSnapshot): boolean {
+    const currentLedgerId = this.hostState?.scheduler.ledgerId
+    const nextLedgerId = snapshot.scheduler.ledgerId
+    const sameGeneration = currentLedgerId === nextLedgerId
+    if (sameGeneration && this.hostState !== undefined && snapshot.revision < this.hostState.revision) return false
+    this.tasks = [...snapshot.tasks]
+    this.hostState = { revision: snapshot.revision, scheduler: snapshot.scheduler, power: snapshot.power }
+    this.transportError = undefined
+    if (this.selectedTaskId !== undefined && !this.tasks.some(task => task.id === this.selectedTaskId)) {
+      this.selectedTaskId = undefined
+    }
+    if (!this.archiveView && this.selectedTaskId !== undefined
+      && this.tasks.find(task => task.id === this.selectedTaskId)?.archivedAt !== undefined) {
+      this.selectedTaskId = undefined
+    }
     this.notify()
+    return true
   }
 
   private notify(): void {
@@ -484,4 +666,3 @@ function attachSessionId(
       execution.id === executionId ? { ...execution, sessionId } : execution),
   }
 }
-

package/src/core/schedule.ts

@@ -73,16 +73,19 @@ export function isValidCron(expr: string): boolean {
 /**
  * Compute the next matching instant after `fromMs` (ms epoch), in local time,
  * at minute granularity, strictly greater than `fromMs`. Returns the ms epoch
- * of the matching minute's start, or undefined when nothing matches within
- * 366 days (e.g. `0 0 30 2 *`).
+ * of the matching minute's start, or undefined when the calendar constraint
+ * can never match (for example `0 0 30 2 *`). The five-year horizon includes
+ * a full leap cycle, so a valid February 29 schedule remains reachable from
+ * every non-leap year.
  */
 export function nextRunAtMs(expr: string, fromMs: number): number | undefined {
   const schedule = parseCron(expr)
   if (schedule === null) return undefined
+  if (!hasPossibleCalendarDay(schedule)) return undefined
   const from = new Date(fromMs)
   // Scan from the next minute; Date rolls overflow (Feb 30 → Mar 2) for free.
   const scan = new Date(from.getFullYear(), from.getMonth(), from.getDate(), from.getHours(), from.getMinutes() + 1, 0, 0)
-  const limitMs = fromMs + 366 * 24 * 60 * 60 * 1000
+  const limitMs = fromMs + 5 * 366 * 24 * 60 * 60 * 1000
   while (scan.getTime() <= limitMs) {
     if (matches(schedule, scan)) return scan.getTime()
     scan.setMinutes(scan.getMinutes() + 1)
@@ -90,6 +93,20 @@ export function nextRunAtMs(expr: string, fromMs: number): number | undefined {
   return undefined
 }
 
+/** Reject impossible month/day pairs without spending the multi-year scan. */
+function hasPossibleCalendarDay(schedule: CronSchedule): boolean {
+  if (schedule.dayWildcard || !schedule.weekdayWildcard) return true
+  const maximumDay = new Map<number, number>([
+    [1, 31], [2, 29], [3, 31], [4, 30], [5, 31], [6, 30],
+    [7, 31], [8, 31], [9, 30], [10, 31], [11, 30], [12, 31],
+  ])
+  for (const month of schedule.months) {
+    const maximum = maximumDay.get(month) ?? 0
+    if ([...schedule.days].some(day => day <= maximum)) return true
+  }
+  return false
+}
+
 /** Parse one comma-list field into the match set. */
 function parseField(field: string, min: number, max: number, out: Set<number>): boolean {
   if (field === '*') {

package/src/core/store.ts

@@ -1,20 +1,16 @@
 /**
- * Task persistence: a small storage seam with a localStorage backend.
+ * Legacy v1 browser persistence and the store seam used by pure client tests.
  *
- * The task-board client plugin runs in the browser, and dsh exposes no
- * browser-writable file channel (same conclusion the skin-center research
- * reached for cordis.patch.yml), so tasks persist in the browser's
- * localStorage under a versioned key — the same persistence mechanism dsh's
- * own client snapshot stores use (`createSnapshotStore` persist). Data
- * survives page refreshes and dsh restarts (same origin), and survives
- * plugin uninstall (the key is simply left in place).
+ * Production v2 state is Host-authoritative. This backend is retained only to
+ * read `dsh.taskBoard.v1` for one-time import; the old value is never removed,
+ * so it remains a read-only rollback copy after migration.
  *
  * The seam keeps the backend swappable (e.g. an IndexedDB or a host-file
  * channel later); tests run against the in-memory backend and a jsdom
  * localStorage backend.
  */
 import { isValidCron } from './schedule.ts'
-import { isTaskPermission, isTaskStatus, type ScheduleRule, type TaskRecord, type TaskPermission, type TaskStatus } from './tasks.ts'
+import { isTaskPermission, isTaskStatus, normalizeTargetId, type ScheduleRule, type TaskRecord, type TaskPermission, type TaskStatus } from './tasks.ts'
 
 /** Persistence seam for the task ledger. */
 export interface TaskStore {
@@ -80,11 +76,6 @@ 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)

package/src/core/tasks.ts

@@ -29,9 +29,8 @@ export interface ExecutionRecord {
 }
 
 /**
- * A scheduled-run rule attached to a task. The browser-side scheduler ticks
- * every minute and triggers the task when `nextRunAt` is due; the rule is
- * persisted with the task (localStorage), so scheduling survives refreshes.
+ * A scheduled-run rule attached to a task. The Host scheduler triggers the
+ * task when `nextRunAt` is due and persists the rule in the Host ledger.
  */
 export interface ScheduleRule {
   /** Whether the schedule is armed. */
@@ -81,7 +80,8 @@ export interface TaskRecord {
   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.
+   * and execution history, leave the main board, and cannot run until restored;
+   * absent means on-board.
    */
   archivedAt?: number
 }
@@ -146,12 +146,12 @@ export function isTaskStatus(value: unknown): value is TaskStatus {
 }
 
 /** Whether a manual move target is allowed from the given status. */
-export function canMoveManually(_from: TaskStatus, to: TaskStatus): boolean {
-  return (MANUAL_STATUSES as readonly TaskStatus[]).includes(to)
+export function canMoveManually(from: TaskStatus, to: TaskStatus): boolean {
+  return from !== 'running' && (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 {
+export function normalizeTargetId(value: string | undefined): string | undefined {
   const trimmed = value?.trim()
   return trimmed === undefined || trimmed === '' ? undefined : trimmed
 }

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

@@ -1,8 +1,8 @@
 /**
  * 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.
+ * main board and back. The task keeps its status, execution history, and
+ * transcript references, while archiving disarms any schedule so it cannot
+ * create more execution records until the user restores and re-enables it.
  */
 import type { TaskRecord } from '../tasks.ts'
 import { ARCHIVABLE_STATUSES } from '../tasks.ts'
@@ -18,7 +18,8 @@ export interface ArchiveTaskResult {
 /**
  * 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.
+ * owns its lifecycle). Archiving disarms a schedule; already-archived tasks
+ * are a no-op.
  */
 export function applyArchiveTask(
   tasks: readonly TaskRecord[],
@@ -30,7 +31,15 @@ export function applyArchiveTask(
     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 }
+    const schedule = task.schedule === undefined
+      ? undefined
+      : { ...task.schedule, enabled: false, nextRunAt: undefined }
+    return {
+      ...task,
+      ...(schedule === undefined ? {} : { schedule }),
+      archivedAt: now,
+      updatedAt: now,
+    }
   })
   return { tasks: next, archived: applied }
 }

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

@@ -22,9 +22,9 @@ export interface SetScheduleResult {
 }
 
 /**
- * Set a task's schedule rule. A blank or invalid cron is rejected (state
- * untouched); an enabled rule computes the next run instant immediately, a
- * disabled or invalid one carries no next-run instant.
+ * Set an on-board task's schedule rule. A blank or invalid cron, or an
+ * archived task, is rejected (state untouched); an enabled rule computes the
+ * next run instant immediately, a disabled one carries no next-run instant.
  * @param tasks - current ledger.
  * @param id - the task to schedule.
  * @param patch - rule fields to change (absent fields keep their current value).
@@ -37,12 +37,13 @@ export function applySetSchedule(
   now: number,
 ): SetScheduleResult {
   const task = tasks.find(candidate => candidate.id === id)
-  if (task === undefined) return { tasks, applied: false }
+  if (task === undefined || task.archivedAt !== undefined) return { tasks, applied: false }
   const current = task.schedule
   const cron = (patch.cron ?? current?.cron ?? '').trim()
   if (cron === '' || !isValidCron(cron)) return { tasks, applied: false }
   const enabled = patch.enabled ?? current?.enabled ?? false
   const nextRunAt = enabled ? nextRunAtMs(cron, now) : undefined
+  if (enabled && nextRunAt === undefined) return { tasks, applied: false }
   return {
     tasks: tasks.map(candidate =>
       candidate.id === id ? withSchedule(candidate, { enabled, cron, nextRunAt }, now) : candidate),
@@ -68,7 +69,7 @@ export function applyScheduleNextRun(
   now: number,
 ): readonly TaskRecord[] {
   return tasks.map(task =>
-    task.id === id && task.schedule !== undefined
+    task.id === id && task.archivedAt === undefined && task.schedule !== undefined
       ? withSchedule(task, { nextRunAt, lastTriggeredAt }, now)
       : task)
 }

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

@@ -8,16 +8,11 @@
  * back to the runtime default); an unknown permission string is ignored so
  * stale UI can never persist a value the execution service rejects.
  */
-import { isTaskPermission, type TaskRecord, type TaskPermission } from '../tasks.ts'
+import { isTaskPermission, normalizeTargetId, type TaskRecord, type TaskPermission } from '../tasks.ts'
 
 /** Editable fields on a task (the update patch surface). */
 export type TaskUpdatePatch = Partial<Pick<TaskRecord, 'title' | 'description' | 'prompt' | 'workspaceId' | 'mode' | 'permission'>>
 
-/** Collapse a blank target string to undefined (clears the pin). */
-function normalizeTargetId(value: string | undefined): string | undefined {
-  return value !== undefined && value.trim() === '' ? undefined : value
-}
-
 /** Keep an unknown permission string from entering the ledger. */
 function normalizePermission(
   current: TaskPermission | undefined,

package/src/dsh-home.ts

@@ -0,0 +1,36 @@
+// Generated by scripts/sync-shared.mjs from shared/host/dsh-home.ts. Do not edit this copy; edit the shared source and run "node scripts/sync-shared.mjs".
+/**
+ * DSH_HOME resolution shared by the plugin family's Host halves: the
+ * environment override wins, the platform home fallback follows. Mirrors
+ * what dsh-pet and dsh-liangshen each used to implement locally.
+ */
+
+import { homedir } from 'node:os'
+import { isAbsolute, join } from 'node:path'
+
+/** Expand a leading ~ (or ~user) in a path, platform-style. */
+export function expandHome(path: string, home: string = homedir()): string {
+  if (path === '~') return home
+  if (path.startsWith('~/') || path.startsWith('~\\')) return join(home, path.slice(2))
+  return path
+}
+
+/**
+ * Resolve the DSH home directory.
+ * @param env - process environment to read DSH_HOME from.
+ * @param home - platform home directory fallback (test seam).
+ * @returns the absolute DSH home path.
+ */
+export function resolveDshHome(env: NodeJS.ProcessEnv = process.env, home: string = homedir()): string {
+  const raw = env.DSH_HOME
+  if (raw !== undefined && raw.trim() !== '') {
+    const expanded = expandHome(raw.trim(), home)
+    return isAbsolute(expanded) ? expanded : join(process.cwd(), expanded)
+  }
+  return join(home, '.dsh')
+}
+
+/** Resolve the DSH home directory from the live environment. */
+export function dshHome(): string {
+  return resolveDshHome()
+}