@linxin666/dsh-client-ui-task-board 0.4.1 → 0.4.3

package/lib/types/mount-once.d.ts

@@ -4,19 +4,50 @@
  * the loader accepts a standalone install of the same package side by side;
  * without this guard the second instance would still re-register the same
  * webserver routes, tools, settings namespaces, and system-prompt sections
- * and fail the boot. mountOnce makes the second host apply a no-op for the
- * lifetime of the first instance (the browser half is already deduped by
- * package name in the client module host).
+ * and fail the boot. mountOnce makes a mount of an already-mounted package a
+ * no-op for as long as the first instance lives (the browser half is already
+ * deduped by package name in the client module host).
+ *
+ * A no-op is only safe while the holder is ALIVE. The holder can be disposed
+ * long after the refused mount ran its course: the Host reloads a profile by
+ * creating the new loader entries before the old ones are torn down (a
+ * plugin-manager enable/disable/install write, a settings-driven row reload,
+ * HMR), so the new aggregate shell entry mounts its family plugin while the
+ * previous entry still owns the name. Dropping that refused mount lost the
+ * plugin for good - the previous entry then disposed its own mount, releasing
+ * the name with nobody left to take it, and the family row stayed listed as
+ * active while its host routes 404ed (the task-board panel showed
+ * "board.hostError.notMounted", no degraded record appeared, and only a Host
+ * restart recovered it).
+ *
+ * The refused mount is therefore QUEUED, not dropped, and replayed the moment
+ * the holder releases the name - if the waiting fiber is still alive then. The
+ * single-instance guarantee is unchanged: exactly one mount is live per
+ * package name, and the replay re-enters the guard so a later mount still
+ * dedupes against it.
  *
  * The registry rides a global symbol so two module instances of the same
- * package (npm copy vs repository link) still share one verdict. cordis
- * `ctx.effect` runs its callback immediately and treats the callback's
+ * package (npm copy vs repository link) still share one verdict. That symbol
+ * is a CROSS-REPOSITORY contract, not this file's private state: the four
+ * satellite packages (dsh-skins / dsh-pet / dsh-presets /
+ * dsh-community-plugins) are separate repositories carrying their own copy of
+ * this guard, rebuilt on their own schedule, so the value under `MOUNTED`
+ * must keep the shape every published copy reads (a `Set` of package names
+ * with `has`/`add`/`delete`). The wait queues this guard added therefore live
+ * under their own additive key, and the registry reads back a `Set` even when
+ * some other build left a different value there. Changing `MOUNTED`'s shape
+ * in place broke that contract once: a satellite's legacy copy created a
+ * `Set`, the family's new copy read it as a `Map`, and every family row
+ * mounted after it failed with "claims.get is not a function".
+ *
+ * cordis `ctx.effect` runs its callback immediately and treats the callback's
  * return value as the fiber disposer, so the unmarker is returned, not run.
  */
 /**
  * Wrap a cordis plugin apply so the package runs at most once per process.
- * The first mount registers normally and unmarks when its fiber disposes;
- * any later mount of the same package name is a no-op.
+ * The first mount registers normally and releases the name when its fiber
+ * disposes; a mount refused while that name is held waits for the release and
+ * then runs, unless its own fiber disposes first.
  * @param packageName - npm package identity shared by every install source.
  * @param fn - the original plugin apply.
  * @returns an apply of the same shape.

package/lib/types/protocol.d.ts

@@ -29,6 +29,16 @@ export interface TaskBoardSnapshot {
     power: TaskBoardPowerSnapshot;
     /** Session-default permission the confirmation gate compares against. */
     sessionDefaultPermission?: TaskPermission;
+    /**
+     * Deployment subtask depth limit (1..3). The browser mirrors it to enable or
+     * disable the subtask controls; the Host ledger is the authority.
+     */
+    maxSubtaskDepth?: number;
+    /**
+     * Whether this deployment serves the Agent Teams service, so a task may opt
+     * into team execution (Team Lead session plus one teammate per subtask).
+     */
+    teamRunAvailable?: boolean;
 }
 /** SSE event frame: revision/scheduler/power only, never the task list. */
 export interface TaskBoardEventPayload {
@@ -96,6 +106,10 @@ export type TaskBoardAction = {
 } | {
     kind: 'confirm-permission';
     taskId: string;
+} | {
+    kind: 'set-parent';
+    taskId: string;
+    parentId: string | null;
 };
 export interface TaskBoardActionEnvelope {
     requestId: string;

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.4.1",
+  "version": "0.4.3",
   "icon": "icon.svg",
   "type": "module",
   "main": "lib/index.js",
@@ -24,7 +24,7 @@
   },
   "dsh": {
     "engines": {
-      "dsh": ">=0.1.7-rc.1"
+      "dsh": ">=0.1.7-rc.2"
     },
     "bundle": {
       "patch": "./cordis.patch.yml"
@@ -34,6 +34,7 @@
         "@deepseek-ai/dsh-client-connection",
         "@deepseek-ai/dsh-client-ui-settings",
         "@deepseek-ai/dsh-client-ui-renderer",
+        "@deepseek-ai/dsh-client-ui-layout",
         "@deepseek-ai/dsh-api-session-controller",
         "@deepseek-ai/dsh-api-workspace-controller",
         "@deepseek-ai/dsh-api-remotes",
@@ -43,7 +44,7 @@
     }
   },
   "peerDependencies": {
-    "@deepseek-ai/dsh": ">=0.1.7-rc.1",
+    "@deepseek-ai/dsh": ">=0.1.7-rc.2",
     "react": "^18.2.0"
   },
   "dependencies": {
@@ -51,24 +52,28 @@
   },
   "devDependencies": {
     "@deepseek-ai/cordis": "^4.0.4",
-    "@deepseek-ai/dsh-agent": "^0.1.7-rc.1",
-    "@deepseek-ai/dsh-agent-preset-registry": "^0.1.7-rc.1",
-    "@deepseek-ai/dsh-api-gateway": "^0.1.7-rc.1",
-    "@deepseek-ai/dsh-api-remotes": "^0.1.7-rc.1",
-    "@deepseek-ai/dsh-api-session-controller": "^0.1.7-rc.1",
-    "@deepseek-ai/dsh-api-workspace-controller": "^0.1.7-rc.1",
-    "@deepseek-ai/dsh-client-connection": "^0.1.7-rc.1",
-    "@deepseek-ai/dsh-client-locale": "^0.1.7-rc.1",
-    "@deepseek-ai/dsh-client-store": "^0.1.7-rc.1",
-    "@deepseek-ai/dsh-client-ui-renderer": "^0.1.7-rc.1",
-    "@deepseek-ai/dsh-client-ui-settings": "^0.1.7-rc.1",
-    "@deepseek-ai/dsh-client-ui-slots": "^0.1.7-rc.1",
-    "@deepseek-ai/dsh-client-ui-workspace": "^0.1.7-rc.1",
-    "@deepseek-ai/dsh-commands": "^0.1.7-rc.1",
-    "@deepseek-ai/dsh-host-webserver": "^0.1.7-rc.1",
-    "@deepseek-ai/dsh-settings": "^0.1.7-rc.1",
-    "@deepseek-ai/dsh-system-prompt": "^0.1.7-rc.1",
-    "@deepseek-ai/dsh-workspace": "^0.1.7-rc.1",
+    "@deepseek-ai/dsh-agent": "^0.1.7-rc.2",
+    "@deepseek-ai/dsh-agent-preset-registry": "^0.1.7-rc.2",
+    "@deepseek-ai/dsh-api-gateway": "^0.1.7-rc.2",
+    "@deepseek-ai/dsh-api-remotes": "^0.1.7-rc.2",
+    "@deepseek-ai/dsh-api-session-controller": "^0.1.7-rc.2",
+    "@deepseek-ai/dsh-api-workspace-controller": "^0.1.7-rc.2",
+    "@deepseek-ai/dsh-client-connection": "^0.1.7-rc.2",
+    "@deepseek-ai/dsh-client-locale": "^0.1.7-rc.2",
+    "@deepseek-ai/dsh-client-store": "^0.1.7-rc.2",
+    "@deepseek-ai/dsh-client-ui-layout": "^0.1.7-rc.2",
+    "@deepseek-ai/dsh-client-ui-renderer": "^0.1.7-rc.2",
+    "@deepseek-ai/dsh-client-ui-settings": "^0.1.7-rc.2",
+    "@deepseek-ai/dsh-client-ui-sidebar": "^0.1.7-rc.2",
+    "@deepseek-ai/dsh-client-ui-slots": "^0.1.7-rc.2",
+    "@deepseek-ai/dsh-client-ui-workspace": "^0.1.7-rc.2",
+    "@deepseek-ai/dsh-commands": "^0.1.7-rc.2",
+    "@deepseek-ai/dsh-host-webserver": "^0.1.7-rc.2",
+    "@deepseek-ai/dsh-llm": "^0.1.7-rc.2",
+    "@deepseek-ai/dsh-settings": "^0.1.7-rc.2",
+    "@deepseek-ai/dsh-system-prompt": "^0.1.7-rc.2",
+    "@deepseek-ai/dsh-tools": "^0.1.7-rc.2",
+    "@deepseek-ai/dsh-workspace": "^0.1.7-rc.2",
     "@types/node": "^22.20.0",
     "@types/react": "~18.3.1",
     "@types/react-dom": "^18.3.5",

package/src/client/TaskBoardSettingsCard.tsx

@@ -9,8 +9,33 @@ import type { SnapshotStore } from '@deepseek-ai/dsh-client-store'
 import type { ConfigForm } from '@deepseek-ai/dsh-client-ui-settings/client'
 import { useEffect, useState } from 'react'
 import type { TaskBoardPowerSnapshot } from '../protocol.ts'
-import { PluginSettingsCard, BooleanField } from './PluginSettingsCard.tsx'
-import { CardForm, booleanField, type CardActions, type CardShell, type FieldState as CardFieldState } from './settings-form.ts'
+import { PluginSettingsCard, BooleanField, ChoiceField } from './PluginSettingsCard.tsx'
+import { SUBTASK_DEPTH_MAX, SUBTASK_DEPTH_MIN } from '../core/subtask.ts'
+import { CardForm, booleanField, type CardActions, type CardShell, type FieldSpec, type FieldState as CardFieldState } from './settings-form.ts'
+
+/** The depth choices the card offers, derived from the supported range. */
+const SUBTASK_DEPTH_CHOICES: readonly string[] = Array.from(
+  { length: SUBTASK_DEPTH_MAX - SUBTASK_DEPTH_MIN + 1 },
+  (_, index) => String(SUBTASK_DEPTH_MIN + index),
+)
+
+/**
+ * The depth field: a choice among the supported levels whose draft text is a
+ * number, because the Host schema (`maxSubtaskDepth`) is numeric. A draft
+ * outside the range blocks the save instead of staging a value the Host
+ * refuses.
+ */
+function subtaskDepthField(): FieldSpec {
+  return {
+    field: 'maxSubtaskDepth',
+    format: value => typeof value === 'number' && Number.isInteger(value) ? String(value) : '',
+    parse: (text) => {
+      const trimmed = text.trim()
+      if (trimmed === '') return { kind: 'clear' }
+      return SUBTASK_DEPTH_CHOICES.includes(trimmed) ? { kind: 'set', value: Number(trimmed) } : undefined
+    },
+  }
+}
 
 /** The task-board fields this card edits (the namespace's full schema). */
 export interface TaskBoardSettings {
@@ -20,6 +45,8 @@ export interface TaskBoardSettings {
   announceToAgent?: boolean
   /** Prevent host idle sleep while sessions run or schedules are armed. */
   preventIdleSleep?: boolean
+  /** Subtask depth limit (1..3); 1 means a single level of subtasks. */
+  maxSubtaskDepth?: number
 }
 
 /** What the task-board card renders. */
@@ -30,6 +57,8 @@ export interface TaskBoardSettingsCardState extends CardShell {
   announceToAgent: CardFieldState
   /** Idle-system-sleep protection flag. */
   preventIdleSleep: CardFieldState
+  /** Subtask depth limit field. */
+  maxSubtaskDepth: CardFieldState
 }
 
 /** The registration-side face the card's slot entry injects. */
@@ -51,6 +80,7 @@ export class TaskBoardSettingsCardController {
       booleanField('enabled'),
       booleanField('announceToAgent'),
       booleanField('preventIdleSleep'),
+      subtaskDepthField(),
     ])
     this.store = this.form.bind(() => this.projection())
   }
@@ -61,6 +91,7 @@ export class TaskBoardSettingsCardController {
       enabled: this.form.field('enabled'),
       announceToAgent: this.form.field('announceToAgent'),
       preventIdleSleep: this.form.field('preventIdleSleep'),
+      maxSubtaskDepth: this.form.field('maxSubtaskDepth'),
     }
   }
 
@@ -102,7 +133,7 @@ export function TaskBoardSettingsCard(props: TaskBoardSettingsCardProps) {
     // one frame on subscribe; polling the full /state snapshot every 5 s
     // re-cloned and re-serialized the whole ledger server-side for one field.
     let live = true
-    const events = new EventSource('/api/task-board/events')
+    const events = new EventSource('api/task-board/events')
     events.onmessage = (message: MessageEvent<string>): void => {
       try {
         const frame = JSON.parse(message.data) as { power?: TaskBoardPowerSnapshot }
@@ -167,6 +198,20 @@ export function TaskBoardSettingsCard(props: TaskBoardSettingsCardProps) {
         onEdit={(text) => { props.edit('preventIdleSleep', text) }}
         onReset={() => { props.resetField('preventIdleSleep') }}
       />
+      <ChoiceField
+        id="settings-task-board-subtask-depth"
+        label={t('settings.maxSubtaskDepth')}
+        hint={t('settings.maxSubtaskDepthHint')}
+        inheritLabel={t('settings.inherit')}
+        choices={SUBTASK_DEPTH_CHOICES.map(value => ({
+          value,
+          label: t('settings.maxSubtaskDepthOption', { depth: value }),
+        }))}
+        {...fieldProps}
+        {...state.maxSubtaskDepth}
+        onEdit={(text) => { props.edit('maxSubtaskDepth', text) }}
+        onReset={() => { props.resetField('maxSubtaskDepth') }}
+      />
       <p>
         {t('settings.powerStatus', {
           platform: power?.platform ?? t('settings.powerUnknown'),

package/src/client/board/LinkSubtaskModal.tsx

@@ -0,0 +1,82 @@
+/**
+ * Link-subtask modal: attach an existing on-board root task under the open
+ * task. The candidate list mirrors the Host lineage gate (checkParentLink), so
+ * a link the Host would refuse is not offered in the first place; the Host
+ * still re-checks the action at submit time.
+ */
+import { useState } from 'react'
+import type { BoardController } from '../../core/controller.ts'
+import { DEFAULT_SUBTASK_DEPTH, checkParentLink } from '../../core/subtask.ts'
+import type { TaskRecord } from '../../core/tasks.ts'
+import { t } from '../locales.ts'
+import css from '../board.module.css'
+import { STATUS_KEY } from './status-key.ts'
+
+/** Link-subtask overlay props. */
+export interface LinkSubtaskModalProps {
+  controller: BoardController
+  /** The task the picked card becomes a subtask of. */
+  parent: TaskRecord
+  onClose: () => void
+}
+
+/** Link-subtask overlay. */
+export function LinkSubtaskModal({ controller, parent, onClose }: LinkSubtaskModalProps) {
+  const [pending, setPending] = useState(false)
+  const [error, setError] = useState<string | undefined>(undefined)
+  const snapshot = controller.getSnapshot()
+  const limit = snapshot.host?.maxSubtaskDepth ?? DEFAULT_SUBTASK_DEPTH
+  // Only root, on-board tasks can move under another parent; the lineage gate
+  // decides the rest (depth, cycle, archived parent).
+  const candidates = snapshot.tasks.filter(task =>
+    task.archivedAt === undefined
+    // A running task may already be a participant of another run group; the
+    // Host refuses the move, so it is not offered here.
+    && task.status !== 'running'
+    && task.parentId === undefined
+    && task.id !== parent.id
+    && checkParentLink(snapshot.tasks, task.id, parent.id, limit).ok,
+  )
+  const link = async (taskId: string): Promise<void> => {
+    setPending(true)
+    setError(undefined)
+    if (await controller.setParent(taskId, parent.id)) {
+      onClose()
+      return
+    }
+    setPending(false)
+    setError(controller.getSnapshot().transportError ?? t('new.required'))
+  }
+  return (
+    <div className={css.modalBackdrop} onMouseDown={event => { if (event.target === event.currentTarget) onClose() }}>
+      <div className={css.modal} role="dialog" aria-label={t('link.subtask.title')}>
+        <h2 className={css.modalTitle}>{t('link.subtask.title')}</h2>
+        <p className={css.fieldHint}>{t('link.subtask.hint')}</p>
+        {candidates.length === 0
+          ? <p className={css.detailText}>{t('link.subtask.empty')}</p>
+          : (
+            <ul className={css.pickList}>
+              {candidates.map(task => (
+                <li key={task.id} className={css.pickRow}>
+                  <span className={css.pickTitle}>{task.title}</span>
+                  <span className={css.statusBadge} data-status={task.status}>{t(STATUS_KEY[task.status])}</span>
+                  <button
+                    type="button"
+                    className={css.primaryButton}
+                    disabled={pending}
+                    onClick={() => { void link(task.id) }}
+                  >
+                    {t('link.subtask.confirm')}
+                  </button>
+                </li>
+              ))}
+            </ul>
+          )}
+        {error !== undefined && <p className={css.formError}>{error}</p>}
+        <footer className={css.modalFooter}>
+          <button type="button" className={css.ghostButton} onClick={onClose}>{t('new.cancel')}</button>
+        </footer>
+      </div>
+    </div>
+  )
+}

package/src/client/board/NewTaskModal.tsx

@@ -6,6 +6,7 @@ import { useEffect, useRef, useState } from 'react'
 import type { BoardController } from '../../core/controller.ts'
 import { isValidCron, nextRunAtMs } from '../../core/schedule.ts'
 import { parseFreezeRequest } from '../../core/freeze-snapshot.ts'
+import { effectiveTaskPermission } from '../../core/subtask.ts'
 import { collectKnownTags, TASK_PERMISSIONS, type TaskPermission, type TaskRecord, type TaskTag } from '../../core/tasks.ts'
 import { t, type TaskBoardKey } from '../locales.ts'
 import { SCHEDULE_PRESETS } from '../schedule-presets.ts'
@@ -25,18 +26,30 @@ export interface NewTaskModalProps {
   defaultWorkspaceId?: string
   /** Optional callback after successful duplication (e.g. to archive source). */
   onDuplicateSuccess?: (sourceTaskId: string) => Promise<void>
+  /**
+   * Task the new card becomes a subtask of ("add subtask" from its detail
+   * view). The execution targets start from the parent's and the create action
+   * carries the parent link; unset targets inherit again at run time.
+   */
+  parentTask?: TaskRecord
 }
 
 /** New-task form overlay. */
-export function NewTaskModal({ controller, onClose, initialTask, defaultWorkspaceId, onDuplicateSuccess }: NewTaskModalProps) {
+export function NewTaskModal({ controller, onClose, initialTask, defaultWorkspaceId, onDuplicateSuccess, parentTask }: NewTaskModalProps) {
   const isDuplicate = initialTask !== undefined
   const [title, setTitle] = useState(initialTask?.title ?? '')
   const [description, setDescription] = useState(initialTask?.description ?? '')
   const [prompt, setPrompt] = useState(initialTask?.prompt ?? '')
-  const [workspaceId, setWorkspaceId] = useState(initialTask?.workspaceId ?? defaultWorkspaceId ?? '')
-  const [mode, setMode] = useState(initialTask?.mode ?? '')
+  // A subtask starts from its parent's execution contract (issue: subtask
+  // inheritance); each picker below still overrides it for this card. The
+  // permission stays UNSET by default: leaving it empty is what makes the Host
+  // inherit the parent's binding together with its human confirmation, while
+  // picking a value pins this card's own binding and re-arms the gate.
+  const [workspaceId, setWorkspaceId] = useState(initialTask?.workspaceId ?? parentTask?.workspaceId ?? defaultWorkspaceId ?? '')
+  const [mode, setMode] = useState(initialTask?.mode ?? parentTask?.mode ?? '')
   const [permission, setPermission] = useState(initialTask?.permission ?? '')
-  const [model, setModel] = useState(initialTask?.model ?? '')
+  const [model, setModel] = useState(initialTask?.model ?? parentTask?.model ?? '')
+  const inheritedPermission = parentTask === undefined ? undefined : effectiveTaskPermission(parentTask)
   const [reuseSession, setReuseSession] = useState(initialTask?.reuseSession ?? false)
   const [scheduleEnabled, setScheduleEnabled] = useState(initialTask?.schedule?.enabled ?? false)
   const [scheduleCron, setScheduleCron] = useState(initialTask?.schedule?.cron ?? '')
@@ -62,6 +75,13 @@ export function NewTaskModal({ controller, onClose, initialTask, defaultWorkspac
   const [parseError, setParseError] = useState<string | undefined>(undefined)
   const parseAbort = useRef<AbortController | undefined>(undefined)
   const parseModels = options.models ?? []
+  // A pinned target may have disappeared from the runtime (workspace deleted,
+  // preset removed) — especially when the form starts from a subtask's parent.
+  // Keep it selectable as a stale row, so the field shows what the create
+  // action will actually send instead of silently displaying the default.
+  const workspaceKnown = workspaceId === '' || options.workspaces.some(item => item.workspaceId === workspaceId)
+  const modeKnown = mode === '' || options.presets.some(item => item.id === mode)
+  const modelKnown = model === '' || parseModels.some(item => item.id === model)
 
   // The workspace list and preset roster arrive from the runtime after mount;
   // follow them so the pickers never freeze on an empty snapshot.
@@ -147,6 +167,7 @@ export function NewTaskModal({ controller, onClose, initialTask, defaultWorkspac
       title,
       description,
       prompt,
+      ...(parentTask === undefined ? {} : { parentId: parentTask.id }),
       freeze,
       handover,
       workspaceId: workspaceId === '' ? undefined : workspaceId,
@@ -185,7 +206,9 @@ export function NewTaskModal({ controller, onClose, initialTask, defaultWorkspac
     ? nextRunAtMs(scheduleCron, Date.now())
     : undefined
 
-  const modalTitle = isDuplicate ? t('new.duplicateTitle') : t('board.new')
+  const modalTitle = parentTask !== undefined
+    ? t('new.subtaskTitle')
+    : isDuplicate ? t('new.duplicateTitle') : t('board.new')
 
   return (
     <ModalShell
@@ -246,6 +269,12 @@ export function NewTaskModal({ controller, onClose, initialTask, defaultWorkspac
         </section>
       )}
 
+      {parentTask !== undefined && (
+        <p className={css.detailText} data-dsh-part="subtask-inherit">
+          {t('detail.parent')}: {parentTask.title} · {t('new.subtaskInherit')}
+        </p>
+      )}
+
       <TaskContentFields
         title={title}
         description={description}
@@ -290,6 +319,7 @@ export function NewTaskModal({ controller, onClose, initialTask, defaultWorkspac
             onChange={event => { setWorkspaceId(event.target.value) }}
           >
             <option value="">{t('exec.workspace.recent')}</option>
+            {!workspaceKnown && <option value={workspaceId}>{workspaceId}{t('exec.mode.removed')}</option>}
             {options.workspaces.map(workspace => (
               <option key={workspace.workspaceId} value={workspace.workspaceId}>{workspace.title}</option>
             ))}
@@ -304,6 +334,7 @@ export function NewTaskModal({ controller, onClose, initialTask, defaultWorkspac
             onChange={event => { setMode(event.target.value) }}
           >
             <option value="">{t('exec.mode.default')}</option>
+            {!modeKnown && <option value={mode}>{mode}{t('exec.mode.removed')}</option>}
             {options.presets.map(preset => (
               <option key={preset.id} value={preset.id} disabled={preset.broken !== undefined}>
                 {preset.name ?? preset.id}
@@ -321,7 +352,9 @@ export function NewTaskModal({ controller, onClose, initialTask, defaultWorkspac
             value={permission}
             onChange={event => { setPermission(event.target.value) }}
           >
-            <option value="">{t('exec.permission.default')}</option>
+            <option value="">{inheritedPermission === undefined
+              ? t('exec.permission.default')
+              : t('exec.permission.inheritParent', { permission: t(`exec.permission.${inheritedPermission}` as TaskBoardKey) })}</option>
             {TASK_PERMISSIONS.map(id => (
               <option key={id} value={id}>{t(`exec.permission.${id}` as TaskBoardKey)}</option>
             ))}
@@ -336,6 +369,7 @@ export function NewTaskModal({ controller, onClose, initialTask, defaultWorkspac
             onChange={event => { setModel(event.target.value) }}
           >
             <option value="">{t('exec.model.default')}</option>
+            {!modelKnown && <option value={model}>{model}{t('exec.model.unknown')}</option>}
             {options.models?.map(item => (
               <option key={item.id} value={item.id}>{item.name ?? item.id}</option>
             ))}

package/src/client/board/TaskBoard.tsx

@@ -43,9 +43,31 @@ export function matchesTagFilter(task: TaskRecord, selected: readonly string[]):
  * re-renders only when its own task changes — not when a sibling card status,
  * the filter, or the selection moves.
  */
-const MemoTaskCard = memo(function MemoTaskCard({ task, pending, timeZone, onOpen }: { task: TaskRecord; pending: boolean; timeZone?: string; onOpen: (id: string) => void }) {
+const MemoTaskCard = memo(function MemoTaskCard({ task, pending, timeZone, onOpen, subtaskCount, isSubtask, subtasksDone, subtasksRunning, subtasksFailed }: {
+  task: TaskRecord
+  pending: boolean
+  timeZone?: string
+  onOpen: (id: string) => void
+  subtaskCount: number
+  isSubtask: boolean
+  subtasksDone: number
+  subtasksRunning: number
+  subtasksFailed: number
+}) {
   const onClick = useCallback(() => { onOpen(task.id) }, [task.id, onOpen])
-  return <TaskCard task={task} pending={pending} timeZone={timeZone} onClick={onClick} />
+  return (
+    <TaskCard
+      task={task}
+      pending={pending}
+      timeZone={timeZone}
+      onClick={onClick}
+      subtaskCount={subtaskCount}
+      isSubtask={isSubtask}
+      subtasksDone={subtasksDone}
+      subtasksRunning={subtasksRunning}
+      subtasksFailed={subtasksFailed}
+    />
+  )
 })
 
 /** Board component; subscribes to the controller snapshot. */
@@ -57,6 +79,11 @@ export function TaskBoard({ controller }: { controller: BoardController }) {
   )
   const [filter, setFilter] = useState('')
   const [tagFilter, setTagFilter] = useState<string[]>([])
+  // Subtask cards are real board cards, but a tree with dozens of children
+  // turns a column into a wall: the board starts from the parent cards only and
+  // the header switch reveals the flat view. A text or label filter re-enables
+  // them automatically, so searching a subtask title still finds it.
+  const [hideSubtasks, setHideSubtasks] = useState(true)
   const [showNew, setShowNew] = useState(false)
   // Project partition (#1536): '' means "all projects". A selected project
   // narrows the board and becomes the new-task form's default workspace.
@@ -70,10 +97,29 @@ export function TaskBoard({ controller }: { controller: BoardController }) {
   // Every label in use across the ledger (board and archive alike), so the
   // filter never loses an option just because its task was archived.
   const knownTags = collectKnownTags(snapshot.tasks)
-  // Archived tasks leave the columns; the archive view shows them instead.
-  const visible = snapshot.tasks.filter(task =>
-    (archiveView ? task.archivedAt !== undefined : task.archivedAt === undefined)
-    && (projectId === '' || task.workspaceId === projectId)
+  // The family of cards this view owns: the board columns, or the archive.
+  const onBoard = snapshot.tasks.filter(task =>
+    archiveView ? task.archivedAt !== undefined : task.archivedAt === undefined,
+  )
+  // Direct subtask count and state roll-up per task, for the card badge: a
+  // hidden tree still has to report how many children run, fail, or finish.
+  const subtaskCounts = new Map<string, number>()
+  const subtaskRollup = new Map<string, { done: number; running: number; failed: number }>()
+  for (const task of onBoard) {
+    if (task.parentId === undefined) continue
+    subtaskCounts.set(task.parentId, (subtaskCounts.get(task.parentId) ?? 0) + 1)
+    const rollup = subtaskRollup.get(task.parentId) ?? { done: 0, running: 0, failed: 0 }
+    if (task.status === 'done') rollup.done += 1
+    else if (task.status === 'running') rollup.running += 1
+    else if (task.status === 'failed') rollup.failed += 1
+    subtaskRollup.set(task.parentId, rollup)
+  }
+  const hasSubtasks = subtaskCounts.size > 0
+  const searchActive = filter.trim() !== '' || tagFilter.length > 0
+  const hidingSubtasks = hideSubtasks && !searchActive
+  const visible = onBoard.filter(task =>
+    (projectId === '' || task.workspaceId === projectId)
+    && (!hidingSubtasks || task.parentId === undefined)
     && matchesFilter(task, filter)
     && matchesTagFilter(task, tagFilter),
   )
@@ -159,6 +205,18 @@ export function TaskBoard({ controller }: { controller: BoardController }) {
           onChange={event => { setFilter(event.target.value) }}
           aria-label={t('board.search')}
         />
+        {hasSubtasks && (
+          <button
+            type="button"
+            className={hidingSubtasks ? css.primaryButton : css.ghostButton}
+            data-dsh-part="subtask-filter"
+            aria-pressed={hidingSubtasks}
+            title={t('board.subtaskFilterHint')}
+            onClick={() => { setHideSubtasks(value => !value) }}
+          >
+            {hidingSubtasks ? t('board.showSubtasks') : t('board.hideSubtasks')}
+          </button>
+        )}
         <button
           type="button"
           className={archiveView ? css.primaryButton : css.ghostButton}
@@ -257,7 +315,18 @@ export function TaskBoard({ controller }: { controller: BoardController }) {
             </header>
             <div className={css.cards}>
               {visible.map(task => (
-                <MemoTaskCard key={task.id} task={task} pending={snapshot.pendingTaskIds.includes(task.id)} timeZone={snapshot.host?.scheduler.timeZone} onOpen={openTask} />
+                <MemoTaskCard
+                  key={task.id}
+                  task={task}
+                  pending={snapshot.pendingTaskIds.includes(task.id)}
+                  timeZone={snapshot.host?.scheduler.timeZone}
+                  onOpen={openTask}
+                  subtaskCount={subtaskCounts.get(task.id) ?? 0}
+                  isSubtask={task.parentId !== undefined}
+                  subtasksDone={subtaskRollup.get(task.id)?.done ?? 0}
+                  subtasksRunning={subtaskRollup.get(task.id)?.running ?? 0}
+                  subtasksFailed={subtaskRollup.get(task.id)?.failed ?? 0}
+                />
               ))}
               {visible.length === 0 && (
                 <div className={css.columnEmpty}>{tagFilter.length > 0 ? t('board.tagEmpty') : t('archive.empty')}</div>
@@ -295,7 +364,18 @@ export function TaskBoard({ controller }: { controller: BoardController }) {
                 </header>
                 <div className={css.cards}>
                   {tasks.map(task => (
-                    <MemoTaskCard key={task.id} task={task} pending={snapshot.pendingTaskIds.includes(task.id)} timeZone={snapshot.host?.scheduler.timeZone} onOpen={openTask} />
+                    <MemoTaskCard
+                      key={task.id}
+                      task={task}
+                      pending={snapshot.pendingTaskIds.includes(task.id)}
+                      timeZone={snapshot.host?.scheduler.timeZone}
+                      onOpen={openTask}
+                      subtaskCount={subtaskCounts.get(task.id) ?? 0}
+                      isSubtask={task.parentId !== undefined}
+                      subtasksDone={subtaskRollup.get(task.id)?.done ?? 0}
+                      subtasksRunning={subtaskRollup.get(task.id)?.running ?? 0}
+                      subtasksFailed={subtaskRollup.get(task.id)?.failed ?? 0}
+                    />
                   ))}
                   {tasks.length === 0 && (
                     <div className={css.columnEmpty}>{tagFilter.length > 0 ? t('board.tagEmpty') : t('board.empty')}</div>