@linxin666/dsh-client-ui-task-board 0.2.8 → 0.3.0

package/src/client/board.module.css

@@ -51,12 +51,13 @@ html[data-dsh-taskboard-active]:not([data-dsh-ssh-active]) [class*='centerCol']
 /* --- sidebar entry row ------------------------------------------------------- */
 
 .entry {
+  box-sizing: border-box;
   display: flex;
   align-items: center;
   gap: 8px;
   width: 100%;
-  height: 32px;
-  padding: 0 12px;
+  height: 36px;
+  padding: 0 10px;
   background: transparent;
   border: none;
   border-radius: 8px;
@@ -67,12 +68,12 @@ html[data-dsh-taskboard-active]:not([data-dsh-ssh-active]) [class*='centerCol']
 }
 
 .entry:hover {
-  background: var(--dsw-specific-sidebar-nav-item-hover);
+  background: var(--dsw-alias-interactive-bg-hover);
   color: var(--dsw-alias-label-primary);
 }
 
 .entry[data-active] {
-  background: var(--dsw-specific-sidebar-nav-item-active);
+  background: var(--dsw-alias-interactive-bg-active);
   color: var(--dsw-alias-label-primary);
   font-weight: 600;
 }
@@ -81,9 +82,17 @@ html[data-dsh-taskboard-active]:not([data-dsh-ssh-active]) [class*='centerCol']
   display: inline-flex;
   align-items: center;
   justify-content: center;
+  width: 24px;
+  height: 24px;
   flex: none;
 }
 
+.entryIcon svg {
+  display: block;
+  width: 18px;
+  height: 18px;
+}
+
 .entryLabel {
   overflow: hidden;
   text-overflow: ellipsis;
@@ -93,7 +102,10 @@ html[data-dsh-taskboard-active]:not([data-dsh-ssh-active]) [class*='centerCol']
 [data-dsh-frame][data-sidebar-collapsed] .entry {
   justify-content: center;
   padding: 0;
-  width: 100%;
+  width: 36px;
+  height: 36px;
+  margin: 0 auto 12px;
+  border-radius: 50%;
 }
 
 [data-dsh-frame][data-sidebar-collapsed] .entryLabel {
@@ -809,31 +821,191 @@ html[data-dsh-taskboard-active]:not([data-dsh-ssh-active]) [class*='centerCol']
 
 /* --- constrained board containers ------------------------------------------ */
 
-@container task-board-view (max-width: 720px) {
+@container task-board-view (max-width: 768px) {
   .board {
     gap: 10px;
     padding: 10px;
   }
 
+  .boardHeader {
+    align-items: center;
+    flex-wrap: wrap;
+    gap: 8px;
+  }
+
+  .backButton {
+    flex: 0 0 auto;
+    order: 1;
+  }
+
+  .boardTitle {
+    flex: 1 1 auto;
+    order: 2;
+  }
+
+  .boardHeader > .detailMeta {
+    flex: 1 0 100%;
+    margin-left: 0;
+    order: 3;
+  }
+
+  .search {
+    flex: 1 0 100%;
+    min-width: 0;
+    order: 4;
+  }
+
+  .boardHeader > button:not(.backButton) {
+    flex: 1 1 0;
+    min-width: 0;
+    order: 5;
+  }
+
   .columns {
+    grid-auto-columns: 86cqw;
     gap: 10px;
+    padding-inline: 2px 14cqw;
+    scroll-padding-inline: 2px;
+    scroll-snap-type: inline mandatory;
+    scrollbar-width: none;
+    -webkit-overflow-scrolling: touch;
+  }
+
+  .columns::-webkit-scrollbar {
+    display: none;
+  }
+
+  .column {
+    scroll-snap-align: start;
+    scroll-snap-stop: always;
+  }
+}
+
+@container task-board-view (max-width: 720px) {
+  .boardHeader > .detailMeta {
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
   }
 }
 
 @container task-board-view (max-width: 600px) {
-  .boardHeader {
+  .board {
+    padding-inline: 8px;
+  }
+}
+
+/* Viewport-specific mobile treatment: overlays occupy the dynamic viewport,
+   preserve notches/home indicators, and keep their action rows reachable. */
+@media (max-width: 768px) {
+  [data-dsh-taskboard-view] {
+    height: 100vh;
+    height: 100dvh;
+  }
+
+  .entry,
+  .card,
+  .primaryButton,
+  .ghostButton,
+  .dangerButton,
+  .iconButton,
+  .linkButton,
+  .search,
+  .input,
+  .select,
+  .schedulePreset,
+  .scheduleToggle {
+    min-height: 44px;
+  }
+
+  .search,
+  .input,
+  .select,
+  .schedulePreset {
+    box-sizing: border-box;
+    font-size: 16px;
+  }
+
+  .modalBackdrop {
+    align-items: stretch;
+    justify-content: stretch;
+    width: 100vw;
+    height: 100vh;
+    height: 100dvh;
+  }
+
+  .modal,
+  .detail {
+    box-sizing: border-box;
+    width: 100vw;
+    height: 100vh;
+    height: 100dvh;
+    max-height: none;
+    border: 0;
+    border-radius: 0;
+  }
+
+  .modal {
+    padding-top: max(16px, env(safe-area-inset-top));
+    padding-right: max(16px, env(safe-area-inset-right));
+    padding-bottom: max(16px, env(safe-area-inset-bottom));
+    padding-left: max(16px, env(safe-area-inset-left));
+  }
+
+  .modalFooter {
+    position: sticky;
+    bottom: 0;
+    z-index: 1;
     flex-wrap: wrap;
-    gap: 8px;
+    padding-top: 8px;
+    background: var(--dsw-alias-bg-base);
   }
 
-  .search {
-    flex: 1 1 calc(100% - 72px);
+  .modalFooter > button {
+    flex: 1 1 120px;
+  }
+
+  .detailHeader {
+    flex-wrap: wrap;
+    padding-top: max(12px, env(safe-area-inset-top));
+    padding-right: max(14px, env(safe-area-inset-right));
+    padding-left: max(14px, env(safe-area-inset-left));
+  }
+
+  .detailTitle {
     min-width: 0;
   }
 
-  .boardHeader > button {
-    flex: 1 1 0;
-    min-width: max-content;
+  .detailBody {
+    overscroll-behavior-y: contain;
+    padding-right: max(14px, env(safe-area-inset-right));
+    padding-left: max(14px, env(safe-area-inset-left));
+  }
+
+  .detailFooter {
+    flex-wrap: wrap;
+    padding-right: max(14px, env(safe-area-inset-right));
+    padding-bottom: max(12px, env(safe-area-inset-bottom));
+    padding-left: max(14px, env(safe-area-inset-left));
+  }
+
+  .detailFooter > button {
+    flex: 1 1 96px;
+  }
+
+  .detailFooter > .detailMeta {
+    flex: 1 0 100%;
+    margin-left: 0;
+    text-align: end;
+  }
+
+  .scheduleRow {
+    align-items: stretch;
+    flex-direction: column;
+  }
+
+  .schedulePreset {
+    width: 100%;
   }
 }
 

package/src/client/sidebar-entry.ts

@@ -19,8 +19,8 @@ import { mountSidebarEntry as mountSharedSidebarEntry } from './sidebar-entry-co
 /** Stable data attribute identifying the injected entry row. */
 export const ENTRY_SELECTOR = '[data-dsh-taskboard-entry]'
 
-/** Inline icon (matches the shell's 16px nav-icon look). */
-const ICON = '<svg viewBox="0 0 16 16" width="14" height="14" fill="none" stroke="currentColor" stroke-width="1.3" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><rect x="2" y="2.5" width="12" height="11" rx="1.5"/><path d="M2 6.5h12M6.5 6.5v7"/></svg>'
+/** Inline icon normalized to the shell's 18px navigation glyph size. */
+const ICON = '<svg viewBox="0 0 16 16" width="18" height="18" fill="none" stroke="currentColor" stroke-width="1.3" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><rect x="2" y="2.5" width="12" height="11" rx="1.5"/><path d="M2 6.5h12M6.5 6.5v7"/></svg>'
 
 /**
  * Mount the sidebar entry, waiting for the shell to render and self-healing

package/src/core/controller.ts

@@ -2,22 +2,17 @@
  * Board controller: the single owner of task-ledger state and view state.
  *
  * 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.
+ * the legacy store seam remains 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.
  *
  * The per use-case domain transitions (create/update/delete/schedule) live in
  * dedicated modules under core/use-cases and are applied here; the controller
- * owns only the orchestration seam (state, persistence, notify, execution,
- * navigation, reconciliation).
+ * owns only the orchestration seam (state, persistence, notify, navigation).
  */
-import type { ExecutionEvent, ExecutionService } from './execution.ts'
 import type { TaskStore } from './store.ts'
-import {
-  settleExecution, startExecution, withStatus,
-  type NewTaskInput, type TaskRecord, type TaskStatus,
-} from './tasks.ts'
+import { 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'
@@ -45,15 +40,11 @@ export interface SessionsControllerFace {
 /** Controller dependencies (all swappable in tests). */
 export interface ControllerDeps {
   store: TaskStore
-  /** Legacy browser execution seam used only by isolated v1 tests. */
-  exec?: ExecutionService
   sessions: SessionsControllerFace
   /** Clock; defaults to Date.now. */
   now?: () => number
   /** Id minting; defaults to a random-uuid. */
   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
 }
@@ -147,7 +138,7 @@ export class BoardController {
   private remoteSubscribed = false
   private remoteInitialization: Promise<boolean> | undefined
 
-  /** @param deps - store, execution service, and the sessions navigation face. */
+  /** @param deps - store and the sessions navigation face. */
   constructor(private readonly deps: ControllerDeps) {
     this.now = deps.now ?? (() => Date.now())
     this.uuid = deps.uuid ?? randomUuid
@@ -158,11 +149,7 @@ export class BoardController {
   /** Load the persisted ledger and start the navigation/status subscriptions. */
   start(): void {
     this.tasks = this.deps.store.load()
-    if (this.deps.transport !== undefined) {
-      void this.initializeRemote()
-    } else {
-      void this.reconcileRunningTasks()
-    }
+    if (this.deps.transport !== undefined) void this.initializeRemote()
     // 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
@@ -182,8 +169,6 @@ export class BoardController {
   dispose(): void {
     for (const dispose of this.disposers.splice(0)) dispose()
     this.listeners.clear()
-    if (this.reconcileTimer !== undefined) clearTimeout(this.reconcileTimer)
-    this.reconcileTimer = undefined
   }
 
   // --- snapshot / subscription ------------------------------------------------
@@ -413,68 +398,30 @@ export class BoardController {
   // --- execution ---------------------------------------------------------------
 
   /**
-   * Execute a task for real: move it to 'running', open an execution record,
-   * and hand off to the ExecutionService. A second call while the task is
-   * already running is ignored.
+   * Request a Host execution for a task: the Host ledger owns the running
+   * transition, the execution record, and the settlement. A second call
+   * while the task is already running is ignored; without a Host transport
+   * the run is refused (returns false).
    */
   async runTask(id: string): Promise<boolean> {
     const task = this.tasks.find(candidate => candidate.id === id)
     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()
-    // This page owns the settlement of its own launches: the live watch
-    // (ExecutionService.run) settles on the turn boundary, and list
-    // 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
+    if (this.deps.transport === undefined) return false
+    return await this.commitRemote({ kind: 'run', taskId: id }, id)
   }
 
-  /** Re-run a settled task: move it back to 'todo' first, then execute. */
+  /** Re-run a settled task through the Host (the Host replans and executes). */
   async rerunTask(id: string): Promise<void> {
     const task = this.tasks.find(candidate => candidate.id === id)
     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()
-    }
-    await this.runTask(id)
-  }
-
-  private handleExecutionEvent(event: ExecutionEvent): void {
-    if (event.kind === 'started') {
-      this.tasks = this.tasks.map(task => task.id === event.taskId
-        ? attachSessionId(task, event.executionId, event.sessionId, this.now())
-        : task)
-      this.persistAndNotify()
-      return
-    }
-    this.activeExecutionIds.delete(event.executionId)
-    this.tasks = this.tasks.map(task => task.id === event.taskId
-      ? settleExecution(task, event.executionId, event.outcome, this.now(), event.error)
-      : task)
-    this.persistAndNotify()
+    if (this.deps.transport === undefined) return
+    await this.commitRemote({ kind: 'rerun', taskId: id }, id)
   }
 
   // --- internals ---------------------------------------------------------------
 
-  /** Reconcile running tasks and close the board when the user navigates. */
+  /** Close the board when the user navigates to another session. */
   private onSessionsChanged(): void {
-    // Background/leftover executions settle through the session list (their
-    // 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.
-    if (this.deps.transport === undefined) this.scheduleReconcile()
     if (!this.boardOpen) return
     const current = currentOf(this.deps.sessions)
     if (current !== this.lastCurrent) this.closeBoard()
@@ -483,74 +430,6 @@ export class BoardController {
 
   private lastCurrent: string | undefined = undefined
 
-  /** Execution ids launched on this page; they settle via their live watch, never list reconciliation. */
-  private readonly activeExecutionIds = new Set<string>()
-
-  /** Debounce timer for {@link reconcileRunningTasks}. */
-  private reconcileTimer: ReturnType<typeof setTimeout> | undefined = undefined
-
-  /** Whether a reconcile pass is underway (single-flight guard). */
-  private reconcileInFlight = false
-
-  /**
-   * Debounce + single-flight trigger for the running-task reconciliation.
-   * Session-list notifications arrive in bursts (one per session status
-   * change); both guards together keep a burst from reading the history API
-   * once per running task.
-   */
-  private scheduleReconcile(): void {
-    if (this.reconcileTimer !== undefined) return
-    this.reconcileTimer = setTimeout(() => {
-      this.reconcileTimer = undefined
-      void this.reconcileRunningTasks()
-    }, this.deps.reconcileDebounceMs ?? 350)
-  }
-
-  /** Settle tasks left 'running' whose sessions already finished. */
-  private async reconcileRunningTasks(): Promise<void> {
-    if (this.deps.exec === undefined) return
-    if (this.reconcileInFlight) {
-      // A session change arrived while a pass was in flight. The in-flight
-      // pass already captured the task list it iterates and will not revisit
-      // this task, so dropping the notification would leave it stuck
-      // 'running'. Re-arm the debounce so the change is reconciled once the
-      // current pass settles.
-      this.scheduleReconcile()
-      return
-    }
-    this.reconcileInFlight = true
-    try {
-      type Settled = Extract<ExecutionEvent, { kind: 'settled' }>
-      const events: Array<{ taskId: string; event: Settled }> = []
-      for (const task of this.tasks) {
-        if (task.status !== 'running') continue
-        const execution = task.executions[task.executions.length - 1]
-        // Runs launched on this page settle through their live watch (turn
-        // boundary); reconciliation exists for background/leftover runs.
-        if (execution !== undefined && this.activeExecutionIds.has(execution.id)) continue
-        const event = await this.deps.exec.reconcile(task)
-        if (event !== undefined && event.kind === 'settled') events.push({ taskId: task.id, event })
-      }
-      if (events.length === 0) return
-      let changed = false
-      for (const { taskId, event } of events) {
-        // The reconcile call above awaited: a sibling tab may have rewritten
-        // the ledger (storage event reload) meanwhile. Re-read the freshest
-        // record now so the stale task captured before the await can never
-        // overwrite fields the sibling wrote.
-        const task = this.tasks.find(candidate => candidate.id === taskId)
-        if (task === undefined) continue
-        const next = settleExecution(task, event.executionId, event.outcome, this.now(), event.error)
-        if (next === task) continue
-        this.tasks = this.tasks.map(candidate => candidate.id === taskId ? next : candidate)
-        changed = true
-      }
-      if (changed) this.persistAndNotify()
-    } finally {
-      this.reconcileInFlight = false
-    }
-  }
-
   private persistAndNotify(): void {
     if (this.deps.transport === undefined) this.deps.store.save(this.tasks)
     this.notify()
@@ -676,18 +555,3 @@ export class BoardController {
     for (const fn of [...this.listeners]) fn()
   }
 }
-
-/** Record which session ran an execution (once the execution service reports it). */
-function attachSessionId(
-  task: TaskRecord,
-  executionId: string,
-  sessionId: string,
-  now: number,
-): TaskRecord {
-  return {
-    ...task,
-    updatedAt: now,
-    executions: task.executions.map(execution =>
-      execution.id === executionId ? { ...execution, sessionId } : execution),
-  }
-}

package/src/core/tasks.ts

@@ -28,6 +28,27 @@ export interface ExecutionRecord {
   error: string | undefined
 }
 
+/**
+ * Maximum number of execution records retained per task. Older settled runs
+ * are trimmed when a new execution starts so per-action ledger cost stays
+ * bounded regardless of how often a task ran before.
+ */
+export const EXECUTION_HISTORY_LIMIT = 20
+
+/**
+ * Trim an execution list to at most {@link EXECUTION_HISTORY_LIMIT} records,
+ * most recent last. A running (unsettled) execution is never trimmed: the
+ * Host monitor and restart recovery depend on the active record, and a task
+ * cannot start a new run while one is still open.
+ */
+export function retainRecentExecutions(executions: readonly ExecutionRecord[]): ExecutionRecord[] {
+  if (executions.length <= EXECUTION_HISTORY_LIMIT) return [...executions]
+  const open = executions.filter(execution => execution.endedAt === undefined)
+  const settled = executions.filter(execution => execution.endedAt !== undefined)
+  const keepSettled = Math.max(EXECUTION_HISTORY_LIMIT - open.length, 0)
+  return [...settled.slice(Math.max(settled.length - keepSettled, 0)), ...open]
+}
+
 /**
  * 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.
@@ -59,7 +80,10 @@ export interface TaskRecord {
   createdAt: number
   /** Last mutation instant (ms epoch). */
   updatedAt: number
-  /** Every execution attempt, most recent last. */
+  /**
+   * Execution history retained on the task, most recent last: the latest
+   * {@link EXECUTION_HISTORY_LIMIT} attempts, oldest trimmed on append.
+   */
   executions: ExecutionRecord[]
   /** Optional scheduled-run rule (absent on tasks without a schedule). */
   schedule?: ScheduleRule
@@ -221,7 +245,12 @@ export function startExecution(
     error: undefined,
   }
   return {
-    task: { ...task, status: 'running', updatedAt: now, executions: [...task.executions, execution] },
+    task: {
+      ...task,
+      status: 'running',
+      updatedAt: now,
+      executions: retainRecentExecutions([...task.executions, execution]),
+    },
     execution,
   }
 }

package/src/host-ledger.ts

@@ -5,7 +5,7 @@ import { dirname, join } from 'node:path'
 import { dshHome } from './dsh-home.ts'
 import { isValidCron, nextRunAtMs } from './core/schedule.ts'
 import { parseLedger } from './core/store.ts'
-import { canMoveManually, settleExecution, startExecution, withStatus, type ExecutionRecord, type TaskRecord } from './core/tasks.ts'
+import { canMoveManually, retainRecentExecutions, settleExecution, startExecution, withStatus, type ExecutionRecord, type TaskRecord } from './core/tasks.ts'
 import { applyArchiveTask, applyRestoreTask } from './core/use-cases/task-archive.ts'
 import { applyCreateTask } from './core/use-cases/task-create.ts'
 import { applyDeleteTask } from './core/use-cases/task-delete.ts'
@@ -41,6 +41,27 @@ export interface OpenedRun {
   execution: ExecutionRecord
 }
 
+/** Minimal value copy used by the Host session monitor. */
+export interface OpenExecutionReference {
+  readonly taskId: string
+  readonly executionId: string
+  readonly sessionId: string | undefined
+  readonly startedAt: number
+}
+
+/** Minimal value copy used by the Host scheduler. */
+export interface DueScheduleReference {
+  readonly taskId: string
+  readonly cron: string
+  readonly nextRunAt: number
+}
+
+/** Derived runtime data for one session-poll pass. */
+export interface LedgerRuntimeView {
+  readonly armedSchedules: number
+  readonly openExecutions: readonly OpenExecutionReference[]
+}
+
 const MAX_REQUEST_CACHE = 256
 
 interface CachedRequest {
@@ -211,7 +232,8 @@ function mergeTask(a: TaskRecord, b: TaskRecord): TaskRecord {
     const previous = byId.get(entry.id)
     byId.set(entry.id, previous === undefined ? entry : betterExecution(previous, entry))
   }
-  return { ...newer, executions: [...byId.values()].sort((x, y) => x.startedAt - y.startedAt) }
+  const executions = [...byId.values()].sort((x, y) => x.startedAt - y.startedAt)
+  return { ...newer, executions: retainRecentExecutions(executions) }
 }
 
 function parseHostTasks(values: readonly unknown[]): TaskRecord[] {
@@ -284,6 +306,50 @@ export class HostTaskLedger {
     return { revision, tasks: cloneTasks(this.document.tasks), scheduler }
   }
 
+  /**
+   * Runtime-only projection for the 5 s Host poll. It copies just primitive
+   * identifiers and timestamps, never the complete task/execution history or
+   * an authoritative mutable object from the ledger.
+   */
+  runtimeView(): LedgerRuntimeView {
+    let armedSchedules = 0
+    const openExecutions: OpenExecutionReference[] = []
+    for (const task of this.document.tasks) {
+      if (task.archivedAt === undefined && task.schedule?.enabled === true) armedSchedules += 1
+      for (const execution of task.executions) {
+        if (execution.endedAt !== undefined) continue
+        openExecutions.push({
+          taskId: task.id,
+          executionId: execution.id,
+          sessionId: execution.sessionId,
+          startedAt: execution.startedAt,
+        })
+      }
+    }
+    return { armedSchedules, openExecutions }
+  }
+
+  /** Count armed, non-archived schedules without cloning task histories. */
+  armedScheduleCount(): number {
+    let count = 0
+    for (const task of this.document.tasks) {
+      if (task.archivedAt === undefined && task.schedule?.enabled === true) count += 1
+    }
+    return count
+  }
+
+  /** Return value-only references for schedules due at the supplied Host time. */
+  dueSchedules(now: number): DueScheduleReference[] {
+    const due: DueScheduleReference[] = []
+    for (const task of this.document.tasks) {
+      if (task.archivedAt !== undefined) continue
+      const schedule = task.schedule
+      if (schedule === undefined || !schedule.enabled || schedule.nextRunAt === undefined || schedule.nextRunAt > now) continue
+      due.push({ taskId: task.id, cron: schedule.cron, nextRunAt: schedule.nextRunAt })
+    }
+    return due
+  }
+
   subscribe(listener: () => void): () => void {
     this.listeners.add(listener)
     return () => { this.listeners.delete(listener) }
@@ -509,7 +575,7 @@ export class HostTaskLedger {
     try {
       const parsed = JSON.parse(readFileSync(this.file, 'utf8')) as Partial<LedgerDocument>
       if (parsed.schemaVersion !== TASK_BOARD_SCHEMA_VERSION || !Array.isArray(parsed.tasks)) throw new Error('unsupported ledger schema')
-      const tasks = parseHostTasks(parsed.tasks)
+      const tasks = parseHostTasks(parsed.tasks).map(task => ({ ...task, executions: retainRecentExecutions(task.executions) }))
       const invalidScheduleIds = (parsed.tasks as unknown[]).flatMap(value => {
         if (typeof value !== 'object' || value === null) return []
         const row = value as { id?: unknown; schedule?: unknown }