@linxin666/dsh-client-ui-task-board 0.3.20 → 0.3.21

package/lib/index.js

@@ -154,7 +154,7 @@ function parseField(field, min, max, out) {
 			high = Number(b);
 		} else if (isDigits(range)) {
 			low = Number(range);
-			high = Number(range);
+			high = stepRaw === void 0 ? low : max;
 		} else return false;
 		if (low < min || high > max || low > high) return false;
 		const step = stepRaw === void 0 ? 1 : isDigits(stepRaw) ? Number(stepRaw) : NaN;
@@ -244,8 +244,18 @@ function retainRecentExecutions(executions) {
 	const keepSettled = Math.max(20 - open.length, 0);
 	return [...settled.slice(Math.max(settled.length - keepSettled, 0)), ...open];
 }
-/** Statuses a settled task may be archived from. */
-const ARCHIVABLE_STATUSES = ["done", "failed"];
+/**
+* Statuses a task may be archived from: every status but `running`, whose
+* execution the runner still owns until it settles. A settled-only gate made
+* the duplicate-and-archive flow a silent no-op for scheduled tasks, which
+* return to `todo` after every successful run (issue #1447).
+*/
+const ARCHIVABLE_STATUSES = [
+	"backlog",
+	"todo",
+	"done",
+	"failed"
+];
 /** Permission presets a task may pin on its execution session (the `/permission <id>` ids). */
 const TASK_PERMISSIONS = [
 	"read-only",
@@ -731,10 +741,10 @@ function parseLedger(raw) {
 //#endregion
 //#region src/core/use-cases/task-archive.ts
 /**
-* 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). Archiving disarms a schedule; already-archived tasks
-* are a no-op.
+* Archive one task: only a `running` task stays on the board (its runner
+* still owns its lifecycle until the execution settles); every other status
+* can be archived. Archiving disarms a schedule; already-archived tasks are
+* a no-op.
 */
 function applyArchiveTask(tasks, id, now) {
 	let applied = false;

package/lib/types/client/body-mutations.d.ts

@@ -0,0 +1,45 @@
+/**
+ * One `document.body` MutationObserver per page, shared by every family
+ * plugin bundle.
+ *
+ * Family plugins that inject at the DOM level must notice when the shell
+ * re-renders around their injected node: the sidebar entry rows
+ * (sidebar-entry-core), the center-column panel containers
+ * (panel-mount-core), and the aggregate shell's column shims. Each consumer
+ * used to install its OWN `MutationObserver` on `document.body` with
+ * `{ childList: true, subtree: true }`, so a page carrying N family plugins
+ * paid N native observers and N callback invocations for EVERY mutation batch
+ * the app produced — chat token streaming alone produces many per second, and
+ * the count grows with the number of installed plugins.
+ *
+ * This module keeps exactly ONE body observer per page. The registry lives on
+ * `globalThis` under a `Symbol.for` key, so the per-package generated copies
+ * of this file (scripts/sync-shared.mjs) and separately bundled plugins all
+ * reach the same hub at runtime instead of one hub per module instance.
+ * Record subscribers receive the mutations accumulated since the last flush.
+ * Consumers that only re-check their DOM use subscribeBodyInvalidations:
+ * when all subscribers use that path, the hub retains no mutation records
+ * (or detached subtrees) while a background page's animation frames pause.
+ * Both paths run at most once per frame. The last subscriber disconnects the
+ * observer, cancels the pending frame and releases its records.
+ *
+ * Failure policy: without a DOM or `MutationObserver` the subscription is a
+ * no-op disposer (the same silence the per-consumer observers had), and when
+ * `requestAnimationFrame` is unavailable the flush runs synchronously so a
+ * subscriber is never silently dropped. A throwing subscriber cannot stop the
+ * others.
+ */
+/**
+ * Subscribe to a coalesced DOM re-check without retaining mutation records.
+ * The marked wrapper also works with an older hub, which delivers records
+ * that it simply ignores until a page reload picks up the updated hub.
+ */
+export declare function subscribeBodyInvalidations(subscriber: () => void): () => void;
+/**
+ * Subscribe to body-level childList mutations.
+ * @param subscriber - called at most once per animation frame with the records
+ *   collected since the previous flush; must be safe to run repeatedly.
+ * @returns the disposer removing this subscriber (and the observer when it was
+ *   the last one).
+ */
+export declare function subscribeBodyMutations(subscriber: (records: MutationRecord[]) => void): () => void;

package/lib/types/client/panel-mount-core.d.ts

@@ -21,7 +21,7 @@
 import { type Root } from 'react-dom/client';
 /** Options for mountCenterPanel; dsh-ssh mount.tsx and dsh-task-board board-mount.tsx are the canonical consumers. */
 export interface CenterPanelMountOptions {
-    /** Render the panel React tree into a root (initial mount, remount, locale refresh). */
+    /** Render the panel tree (first open, remount while open, locale refresh). */
     render: (root: Root) => void;
     /** dataset key of the injected container's view attribute, e.g. `dshSshView` for `data-dsh-ssh-view`. */
     viewDatasetKey: string;

package/lib/types/client/sidebar-entry-core.d.ts

@@ -1,18 +1,3 @@
-/**
- * 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'. */

package/lib/types/core/controller.d.ts

@@ -154,9 +154,8 @@ export declare class BoardController {
     moveTask(id: string, status: TaskStatus): void;
     deleteTask(id: string): void;
     /**
-     * Archive a settled task (done/failed). Running or on-board-unsettled
-     * tasks are refused so the runner keeps exclusive ownership of their
-     * lifecycle.
+     * Archive a task from any status but `running`, whose lifecycle the runner
+     * keeps exclusive ownership of until it settles.
      * @returns true when applied.
      */
     archiveTask(id: string): boolean;

package/lib/types/core/tasks.d.ts

@@ -158,7 +158,12 @@ export interface TaskRecord {
      */
     archivedAt?: number;
 }
-/** Statuses a settled task may be archived from. */
+/**
+ * Statuses a task may be archived from: every status but `running`, whose
+ * execution the runner still owns until it settles. A settled-only gate made
+ * the duplicate-and-archive flow a silent no-op for scheduled tasks, which
+ * return to `todo` after every successful run (issue #1447).
+ */
 export declare const ARCHIVABLE_STATUSES: readonly TaskStatus[];
 /** Permission presets a task may pin on its execution session (the `/permission <id>` ids). */
 export declare const TASK_PERMISSIONS: readonly ["read-only", "workspace-write", "danger-full-access"];

package/lib/types/core/use-cases/task-archive.d.ts

@@ -1,6 +1,6 @@
 /**
- * Archive/restore task use case: move a settled (done/failed) task off the
- * main board and back. The task keeps its status, execution history, and
+ * Archive/restore task use case: move a task off the main board and back,
+ * whatever its status but `running`. 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.
  */
@@ -13,10 +13,10 @@ export interface ArchiveTaskResult {
     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). Archiving disarms a schedule; already-archived tasks
- * are a no-op.
+ * Archive one task: only a `running` task stays on the board (its runner
+ * still owns its lifecycle until the execution settles); every other status
+ * can be archived. Archiving disarms a schedule; already-archived tasks are
+ * a no-op.
  */
 export declare function applyArchiveTask(tasks: readonly TaskRecord[], id: string, now: number): ArchiveTaskResult;
 /** Restore one task back onto the main board (clears the archive marker). */

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@linxin666/dsh-client-ui-task-board",
   "description": "Host-authoritative task board for the DSH Web GUI with real session execution, Host cron scheduling, and optional cross-platform idle-sleep protection; mounted without DSH source changes.",
-  "version": "0.3.20",
+  "version": "0.3.21",
   "type": "module",
   "main": "lib/index.js",
   "types": "lib/types/index.d.ts",

package/src/client/board/TaskDetail.tsx

@@ -347,8 +347,10 @@ export function TaskDetail({ controller, task }: { controller: BoardController;
               </p>
               <p className={css.detailText}><strong>{t('detail.handover.references')}</strong></p>
               <ul className={css.executionList}>
-                {current.handover.references.map(reference => (
-                  <li key={reference} className={css.executionRow}><code>{reference}</code></li>
+                {current.handover.references.map((reference, index) => (
+                  // References are free text from the freeze block, so the same
+                  // string can appear twice; the index keeps the key unique (#1492).
+                  <li key={`${reference}-${index}`} className={css.executionRow}><code>{reference}</code></li>
                 ))}
               </ul>
               <p className={css.detailMeta}>{t('detail.handover.bundledAt', { time: formatHostTimestamp(current.handover.bundledAt, timeZone) })}</p>

package/src/client/body-mutations.ts

@@ -0,0 +1,133 @@
+// Generated by scripts/sync-shared.mjs from shared/client/body-mutations.ts. Do not edit this copy; edit the shared source and run "node scripts/sync-shared.mjs".
+/**
+ * One `document.body` MutationObserver per page, shared by every family
+ * plugin bundle.
+ *
+ * Family plugins that inject at the DOM level must notice when the shell
+ * re-renders around their injected node: the sidebar entry rows
+ * (sidebar-entry-core), the center-column panel containers
+ * (panel-mount-core), and the aggregate shell's column shims. Each consumer
+ * used to install its OWN `MutationObserver` on `document.body` with
+ * `{ childList: true, subtree: true }`, so a page carrying N family plugins
+ * paid N native observers and N callback invocations for EVERY mutation batch
+ * the app produced — chat token streaming alone produces many per second, and
+ * the count grows with the number of installed plugins.
+ *
+ * This module keeps exactly ONE body observer per page. The registry lives on
+ * `globalThis` under a `Symbol.for` key, so the per-package generated copies
+ * of this file (scripts/sync-shared.mjs) and separately bundled plugins all
+ * reach the same hub at runtime instead of one hub per module instance.
+ * Record subscribers receive the mutations accumulated since the last flush.
+ * Consumers that only re-check their DOM use subscribeBodyInvalidations:
+ * when all subscribers use that path, the hub retains no mutation records
+ * (or detached subtrees) while a background page's animation frames pause.
+ * Both paths run at most once per frame. The last subscriber disconnects the
+ * observer, cancels the pending frame and releases its records.
+ *
+ * Failure policy: without a DOM or `MutationObserver` the subscription is a
+ * no-op disposer (the same silence the per-consumer observers had), and when
+ * `requestAnimationFrame` is unavailable the flush runs synchronously so a
+ * subscriber is never silently dropped. A throwing subscriber cannot stop the
+ * others.
+ */
+
+/** The page-wide hub: one observer plus its subscribers and pending records. */
+interface BodyMutationHub {
+  observer: MutationObserver
+  subscribers: Set<(records: MutationRecord[]) => void>
+  pending: MutationRecord[]
+  scheduled: boolean
+  frame?: number
+}
+
+/** Cross-bundle registry key; `Symbol.for` so every module copy agrees. */
+const HUB_KEY = Symbol.for('dsh-web.body-mutation-hub')
+const INVALIDATION_ONLY = Symbol.for('dsh-web.body-mutation-invalidation')
+type Subscriber = ((records: MutationRecord[]) => void) & { [INVALIDATION_ONLY]?: true }
+
+function needsRecords(subscribers: Set<(records: MutationRecord[]) => void>): boolean {
+  for (const listener of subscribers) {
+    if (!(listener as Subscriber)[INVALIDATION_ONLY]) return true
+  }
+  return false
+}
+
+/**
+ * Subscribe to a coalesced DOM re-check without retaining mutation records.
+ * The marked wrapper also works with an older hub, which delivers records
+ * that it simply ignores until a page reload picks up the updated hub.
+ */
+export function subscribeBodyInvalidations(subscriber: () => void): () => void {
+  const listener: Subscriber = () => { subscriber() }
+  listener[INVALIDATION_ONLY] = true
+  return subscribeBodyMutations(listener)
+}
+
+/**
+ * Subscribe to body-level childList mutations.
+ * @param subscriber - called at most once per animation frame with the records
+ *   collected since the previous flush; must be safe to run repeatedly.
+ * @returns the disposer removing this subscriber (and the observer when it was
+ *   the last one).
+ */
+export function subscribeBodyMutations(subscriber: (records: MutationRecord[]) => void): () => void {
+  if (typeof globalThis === 'undefined' || typeof document === 'undefined') return () => {}
+  if (typeof MutationObserver !== 'function') return () => {}
+  const registry = globalThis as unknown as Record<symbol, unknown>
+  let hub = registry[HUB_KEY] as BodyMutationHub | undefined
+  if (hub === undefined) {
+    const subscribers = new Set<(records: MutationRecord[]) => void>()
+    const created: BodyMutationHub = {
+      observer: undefined as unknown as MutationObserver,
+      subscribers,
+      pending: [],
+      scheduled: false,
+    }
+    const flush = (): void => {
+      created.frame = undefined
+      created.scheduled = false
+      const batch = created.pending
+      created.pending = []
+      for (const listener of [...subscribers]) {
+        if (!subscribers.has(listener)) continue
+        try {
+          listener(batch)
+        } catch {
+          // One subscriber must never break the others; the next flush retries it.
+        }
+      }
+    }
+    const schedule = (): void => {
+      if (created.scheduled) return
+      created.scheduled = true
+      if (typeof requestAnimationFrame === 'function') created.frame = requestAnimationFrame(flush)
+      else flush()
+    }
+    created.observer = new MutationObserver((records) => {
+      if (needsRecords(subscribers)) {
+        for (const record of records) created.pending.push(record)
+      }
+      schedule()
+    })
+    created.observer.observe(document.body ?? document.documentElement, { childList: true, subtree: true })
+    registry[HUB_KEY] = created
+    hub = created
+  }
+  const active = hub
+  active.subscribers.add(subscriber)
+  let subscribed = true
+  return () => {
+    if (!subscribed) return
+    subscribed = false
+    active.subscribers.delete(subscriber)
+    if (!needsRecords(active.subscribers)) active.pending = []
+    if (active.subscribers.size === 0 && registry[HUB_KEY] === active) {
+      active.observer.disconnect()
+      if (active.frame !== undefined && typeof cancelAnimationFrame === 'function') cancelAnimationFrame(active.frame)
+      active.frame = undefined
+      active.pending = []
+      active.scheduled = false
+      delete registry[HUB_KEY]
+    }
+  }
+}

package/src/client/index.ts

@@ -80,7 +80,7 @@ declare module '@deepseek-ai/cordis' {
  * on hosts below that cohort, which serve the same roster through the
  * connection RPC face.
  */
-export const inject = ['slots', 'sessions', 'workspaces', 'connection', 'settingsScope', 'locale', 'remote']
+export const inject = ['slots', 'sessions', 'workspaces', 'connection', 'settingsScope', 'locale', 'remote', 'remote.session']
 
 /** One agent-preset row the mode picker consumes (either face's wire shape). */
 interface PresetRosterRow {
@@ -251,31 +251,63 @@ export function apply(ctx: ClientContext): void {
     }
     const pushModelOptions = async (): Promise<void> => {
       try {
-        const conn = ctx.get('connection') as { api?: { llm?: { discoverModels?: () => Promise<unknown> }; sessions?: { modelCatalog?: () => Promise<unknown> } } } | undefined
-        if (conn?.api) {
-          let models: Array<{ id: string; name?: string; provider?: string }> = []
-          if (typeof conn.api.llm?.discoverModels === 'function') {
-            const res = await conn.api.llm.discoverModels() as { result?: { value?: { models?: Array<{ id: string; name?: string }> } } }
-            const list = res?.result?.value?.models
-            if (Array.isArray(list)) {
-              models = list.map(m => ({ id: m.id, name: m.name }))
+        let models: Array<{ id: string; name?: string; provider?: string }> = []
+        let sessionRemote: ClientRemote['session'] | undefined
+        try {
+          sessionRemote = (remote as Partial<ClientRemote>).session
+        } catch {
+          sessionRemote = undefined
+        }
+        if (typeof sessionRemote?.modelCatalog === 'function') {
+          const res = await sessionRemote.modelCatalog()
+          if (res.ok && Array.isArray(res.value?.groups)) {
+            for (const g of res.value.groups) {
+              const provider = (g as { id?: string; provider?: string }).id ?? (g as { id?: string; provider?: string }).provider
+              for (const m of g.models ?? []) {
+                const qualifiedId = provider ? `${provider}/${m.id}` : m.id
+                models.push({ id: qualifiedId, name: m.name ?? m.id, provider })
+              }
             }
           }
-          if (models.length === 0 && typeof conn.api.sessions?.modelCatalog === 'function') {
-            const res = await conn.api.sessions.modelCatalog() as { result?: { value?: { groups?: Array<{ provider?: string; models?: Array<{ id: string; name?: string }> }> } } }
-            const groups = res?.result?.value?.groups
-            if (Array.isArray(groups)) {
-              for (const g of groups) {
-                for (const m of g.models ?? []) {
-                  const qualifiedId = g.provider ? `${g.provider}/${m.id}` : m.id
-                  models.push({ id: qualifiedId, name: m.name ?? m.id, provider: g.provider })
+        }
+        if (models.length === 0) {
+          const conn = ctx.get('connection') as {
+            api?: {
+              llm?: { discoverModels?: () => Promise<unknown> }
+              sessions?: { modelCatalog?: () => Promise<unknown> }
+              session?: { modelCatalog?: () => Promise<unknown> }
+            }
+          } | undefined
+          if (conn?.api) {
+            if (typeof conn.api.llm?.discoverModels === 'function') {
+              const res = await conn.api.llm.discoverModels() as { result?: { value?: { models?: Array<{ id: string; name?: string }> } } }
+              const list = res?.result?.value?.models
+              if (Array.isArray(list)) {
+                models = list.map(m => ({ id: m.id, name: m.name }))
+              }
+            }
+            const catalogFn = typeof conn.api.session?.modelCatalog === 'function'
+              ? conn.api.session.modelCatalog
+              : typeof conn.api.sessions?.modelCatalog === 'function'
+                ? conn.api.sessions.modelCatalog
+                : undefined
+            if (models.length === 0 && catalogFn !== undefined) {
+              const res = await catalogFn() as { result?: { value?: { groups?: Array<{ id?: string; provider?: string; models?: Array<{ id: string; name?: string }> }> } } }
+              const groups = res?.result?.value?.groups
+              if (Array.isArray(groups)) {
+                for (const g of groups) {
+                  const provider = g.id ?? g.provider
+                  for (const m of g.models ?? []) {
+                    const qualifiedId = provider ? `${provider}/${m.id}` : m.id
+                    models.push({ id: qualifiedId, name: m.name ?? m.id, provider })
+                  }
                 }
               }
             }
           }
-          if (models.length > 0) {
-            controller.setExecutionOptions({ models })
-          }
+        }
+        if (models.length > 0) {
+          controller.setExecutionOptions({ models })
         }
       } catch (error) {
         console.error('[dsh-task-board] model options read failed', error)

package/src/client/panel-mount-core.ts

@@ -20,10 +20,11 @@
  * (shared/client/sidebar-entry-core.ts, synced copy).
  */
 import { createRoot, type Root } from 'react-dom/client'
+import { subscribeBodyInvalidations } from './body-mutations.ts'
 
 /** Options for mountCenterPanel; dsh-ssh mount.tsx and dsh-task-board board-mount.tsx are the canonical consumers. */
 export interface CenterPanelMountOptions {
-  /** Render the panel React tree into a root (initial mount, remount, locale refresh). */
+  /** Render the panel tree (first open, remount while open, locale refresh). */
   render: (root: Root) => void
   /** dataset key of the injected container's view attribute, e.g. `dshSshView` for `data-dsh-ssh-view`. */
   viewDatasetKey: string
@@ -79,31 +80,38 @@ export function mountCenterPanel(options: CenterPanelMountOptions): () => void {
   } catch { /* locale service absent: the panel follows its next natural re-render */ }
 
   const ensure = (): void => {
-    if (container !== undefined) {
-      if (container.isConnected) return
+    if (container !== undefined && !container.isConnected) {
       // The conversation pane was replaced; drop the stale tree and remount.
       root?.unmount()
       root = undefined
       container.remove()
       container = undefined
     }
-    const column = conversationColumn()
-    if (column === undefined) return
-    container = document.createElement('div')
-    container.dataset[options.viewDatasetKey] = ''
-    container.dataset.dshPlugin = options.pluginName
-    container.className = options.viewClassName
-    column.appendChild(container)
+    if (container === undefined) {
+      const column = conversationColumn()
+      if (column === undefined) return
+      container = document.createElement('div')
+      container.dataset[options.viewDatasetKey] = ''
+      container.dataset.dshPlugin = options.pluginName
+      container.className = options.viewClassName
+      column.appendChild(container)
+    }
+    // Keep a visited tree mounted so drafts and terminal sessions survive
+    // close/reopen; an unused panel needs neither a React root nor effects.
+    if (root !== undefined || !options.isOpen()) return
     root = createRoot(container)
     options.render(root)
   }
 
   // The frame mounts after boot settlement; watch for the column's arrival.
-  const waitObserver = new MutationObserver(() => { ensure() })
-  waitObserver.observe(document.body, { childList: true, subtree: true })
+  // The observation is the page-wide hub (shared/client/body-mutations.ts):
+  // every family panel used to hold its own document.body subtree observer, so
+  // the per-mutation cost grew with the number of installed plugins.
+  const unsubscribeBody = subscribeBodyInvalidations(() => { ensure() })
 
   const applyActive = (): void => {
     if (options.isOpen()) {
+      ensure()
       // Single-occupant center column: opening this panel must evict the
       // sibling panel, both its html attribute and its controller state,
       // otherwise the two panels' visibility rules fight and the second
@@ -135,7 +143,7 @@ export function mountCenterPanel(options: CenterPanelMountOptions): () => void {
   return () => {
     document.removeEventListener('click', onClickSidebarRow, true)
     document.removeEventListener(ACTIVATE_EVENT, onOtherActivate)
-    waitObserver.disconnect()
+    unsubscribeBody()
     unsubscribe()
     unsubscribeLocale?.()
     document.documentElement.removeAttribute(options.activeAttribute)

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

@@ -14,6 +14,7 @@
  * 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.
  */
+import { subscribeBodyInvalidations } from './body-mutations.ts'
 
 /** Per-package configuration for one sidebar entry row. */
 export interface SidebarEntryOptions {
@@ -188,13 +189,15 @@ export function mountSidebarEntry(options: SidebarEntryOptions): () => void {
 
   // 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
+  // only this body observation can notice the new pane mounting. It stays
+  // subscribed 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 })
+  // unrelated app mutations (e.g. chat streaming) cost one contains check per
+  // frame instead of churning the full re-query. The body observation itself is
+  // the page-wide hub (shared/client/body-mutations.ts): every family plugin
+  // used to hold its own body subtree observer, so the per-mutation cost grew
+  // with the number of installed plugins; the hub keeps exactly one.
+  const unsubscribeBody = subscribeBodyInvalidations(() => { tryPlace() })
 
   // Self-heal: if a React re-render displaces the row, re-insert it in the
   // same frame (microtask before paint -> no visible flicker).
@@ -225,7 +228,7 @@ export function mountSidebarEntry(options: SidebarEntryOptions): () => void {
   tryPlace()
 
   return () => {
-    waitObserver.disconnect()
+    unsubscribeBody()
     rootObserver.disconnect()
     unsubscribeRefresh?.()
     unsubscribeActive?.()

package/src/core/controller.ts

@@ -327,9 +327,8 @@ export class BoardController {
   }
 
   /**
-   * Archive a settled task (done/failed). Running or on-board-unsettled
-   * tasks are refused so the runner keeps exclusive ownership of their
-   * lifecycle.
+   * Archive a task from any status but `running`, whose lifecycle the runner
+   * keeps exclusive ownership of until it settles.
    * @returns true when applied.
    */
   archiveTask(id: string): boolean {

package/src/core/schedule.ts

@@ -179,7 +179,10 @@ function parseField(field: string, min: number, max: number, out: Set<number>):
       high = Number(b)
     } else if (isDigits(range)) {
       low = Number(range)
-      high = Number(range)
+      // Standard cron: a bare value carrying a step runs from that value to the
+      // field maximum (minutes 5/15 are 5,20,35,50), while a bare value alone is
+      // exactly itself (#1493).
+      high = stepRaw === undefined ? low : max
     } else {
       return false
     }

package/src/core/tasks.ts

@@ -172,8 +172,13 @@ export interface TaskRecord {
   archivedAt?: number
 }
 
-/** Statuses a settled task may be archived from. */
-export const ARCHIVABLE_STATUSES: readonly TaskStatus[] = ['done', 'failed']
+/**
+ * Statuses a task may be archived from: every status but `running`, whose
+ * execution the runner still owns until it settles. A settled-only gate made
+ * the duplicate-and-archive flow a silent no-op for scheduled tasks, which
+ * return to `todo` after every successful run (issue #1447).
+ */
+export const ARCHIVABLE_STATUSES: readonly TaskStatus[] = ['backlog', 'todo', 'done', 'failed']
 
 
 /** Permission presets a task may pin on its execution session (the `/permission <id>` ids). */

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

@@ -1,6 +1,6 @@
 /**
- * Archive/restore task use case: move a settled (done/failed) task off the
- * main board and back. The task keeps its status, execution history, and
+ * Archive/restore task use case: move a task off the main board and back,
+ * whatever its status but `running`. 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.
  */
@@ -16,10 +16,10 @@ 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). Archiving disarms a schedule; already-archived tasks
- * are a no-op.
+ * Archive one task: only a `running` task stays on the board (its runner
+ * still owns its lifecycle until the execution settles); every other status
+ * can be archived. Archiving disarms a schedule; already-archived tasks are
+ * a no-op.
  */
 export function applyArchiveTask(
   tasks: readonly TaskRecord[],