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

package/src/client/sidebar-entry-core.ts

@@ -0,0 +1,208 @@
+// Generated by scripts/sync-shared.mjs from shared/client/sidebar-entry-core.ts. Do not edit this copy; edit the shared source and run "node scripts/sync-shared.mjs".
+/**
+ * Shared sidebar entry injection core.
+ *
+ * dsh's sidebar shell exposes no slot an external plugin can register into,
+ * so the entry row is injected between the shell's New Session button and the
+ * workspace browser. The injection self-heals: a MutationObserver watches the
+ * sidebar root and re-inserts the row whenever a React re-render displaces it
+ * (re-insertion happens in the same frame, before paint, so no flicker).
+ *
+ * The row is plain DOM (no React tree) so it can never disturb the shell's
+ * reconciliation; the view it toggles is a separate root owned by the caller.
+ *
+ * Packages receive this file as a generated copy via scripts/sync-shared.mjs;
+ * edit the shared source and re-run the sync instead of editing a copy.
+ */
+
+/** Per-package configuration for one sidebar entry row. */
+export interface SidebarEntryOptions {
+  /** Full attribute name identifying the injected row (idempotency key), e.g. 'data-dsh-ssh-entry'. */
+  rowAttribute: string
+  /** CSS selector matching the injected row, e.g. '[data-dsh-ssh-entry]'. */
+  rowSelector: string
+  /**
+   * L2 semantic-attribute plugin id (issue #506, enum table:
+   * skins/skin-center/contracts/semantic-attrs-v1.md). When set, the row also
+   * outputs data-dsh-plugin="<id>" and data-dsh-part="sidebar-entry"; unset
+   * leaves the row without semantic attributes.
+   */
+  plugin?: string
+  /** Inline icon markup (matches the shell's 16px nav-icon look). */
+  icon: string
+  /** CSS module class names for the row and its two spans (entry / entryIcon / entryLabel). */
+  css: Record<string, string>
+  /** Localized row label (aria-label + visible text). */
+  label(): string
+  /** Optional localized tooltip (title attribute). */
+  tooltip?(): string
+  /** Click action (open/toggle the owning panel). */
+  onToggle(): void
+  /** Family-block position: 'before' inserts ahead of sibling plugin rows, 'after' behind them. */
+  position: 'before' | 'after'
+  /**
+   * Selectors of the sibling plugin entry rows this package orders against
+   * (its own row included — the placement guard excludes a row that is
+   * already inside the root). Each package passes the same list it used
+   * before the consolidation so the rendered order stays stable.
+   */
+  familySelectors: readonly string[]
+  /** Optional active-state bridge; highlights the row while the panel is open. */
+  active?: {
+    subscribe(listener: () => void): () => void
+    isOpen(): boolean
+  }
+}
+
+/** Find the sidebar shell root element, or undefined while not yet mounted. */
+function sidebarRoot(): HTMLElement | undefined {
+  const column = document.querySelector<HTMLElement>('[data-pane="sidebar"], [class*="sidebarCol"]')
+  if (column === null) return undefined
+  // Current shells wrap the sidebar UI: column > wrapper > root(logoRow owner).
+  // Prefer the element that owns the logo row — the real sidebar UI root —
+  // and fall back to the column's first child for legacy shells.
+  const logoOwner = column.querySelector<HTMLElement>('[class*="logoRow"]')?.parentElement
+  return logoOwner ?? (column.firstElementChild as HTMLElement | undefined)
+}
+
+/** The New Session button: nested in the logo row on current shells, a direct child on legacy shells. */
+function newSessionButton(root: HTMLElement): HTMLButtonElement | undefined {
+  const nested = root.querySelector<HTMLButtonElement>('button[class*="newSession"]')
+  if (nested !== null) return nested
+  for (const child of root.children) {
+    if (child.tagName === 'BUTTON') return child as HTMLButtonElement
+  }
+  return undefined
+}
+
+/** Build the entry row (a detached button; insert once the shell is up). */
+function createEntry(options: SidebarEntryOptions): HTMLButtonElement {
+  const entry = document.createElement('button')
+  entry.type = 'button'
+  entry.setAttribute(options.rowAttribute, '')
+  if (options.plugin !== undefined) {
+    entry.setAttribute('data-dsh-plugin', options.plugin)
+    entry.setAttribute('data-dsh-part', 'sidebar-entry')
+  }
+  entry.className = options.css['entry'] ?? ''
+  entry.setAttribute('aria-label', options.label())
+  if (options.tooltip !== undefined) entry.setAttribute('title', options.tooltip())
+  entry.innerHTML = '<span class="' + (options.css['entryIcon'] ?? '') + '">' + options.icon
+    + '</span><span class="' + (options.css['entryLabel'] ?? '') + '">' + options.label() + '</span>'
+  entry.addEventListener('click', options.onToggle)
+  return entry
+}
+
+/** Re-insert the entry after the New Session row (before the browser region). */
+function placeEntry(root: HTMLElement, entry: HTMLButtonElement, options: SidebarEntryOptions): boolean {
+  const button = newSessionButton(root)
+  if (button === undefined) return false
+  if (entry.parentElement !== root) {
+    // Position relative to the family block (entries injected by sibling
+    // plugins), never relative to transient logoRow geometry: every family
+    // plugin that self-heals during a re-render then lands in the same
+    // relative order, so the entries cannot swap positions regardless of
+    // observer callback order or of shell wrapper changes. There is no
+    // append-to-end fallback: appending at the end would randomly reorder
+    // the block after a shell re-render.
+    const row = button.closest('[class*="logoRow"]')
+    const base = (row !== null && row.parentElement === root) ? row : button
+    const family = Array.from(root.children).filter(
+      (el): el is HTMLElement => el instanceof HTMLElement && el.matches(options.familySelectors.join(', ')),
+    )
+    const anchor = options.position === 'before'
+      ? (family.length > 0 ? family[0] : base.nextElementSibling)
+      : (family.length > 0 ? family[family.length - 1]!.nextElementSibling : base.nextElementSibling)
+    root.insertBefore(entry, anchor)
+  }
+  return true
+}
+
+/**
+ * Mount the sidebar entry, waiting for the shell to render and self-healing
+ * on later React re-renders.
+ * @param options - the row's attribute/icon/copy/action/ordering configuration.
+ * @returns disposer removing the entry and its observers.
+ */
+export function mountSidebarEntry(options: SidebarEntryOptions): () => void {
+  // DOM-level idempotency: whatever path mounted an entry row before this
+  // call (a duplicated apply, an HMR re-injection, a stale module still
+  // alive), never mount a second one. The existing row keeps working; a full
+  // page reload is the ultimate reset.
+  if (typeof document !== 'undefined' && document.querySelector(options.rowSelector) !== null) {
+    return () => {}
+  }
+  const entry = createEntry(options)
+  let root: HTMLElement | undefined
+  let placed = false
+
+  const tryPlace = (): void => {
+    if (root !== undefined && !root.isConnected) {
+      // The shell rebuilt the sidebar pane (whole-tree teardown); the root
+      // observer is gone with the old tree, so detach it and re-query from
+      // scratch. The new pane is later noticed by the body-level watcher.
+      rootObserver.disconnect()
+      root = undefined
+      placed = false
+    }
+    if (placed) {
+      // Cheap short-circuit: entry still lives in a mountable subtree.
+      if (document.body.contains(entry)) return
+      // Entry was torn down together with the old tree; reset and re-place.
+      rootObserver.disconnect()
+      root = undefined
+      placed = false
+    }
+    root ??= sidebarRoot()
+    if (root === undefined) return
+    placed = placeEntry(root, entry, options)
+    if (placed) {
+      rootObserver.observe(root, { childList: true, subtree: true })
+    }
+  }
+
+  // Body-level watcher retained as the "whole rebuild" fallback: when the shell
+  // tears down the whole sidebar pane, the root observer is gone with it and
+  // only this body observation can notice the new pane mounting. It is no
+  // longer disconnected after placement; the placed-and-still-mounted case
+  // short-circuits through the cheap document.body.contains(entry) check, so
+  // unrelated app mutations (e.g. chat streaming) cost one contains check
+  // instead of churning the full re-query.
+  const waitObserver = new MutationObserver(() => { tryPlace() })
+  waitObserver.observe(document.body, { childList: true, subtree: true })
+
+  // Self-heal: if a React re-render displaces the row, re-insert it in the
+  // same frame (microtask before paint -> no visible flicker).
+  const rootObserver = new MutationObserver(() => {
+    if (root === undefined || !root.isConnected) {
+      placed = false
+      tryPlace()
+      return
+    }
+    if (!root.contains(entry)) {
+      placed = placeEntry(root, entry, options)
+    }
+  })
+
+  // Reflect the panel's open state on the row (active highlight). Note: assigning
+  // undefined to dataset.active materializes data-active="undefined" and keeps the
+  // row permanently highlighted — delete the attribute instead.
+  const unsubscribeActive = options.active === undefined ? undefined : (() => {
+    const syncActive = (): void => {
+      if (options.active!.isOpen()) entry.dataset.active = 'true'
+      else delete entry.dataset.active
+    }
+    const unsubscribe = options.active.subscribe(syncActive)
+    syncActive()
+    return unsubscribe
+  })()
+
+  tryPlace()
+
+  return () => {
+    waitObserver.disconnect()
+    rootObserver.disconnect()
+    unsubscribeActive?.()
+    entry.remove()
+  }
+}

package/src/client/sidebar-entry.ts

@@ -1,84 +1,26 @@
 /**
- * Sidebar entry injection.
+ * Sidebar entry injection — package-specific wiring over the shared core.
  *
  * dsh's sidebar shell exposes no slot an external plugin can register into
  * (`sidebar.workspaces` / `sidebar.settings` are single-occupant and already
- * taken), so — following the skin precedent of DOM-level extension — the
- * entry row is injected between the shell's New Session button and the
- * workspace browser. The injection self-heals: a MutationObserver watches the
- * sidebar root and re-inserts the row whenever a React re-render displaces it
- * (re-insertion happens in the same frame, before paint, so no flicker).
- *
- * The row is plain DOM (no React tree) so it can never disturb the shell's
- * reconciliation; the board view it toggles is a separate React root mounted
- * in the center column (see board-mount.ts).
+ * taken), so the entry row is injected between the shell's New Session button
+ * and the workspace browser. The DOM injection / self-healing / idempotency
+ * logic lives exactly once in shared/client/sidebar-entry-core.ts (synced
+ * copy); this wrapper supplies the task-board icon, copy, CSS module, and the
+ * board toggle. The row is plain DOM (no React tree); the board view it
+ * toggles is a separate React root mounted in the center column
+ * (see board-mount.ts).
  */
 import type { BoardController } from '../core/controller.ts'
 import { t } from './locales.ts'
 import css from './board.module.css'
+import { mountSidebarEntry as mountSharedSidebarEntry } from './sidebar-entry-core.ts'
 
 /** 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>`
-
-/** Find the sidebar shell root element, or undefined while not yet mounted. */
-function sidebarRoot(): HTMLElement | undefined {
-  const column = document.querySelector<HTMLElement>('[data-pane="sidebar"], [class*="sidebarCol"]')
-  if (column === null) return undefined
-  // Current shells wrap the sidebar UI: column > wrapper > root(logoRow owner).
-  // Prefer the element that owns the logo row — the real sidebar UI root —
-  // and fall back to the column's first child for legacy shells.
-  const logoOwner = column.querySelector<HTMLElement>('[class*="logoRow"]')?.parentElement
-  return logoOwner ?? (column.firstElementChild as HTMLElement | undefined)
-}
-
-/** The New Session button: nested in the logo row on current shells, a direct child on legacy shells. */
-function newSessionButton(root: HTMLElement): HTMLButtonElement | undefined {
-  const nested = root.querySelector<HTMLButtonElement>('button[class*="newSession"]')
-  if (nested !== null) return nested
-  for (const child of root.children) {
-    if (child.tagName === 'BUTTON') return child as HTMLButtonElement
-  }
-  return undefined
-}
-
-/** Build the entry row (a detached button; insert once the shell is up). */
-function createEntry(controller: BoardController): HTMLButtonElement {
-  const entry = document.createElement('button')
-  entry.type = 'button'
-  entry.dataset.dshTaskboardEntry = ''
-  entry.className = css.entry
-  entry.setAttribute('aria-label', t('entry.label'))
-  entry.innerHTML = `<span class="${css.entryIcon}">${ICON}</span><span class="${css.entryLabel}">${t('entry.label')}</span>`
-  entry.addEventListener('click', () => { controller.toggleBoard() })
-  return entry
-}
-
-/** Re-insert the entry after the New Session row (before the browser region). */
-function placeEntry(root: HTMLElement, entry: HTMLButtonElement): boolean {
-  const button = newSessionButton(root)
-  if (button === undefined) return false
-  if (entry.parentElement !== root) {
-    // Position relative to the family block (entries injected by sibling
-    // plugins), never relative to transient logoRow geometry: every family
-    // plugin that self-heals during a re-render then lands in the same
-    // relative order, so the entries cannot swap positions regardless of
-    // observer callback order or of shell wrapper changes. There is no
-    // append-to-end fallback: appending at the end would randomly reorder
-    // the block after a shell re-render.
-    const row = button.closest('[class*="logoRow"]')
-    const base = (row !== null && row.parentElement === root) ? row : button
-    const family = Array.from(root.children).filter(
-      (el): el is HTMLElement => el instanceof HTMLElement && el.matches('[data-dsh-taskboard-entry], [data-dsh-ssh-entry]'),
-    )
-    // task board sits before the whole family block.
-    const anchor = family.length > 0 ? family[0] : base.nextElementSibling
-    root.insertBefore(entry, anchor)
-  }
-  return true
-}
+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>'
 
 /**
  * Mount the sidebar entry, waiting for the shell to render and self-healing
@@ -87,81 +29,19 @@ function placeEntry(root: HTMLElement, entry: HTMLButtonElement): boolean {
  * @returns disposer removing the entry and its observers.
  */
 export function mountSidebarEntry(controller: BoardController): () => void {
-  // DOM-level idempotency: whatever path mounted an entry row before this
-  // call (a duplicated apply, an HMR re-injection, a stale module still
-  // alive), never mount a second one. The existing row keeps working; a full
-  // page reload is the ultimate reset.
-  if (typeof document !== 'undefined' && document.querySelector('[data-dsh-taskboard-entry]') !== null) {
-    return () => {}
-  }
-  const entry = createEntry(controller)
-  let root: HTMLElement | undefined
-  let placed = false
-
-  const tryPlace = (): void => {
-    if (root !== undefined && !root.isConnected) {
-      // The shell rebuilt the sidebar pane (whole-tree teardown); the root
-      // observer is gone with the old tree, so detach it and re-query from
-      // scratch. The new pane is later noticed by the body-level watcher.
-      rootObserver.disconnect()
-      root = undefined
-      placed = false
-    }
-    if (placed) {
-      // Cheap short-circuit: entry still lives in a mountable subtree.
-      if (document.body.contains(entry)) return
-      // Entry was torn down together with the old tree; reset and re-place.
-      rootObserver.disconnect()
-      root = undefined
-      placed = false
-    }
-    root ??= sidebarRoot()
-    if (root === undefined) return
-    placed = placeEntry(root, entry)
-    if (placed) {
-      rootObserver.observe(root, { childList: true, subtree: true })
-    }
-  }
-
-  // Body-level watcher retained as the "whole rebuild" fallback: when the shell
-  // tears down the whole sidebar pane, the root observer is gone with it and
-  // only this body observation can notice the new pane mounting. It is no
-  // longer disconnected after placement; the placed-and-still-mounted case
-  // short-circuits through the cheap document.body.contains(entry) check, so
-  // unrelated app mutations (e.g. chat streaming) cost one contains check
-  // instead of churning the full re-query.
-  const waitObserver = new MutationObserver(() => { tryPlace() })
-  waitObserver.observe(document.body, { childList: true, subtree: true })
-
-  // Self-heal: if a React re-render displaces the row, re-insert it in the
-  // same frame (microtask before paint → no visible flicker).
-  const rootObserver = new MutationObserver(() => {
-    if (root === undefined || !root.isConnected) {
-      placed = false
-      tryPlace()
-      return
-    }
-    if (!root.contains(entry)) {
-      placed = placeEntry(root, entry)
-    }
+  return mountSharedSidebarEntry({
+    rowAttribute: 'data-dsh-taskboard-entry',
+    rowSelector: ENTRY_SELECTOR,
+    plugin: 'task-board',
+    icon: ICON,
+    css,
+    label: () => t('entry.label'),
+    onToggle: () => { controller.toggleBoard() },
+    position: 'before',
+    familySelectors: ['[data-dsh-taskboard-entry]', '[data-dsh-ssh-entry]'],
+    active: {
+      subscribe: (listener) => controller.subscribe(listener),
+      isOpen: () => controller.getSnapshot().boardOpen,
+    },
   })
-
-  // Reflect the board's open state on the row (active highlight). Note: assigning
-  // undefined to dataset.active materializes data-active="undefined" and keeps the
-  // row permanently highlighted — delete the attribute instead.
-  const syncActive = () => {
-    if (controller.getSnapshot().boardOpen) entry.dataset.active = 'true'
-    else delete entry.dataset.active
-  }
-  const unsubscribe = controller.subscribe(syncActive)
-  syncActive()
-
-  tryPlace()
-
-  return () => {
-    waitObserver.disconnect()
-    rootObserver.disconnect()
-    unsubscribe()
-    entry.remove()
-  }
 }

package/src/core/controller.ts

@@ -23,13 +23,13 @@ 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'
+import type { TaskBoardAction, TaskBoardEventPayload, 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
+  subscribe(listener: (event?: TaskBoardEventPayload) => void): () => void
 }
 
 /** The sessions face the controller needs for navigation awareness. */
@@ -601,7 +601,7 @@ export class BoardController {
       this.acceptRemote(await transport.bootstrap(this.tasks))
       if (!this.remoteSubscribed) {
         this.remoteSubscribed = true
-        this.disposers.push(transport.subscribe(() => { void this.refreshRemote() }))
+        this.disposers.push(transport.subscribe((event) => { this.onRemoteEvent(event) }))
       }
       return true
     } catch (error) {
@@ -611,6 +611,23 @@ export class BoardController {
     }
   }
 
+  /**
+   * SSE frames carry revision/scheduler/power. When the revision matches the
+   * one already applied, apply the frame's scheduler/power in place and skip
+   * the full /state fetch; otherwise the 5 s heartbeat would re-clone and
+   * re-serialize the whole ledger per tab even while nothing changes.
+   */
+  private onRemoteEvent(event: TaskBoardEventPayload | undefined): void {
+    if (event !== undefined && this.hostState !== undefined && event.revision === this.hostState.revision
+      && typeof event.scheduler === 'object' && event.scheduler !== null
+      && typeof event.power === 'object' && event.power !== null) {
+      this.hostState = { revision: event.revision, scheduler: event.scheduler, power: event.power }
+      this.notify()
+      return
+    }
+    void this.refreshRemote()
+  }
+
   private async refreshRemote(preserveError?: string): Promise<boolean> {
     const transport = this.deps.transport
     if (transport === undefined) return true

package/src/core/schedule.ts

@@ -77,22 +77,73 @@ export function isValidCron(expr: string): boolean {
  * 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.
+ *
+ * Walks candidate year/month/day/hour/minute values straight from the parsed
+ * field sets instead of scanning every minute: a sparse expression such as
+ * `0 0 29 2 *` used to iterate ~1.5M wall-clock minutes before reaching the
+ * next leap day. Wall-clock field construction + the final `matches` re-check
+ * preserve the old minute scan's DST semantics exactly (nonexistent spring
+ * minutes normalize forward and the repeated fall-back hour is never visited).
  */
 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 + 5 * 366 * 24 * 60 * 60 * 1000
-  while (scan.getTime() <= limitMs) {
-    if (matches(schedule, scan)) return scan.getTime()
-    scan.setMinutes(scan.getMinutes() + 1)
+
+  const sortedMinutes = [...schedule.minutes].sort((a, b) => a - b)
+  const sortedHours = [...schedule.hours].sort((a, b) => a - b)
+  const sortedMonths = [...schedule.months].sort((a, b) => a - b)
+
+  let year = from.getFullYear()
+  let month = from.getMonth() + 1
+  let day = from.getDate()
+  let hour = from.getHours()
+  // Strictly after fromMs: the old scan started from the next minute.
+  let minute = from.getMinutes() + 1
+
+  while (new Date(year, month - 1, 1, 0, 0, 0, 0).getTime() <= limitMs) {
+    for (const candidateMonth of sortedMonths) {
+      if (candidateMonth < month) continue
+      const daysInMonth = new Date(year, candidateMonth, 0).getDate()
+      const dayStart = candidateMonth === month ? day : 1
+      for (let candidateDay = dayStart; candidateDay <= daysInMonth; candidateDay += 1) {
+        const dayProbe = new Date(year, candidateMonth - 1, candidateDay, 0, 0, 0, 0)
+        if (!dayCandidate(schedule, dayProbe)) continue
+        const hourStart = candidateMonth === month && candidateDay === day ? hour : 0
+        for (const candidateHour of sortedHours) {
+          if (candidateHour < hourStart) continue
+          const minuteStart = candidateMonth === month && candidateDay === day && candidateHour === hour ? minute : 0
+          for (const candidateMinute of sortedMinutes) {
+            if (candidateMinute < minuteStart) continue
+            const candidate = new Date(year, candidateMonth - 1, candidateDay, candidateHour, candidateMinute, 0, 0)
+            const time = candidate.getTime()
+            if (time <= fromMs) continue
+            if (time > limitMs) return undefined
+            if (matches(schedule, candidate)) return time
+          }
+        }
+      }
+    }
+    year += 1
+    month = 1
+    day = 1
+    hour = 0
+    minute = 0
   }
   return undefined
 }
 
+/** Day/weekday OR gate shared by {@link matches} and the candidate scan. */
+function dayCandidate(schedule: CronSchedule, date: Date): boolean {
+  const dayMatches = schedule.days.has(date.getDate())
+  const weekdayMatches = schedule.weekdays.has(date.getDay())
+  if (schedule.dayWildcard) return weekdayMatches
+  if (schedule.weekdayWildcard) return dayMatches
+  return dayMatches || weekdayMatches
+}
+
 /** Reject impossible month/day pairs without spending the multi-year scan. */
 function hasPossibleCalendarDay(schedule: CronSchedule): boolean {
   if (schedule.dayWildcard || !schedule.weekdayWildcard) return true
@@ -145,11 +196,7 @@ function matches(schedule: CronSchedule, date: Date): boolean {
   if (!schedule.minutes.has(date.getMinutes())) return false
   if (!schedule.hours.has(date.getHours())) return false
   if (!schedule.months.has(date.getMonth() + 1)) return false
-  const dayMatches = schedule.days.has(date.getDate())
-  const weekdayMatches = schedule.weekdays.has(date.getDay())
-  if (schedule.dayWildcard) return weekdayMatches
-  if (schedule.weekdayWildcard) return dayMatches
-  return dayMatches || weekdayMatches
+  return dayCandidate(schedule, date)
 }
 
 function isDigits(value: string): boolean {

package/src/host-ledger.ts

@@ -120,11 +120,14 @@ export class HostTaskLedger {
   private lockFd: number | undefined
   readonly file: string
   readonly lockFile: string
+  /** Small sidecar for the 30 s scheduler heartbeat (lastTickAt only). */
+  readonly schedulerFile: string
 
   constructor(dir: string = join(dshHome(), 'task-board'), private readonly now: () => number = Date.now) {
     mkdirSync(dir, { recursive: true })
     this.file = join(dir, 'ledger-v2.json')
     this.lockFile = join(dir, 'ledger-v2.lock')
+    this.schedulerFile = join(dir, 'scheduler-v2.json')
     this.lockFd = this.acquireLock()
     try {
       this.document = this.load(dir)
@@ -142,9 +145,15 @@ export class HostTaskLedger {
     }
   }
 
-  state(): LedgerState {
+  /** Revision + scheduler without any task cloning; feeds the SSE event frame. */
+  summary(): { revision: number; scheduler: TaskBoardSchedulerSnapshot } {
     const { importedSources: _imports, ...scheduler } = this.document.scheduler
-    return { revision: this.document.revision, tasks: cloneTasks(this.document.tasks), scheduler: { ...scheduler } }
+    return { revision: this.document.revision, scheduler: { ...scheduler } }
+  }
+
+  state(): LedgerState {
+    const { revision, scheduler } = this.summary()
+    return { revision, tasks: cloneTasks(this.document.tasks), scheduler }
   }
 
   subscribe(listener: () => void): () => void {
@@ -215,6 +224,14 @@ export class HostTaskLedger {
 
   setScheduler(patch: Partial<TaskBoardSchedulerSnapshot>): void {
     this.document.scheduler = { ...this.document.scheduler, ...patch }
+    // The 30 s heartbeat only moves lastTickAt; rewriting the whole ledger
+    // for it made idle idle cost O(ledger bytes) every tick. Persist it to a
+    // tiny sidecar instead; any other patch still goes through the full
+    // atomic commit.
+    if (patch.lastTickAt !== undefined && Object.keys(patch).every(key => key === 'lastTickAt')) {
+      this.writeSchedulerSidecar()
+      return
+    }
     this.commit(false)
   }
 
@@ -374,6 +391,13 @@ export class HostTaskLedger {
           ? [typeof row.id === 'string' ? row.id : 'unknown']
           : []
       })
+      const documentLastTickAt = typeof parsed.scheduler?.lastTickAt === 'number' ? parsed.scheduler.lastTickAt : undefined
+      const sidecarLastTickAt = this.readSchedulerSidecar()
+      // A sidecar write can be newer than the last full commit (crash between
+      // the two); lastTickAt only ever moves forward, so take the greater.
+      const lastTickAt = sidecarLastTickAt === undefined || (documentLastTickAt !== undefined && documentLastTickAt >= sidecarLastTickAt)
+        ? documentLastTickAt
+        : sidecarLastTickAt
       return {
         schemaVersion: TASK_BOARD_SCHEMA_VERSION,
         revision: Number.isSafeInteger(parsed.revision) && (parsed.revision as number) >= 0 ? parsed.revision as number : 0,
@@ -381,7 +405,7 @@ export class HostTaskLedger {
         scheduler: {
           timeZone: timeZone(),
           ledgerId: typeof parsed.scheduler?.ledgerId === 'string' && parsed.scheduler.ledgerId !== '' ? parsed.scheduler.ledgerId : crypto.randomUUID(),
-          ...(typeof parsed.scheduler?.lastTickAt === 'number' ? { lastTickAt: parsed.scheduler.lastTickAt } : {}),
+          ...(lastTickAt === undefined ? {} : { lastTickAt }),
           ...(typeof parsed.scheduler?.error === 'string' ? { error: parsed.scheduler.error } : {}),
           ...(invalidScheduleIds.length > 0 ? { error: `invalid cron disabled for task(s): ${invalidScheduleIds.join(', ')}` } : {}),
           ...(Array.isArray(parsed.scheduler?.importedSources) ? { importedSources: parsed.scheduler.importedSources.filter(x => typeof x === 'string') } : {}),
@@ -416,6 +440,43 @@ export class HostTaskLedger {
     }))
   }
 
+  private readSchedulerSidecar(): number | undefined {
+    try {
+      const parsed = JSON.parse(readFileSync(this.schedulerFile, 'utf8')) as { lastTickAt?: unknown }
+      return typeof parsed.lastTickAt === 'number' && Number.isFinite(parsed.lastTickAt) ? parsed.lastTickAt : undefined
+    } catch {
+      return undefined
+    }
+  }
+
+  /** Atomic write of the scheduler heartbeat sidecar (0600, tmp + rename + fsync). */
+  private writeSchedulerSidecar(): void {
+    const payload = JSON.stringify({ lastTickAt: this.document.scheduler.lastTickAt })
+    mkdirSync(dirname(this.schedulerFile), { recursive: true })
+    const tmp = `${this.schedulerFile}.tmp-${process.pid}`
+    let fd: number | undefined
+    try {
+      fd = openSync(tmp, 'w', 0o600)
+      writeFileSync(fd, payload, { encoding: 'utf8' })
+      fsyncSync(fd)
+      closeSync(fd)
+      fd = undefined
+      try { chmodSync(tmp, 0o600) } catch { /* Windows ACLs own access */ }
+      renameSync(tmp, this.schedulerFile)
+      try {
+        const dirFd = openSync(dirname(this.schedulerFile), 'r')
+        try { fsyncSync(dirFd) } finally { closeSync(dirFd) }
+      } catch {
+        // Windows does not permit fsync on a directory handle; rename remains atomic.
+      }
+    } catch (error) {
+      if (fd !== undefined) closeSync(fd)
+      try { unlinkSync(tmp) } catch { /* best-effort temporary cleanup */ }
+      throw error
+    }
+    this.notify()
+  }
+
   private commit(bumpRevision = true): void {
     if (bumpRevision) this.document.revision += 1
     mkdirSync(dirname(this.file), { recursive: true })