@linxin666/dsh-client-ui-task-board 0.4.6 → 0.4.7

package/src/core/controller.ts

@@ -127,6 +127,17 @@ export interface ExecutionModelOption {
   name?: string
   label?: string
   provider?: string
+  /**
+   * Reasoning metadata the adapter declares for this exact route. An effort
+   * picker is offered only while `supported`, and its choices are `efforts` —
+   * the ids the target model really accepts, so the UI never offers (or keeps)
+   * a level the model would reject. Absent means the deployment published no
+   * capability for this model; the card value is then left untouched.
+   */
+  reasoning?: {
+    supported: boolean
+    efforts?: readonly string[]
+  }
 }
 
 /** The execution-target option sets the UI feeds into the controller. */
@@ -141,7 +152,7 @@ export interface ExecutionOptionsSnapshot {
  * (revision/scheduler/power); a full snapshot also carries the deployment
  * constants the UI reads (session default permission, subtask depth).
  */
-export type HostMirror = Pick<TaskBoardSnapshot, 'revision' | 'scheduler' | 'power' | 'sessionDefaultPermission' | 'maxSubtaskDepth' | 'teamRunAvailable' | 'goalRunEnabled' | 'extensions'>
+export type HostMirror = Pick<TaskBoardSnapshot, 'revision' | 'scheduler' | 'power' | 'sessionDefaultPermission' | 'maxSubtaskDepth' | 'teamRunAvailable' | 'goalRunEnabled' | 'cardDefaults' | 'extensions'>
 
 /** Immutable controller snapshot for UI subscriptions. */
 export interface ControllerSnapshot {
@@ -318,6 +329,22 @@ export class BoardController {
     return await this.initializeRemote()
   }
 
+  /**
+   * Re-read the authoritative Host snapshot.
+   *
+   * The board's volatile deployment configuration — the new-card defaults among
+   * it — is republished the moment the settings document is written, but the SSE
+   * frame that republish emits carries the value as of BEFORE the write (the
+   * loader hands the update to the fiber while the new document is not yet
+   * visible to it), so a mirror that followed frames alone would stay one edit
+   * behind and the create dialog would prefill from the previous defaults for
+   * the rest of the session. The surface that owns the write asks for the
+   * snapshot again instead of trusting the frame.
+   */
+  refreshHostState(): void {
+    void this.refreshRemote()
+  }
+
   // --- view state -------------------------------------------------------------
 
   /**
@@ -407,7 +434,7 @@ export class BoardController {
 
   createTask(input: NewTaskInput): TaskRecord | undefined {
     const id = this.uuid()
-    const { task, tasks } = applyCreateTask(this.tasks, input, this.now(), id, this.mirrorDepth())
+    const { task, tasks } = applyCreateTask(this.tasks, input, this.now(), id, this.mirrorDepth(), undefined, this.hostState?.cardDefaults)
     if (task === undefined) return undefined
     this.tasks = [...tasks]
     this.persistAndNotify()
@@ -421,7 +448,7 @@ export class BoardController {
     // The preview must obey the SAME lineage gate the Host will: a browser-side
     // default of one level would reject a legal subtask-of-subtask before the
     // request is ever sent.
-    const preview = applyCreateTask(this.tasks, input, this.now(), id, this.mirrorDepth()).task
+    const preview = applyCreateTask(this.tasks, input, this.now(), id, this.mirrorDepth(), undefined, this.hostState?.cardDefaults).task
     if (preview === undefined) return undefined
     return await this.commitRemote({ kind: 'create', id, input }, id)
       ? this.tasks.find(task => task.id === id)
@@ -804,18 +831,25 @@ export class BoardController {
   }
 
   /**
-   * Project a Host snapshot onto the browser's mirror. SSE frames and partial
-   * snapshots carry only the volatile subset (revision/scheduler/power), so the
-   * deployment constants the UI reads — the session-default permission the
-   * confirmation banner compares against and the subtask depth limit — are
-   * carried over from the last full snapshot instead of being dropped by a
-   * heartbeat frame.
+   * Project a Host snapshot onto the browser's mirror. Every snapshot the
+   * transport serves is a full document (bootstrap/state/action all answer
+   * `TaskBoardHostService.snapshot()`), so the deployment constants the UI reads
+   * — the session-default permission the confirmation banner compares against,
+   * the subtask depth limit, the platform switches and the extensions a provider
+   * published — are taken as published, carried over only where the snapshot
+   * itself omits the key.
    */
   private mirrorOf(snapshot: TaskBoardSnapshot): HostMirror {
     const sessionDefaultPermission = snapshot.sessionDefaultPermission ?? this.hostState?.sessionDefaultPermission
     const maxSubtaskDepth = snapshot.maxSubtaskDepth ?? this.hostState?.maxSubtaskDepth
     const teamRunAvailable = snapshot.teamRunAvailable ?? this.hostState?.teamRunAvailable
     const goalRunEnabled = snapshot.goalRunEnabled ?? this.hostState?.goalRunEnabled
+    // The new-card defaults are NOT carried over: the Host publishes a target
+    // nothing configures by omitting it (protocol.ts states that explicitly), so
+    // an absent key means "this deployment configures none". Carrying the last
+    // value over would keep a CLEARED default alive in the create dialog, which
+    // is the mirror image of the staleness this key is re-read for.
+    const cardDefaults = snapshot.cardDefaults
     const extensions = snapshot.extensions ?? this.hostState?.extensions
     return {
       revision: snapshot.revision,
@@ -825,6 +859,7 @@ export class BoardController {
       ...(maxSubtaskDepth === undefined ? {} : { maxSubtaskDepth }),
       ...(teamRunAvailable === undefined ? {} : { teamRunAvailable }),
       ...(goalRunEnabled === undefined ? {} : { goalRunEnabled }),
+      ...(cardDefaults === undefined ? {} : { cardDefaults }),
       ...(extensions === undefined ? {} : { extensions }),
     }
   }

package/src/core/launch-width.ts

@@ -0,0 +1,38 @@
+/**
+ * Run-launch admission width: the one bound on how many sessions this board
+ * starts at the same time.
+ *
+ * One board action opens a whole subtree, and a team run hands every member of
+ * it to the Lead at once, so without a bound the Host asks DSH for dozens of
+ * sessions in a single tick. The repository's own measured guidance caps heavy
+ * implementation subagents at three (docs/multi-agent-resources.md) and no
+ * runtime mechanism enforced it; this setting is that mechanism.
+ *
+ * The bounds and the default live here rather than in either half, exactly like
+ * the roster cadence: the settings card validates a draft against the same
+ * range the Host clamps a hand-edited configuration to, and a programmatic
+ * mount that names no width gets the default.
+ *
+ * @module dsh-task-board/core/launch-width
+ */
+
+/** Width used when neither the settings document nor the mount names one. */
+export const DEFAULT_RUN_LAUNCH_WIDTH = 3
+
+/** Narrowest accepted width: one launch at a time. */
+export const RUN_LAUNCH_WIDTH_MIN = 1
+
+/** Widest accepted width. */
+export const RUN_LAUNCH_WIDTH_MAX = 16
+
+/**
+ * Clamp a configured width into the supported range. A value the schema would
+ * refuse (non-finite, below the floor, above the ceiling) still leaves the
+ * board launching: an out-of-range setting never stalls a run.
+ * @param width - configured width, or undefined for the default.
+ * @returns the effective width.
+ */
+export function normalizeRunLaunchWidth(width: number | undefined): number {
+  if (width === undefined || !Number.isFinite(width)) return DEFAULT_RUN_LAUNCH_WIDTH
+  return Math.min(Math.max(Math.trunc(width), RUN_LAUNCH_WIDTH_MIN), RUN_LAUNCH_WIDTH_MAX)
+}

package/src/core/reasoning-effort.ts

@@ -0,0 +1,92 @@
+/**
+ * Which reasoning effort one execution may actually send.
+ *
+ * The rule lives here, in one pure place, so the launch path cannot drift from
+ * what the picker promises: an effort is sent ONLY for the exact model route
+ * whose adapter declares that id. An unsupported value is dropped rather than
+ * passed through — the Host validates the selection against the same
+ * capability (`resolveCallConfig` rejects an unsupported effort) and the whole
+ * model selection would fail with it. An absent effort stays absent: the SDK
+ * then materializes the model's own default, which is exactly what "inherit
+ * the model" means.
+ *
+ * A card that pins a bare model id also gets its provider resolved here: the
+ * session wire contract requires `provider` (ModelSelection), so the catalog is
+ * the only place that can complete the documented `provider/model` or model-id
+ * pin.
+ */
+import type { CatalogModel, ModelCatalogView } from './verification.ts'
+
+/** One execution route an effort resolves against: `provider/model`, or a bare model id. */
+export interface ReasoningRoute {
+  provider?: string
+  model: string
+}
+
+/** The catalog entry a route names, once the catalog can complete it. */
+export interface DeclaredReasoningRoute {
+  provider: string
+  model: string
+  /** The adapter's reasoning metadata; absent when it exposes none. */
+  reasoning?: CatalogModel['reasoning']
+}
+
+/** What one card's effort resolves to for one route. */
+export interface ReasoningEffortDecision {
+  /** The effort to send; absent means "send none". */
+  effort?: string
+  /** The card's own value when it will NOT be sent. */
+  dropped?: string
+}
+
+/** Trim one optional effort: blank text means "not set", like every other pinned target. */
+export function normalizeReasoningEffort(value: string | undefined): string | undefined {
+  const trimmed = value?.trim()
+  return trimmed === undefined || trimmed === '' ? undefined : trimmed
+}
+
+/**
+ * Complete one route through the host catalog: a qualified route must match its
+ * provider group, and a bare model id matches the first group carrying it —
+ * which is the provider the request then names.
+ * @param catalog - the host model catalog, when this deployment serves one.
+ * @param route - the route as the card pins it.
+ * @returns the completed route with its reasoning metadata, or undefined when
+ *   the catalog declares no such model.
+ */
+export function declaredRoute(
+  catalog: ModelCatalogView | undefined,
+  route: ReasoningRoute,
+): DeclaredReasoningRoute | undefined {
+  const groups = catalog?.groups ?? []
+  const matched = route.provider === undefined || route.provider === ''
+    ? groups.find(group => group.models.some(model => model.id === route.model))
+    : groups.find(group => group.id === route.provider)
+  const model = matched?.models.find(candidate => candidate.id === route.model)
+  if (matched === undefined || model === undefined) return undefined
+  return {
+    provider: matched.id,
+    model: model.id,
+    ...(model.reasoning === undefined ? {} : { reasoning: model.reasoning }),
+  }
+}
+
+/**
+ * Resolve the effort one execution sends.
+ * @param requested - the card's stored effort (absent or blank = inherit).
+ * @param catalog - the host model catalog, when this deployment serves one.
+ * @param route - the route the execution will actually run at.
+ * @returns the effort to send, or the dropped value that will not be sent.
+ */
+export function resolveReasoningEffort(
+  requested: string | undefined,
+  catalog: ModelCatalogView | undefined,
+  route: ReasoningRoute | undefined,
+): ReasoningEffortDecision {
+  const effort = normalizeReasoningEffort(requested)
+  if (effort === undefined) return {}
+  if (route === undefined) return { dropped: effort }
+  const declared = declaredRoute(catalog, route)
+  const supported = declared?.reasoning?.efforts.some(option => option.id === effort) === true
+  return supported ? { effort } : { dropped: effort }
+}

package/src/core/store.ts

@@ -68,6 +68,7 @@ function isTaskRecordShape(value: unknown): value is Omit<TaskRecord, 'status'>
   if (record.parentId !== undefined && typeof record.parentId !== 'string') return false
   if (record.workspaceId !== undefined && typeof record.workspaceId !== 'string') return false
   if (record.mode !== undefined && typeof record.mode !== 'string') return false
+  if (record.reasoningEffort !== undefined && typeof record.reasoningEffort !== 'string') return false
   if (record.permission !== undefined && typeof record.permission !== 'string') return false
   if (record.integrations !== undefined && (typeof record.integrations !== 'object' || record.integrations === null || Array.isArray(record.integrations))) return false
   if (record.hidden !== undefined && typeof record.hidden !== 'boolean') return false
@@ -265,6 +266,10 @@ export function parseLedger(raw: string | null): TaskRecord[] {
     // fall back to the session default instead of dropping the row.
     task.workspaceId = normalizeTargetId(row.workspaceId)
     task.mode = normalizeTargetId(row.mode)
+    // The effort is repaired like the other execution-target strings: blank text
+    // from a hand-edited document clears the pin instead of dropping the row,
+    // and the card then runs at its model's own default level.
+    task.reasoningEffort = normalizeTargetId(row.reasoningEffort)
     task.archivedAt = typeof row.archivedAt === 'number' && Number.isFinite(row.archivedAt) ? row.archivedAt : undefined
     task.permission = isTaskPermission(row.permission) ? row.permission as TaskPermission : undefined
     task.reuseSession = row.reuseSession === true ? true : undefined

package/src/core/subtask.ts

@@ -183,9 +183,12 @@ export function checkParentLink(
 
 /**
  * The tasks one run request opens executions for: the requested task first,
- * then its on-board descendants within the configured depth. Archived tasks
- * never run; a participant that already has an open execution is skipped by
- * the caller, which cannot start it twice.
+ * then its on-board descendants within the configured depth. This is the
+ * SHAPE of a cascade — every walk that must see the whole tree (settlement,
+ * archive/restore, the running lock) reads it. The run path filters it with
+ * {@link joinsCascadeRun}: archived tasks never run, a participant that already
+ * has an open execution is skipped by the caller, which cannot start it twice,
+ * and a finished descendant is left alone.
  */
 export function cascadeTargets(
   tasks: readonly TaskRecord[],
@@ -197,6 +200,27 @@ export function cascadeTargets(
   return [root, ...descendantTasks(tasks, rootId, maxSubtaskDepth)]
 }
 
+/**
+ * Whether a cascade member takes part in a new run.
+ *
+ * The task the user ran is always a member: the request names that card, and
+ * the operator asked for it to run whatever its column says. A descendant does
+ * not join once it sits in the `done` column — its work is finished, so running
+ * the parent again is a run of the parent, never a second execution of work
+ * that is already done. The rule keys on the column alone, so it covers both a
+ * subtask that ran and one an operator moved to done by hand, and it holds for
+ * every trigger: a manual run, a re-run, and a due occurrence of a schedule.
+ * A card whose own schedule is enabled settles back into `todo`, so a scheduled
+ * subtask stays a participant; to make a finished one run again, move it back
+ * to `todo` or run it on its own.
+ * @param task - the candidate member.
+ * @param rootId - the task the run request named.
+ * @returns false when this member is left alone by the run.
+ */
+export function joinsCascadeRun(task: TaskRecord, rootId: string): boolean {
+  return task.id === rootId || task.status !== 'done'
+}
+
 /** One still-open execution belonging to a cascade run group. */
 export interface OpenCascadeChild {
   taskId: string
@@ -263,11 +287,12 @@ export function effectiveTaskPermission(task: TaskRecord): TaskRecord['permissio
 /**
  * Resolve the execution targets a (sub)task actually runs with: its own value
  * wins, and an unset target inherits the nearest ancestor up to the root.
- * Workspace, agent preset and model inherit the ancestor's PIN only — a
- * handover bundle is a per-card continuation artefact and is never inherited.
- * The permission inherits the ancestor's EFFECTIVE binding, and its human
- * confirmation travels with it, so a subtask of an already-confirmed elevated
- * card is runnable while a subtask's own unconfirmed binding stays gated.
+ * Workspace, agent preset, model and reasoning effort inherit the ancestor's
+ * PIN only — a handover bundle is a per-card continuation artefact and is never
+ * inherited. The permission inherits the ancestor's EFFECTIVE binding, and its
+ * human confirmation travels with it, so a subtask of an already-confirmed
+ * elevated card is runnable while a subtask's own unconfirmed binding stays
+ * gated.
  */
 /**
  * The immutable teammate name for one team-mode member. Teammate names are
@@ -317,13 +342,22 @@ export function resolveExecutionTargets(
 ): TaskRecord {
   if (task.parentId === undefined) return task
   const chain = [task, ...ancestorChain(tasks, task).slice(0, maxSubtaskDepth)]
-  const first = (key: 'workspaceId' | 'mode' | 'model'): string | undefined => {
-    for (const candidate of chain) {
+  const first = (key: 'workspaceId' | 'mode' | 'model' | 'reasoningEffort', candidates: readonly TaskRecord[]): string | undefined => {
+    for (const candidate of candidates) {
       const value = candidate[key]
       if (value !== undefined) return value
     }
     return undefined
   }
+  // The model pin is the boundary of the effort: an effort is only ever taken
+  // from the card the model came from, or from the card that pinned it below
+  // that one. A card with a model of its own thus sends NO effort when it stores
+  // none — the model's own default — instead of quietly running at an ancestor
+  // level chosen for a different model, even when both models declare that
+  // level. A card with no model of its own still inherits the nearest model
+  // together with the nearest level pinned at or below it.
+  const boundary = chain.findIndex(candidate => candidate.model !== undefined)
+  const effortChain = boundary === -1 ? chain : chain.slice(0, boundary + 1)
   const own = effectiveTaskPermission(task)
   // An own binding (pin or handover) keeps its own confirmation stamp; only an
   // absent one borrows the ancestor's binding AND that ancestor's stamp.
@@ -332,9 +366,10 @@ export function resolveExecutionTargets(
     : undefined
   return {
     ...task,
-    workspaceId: first('workspaceId'),
-    mode: first('mode'),
-    model: first('model'),
+    workspaceId: first('workspaceId', chain),
+    mode: first('mode', chain),
+    model: first('model', chain),
+    reasoningEffort: first('reasoningEffort', effortChain),
     permission: own ?? (owner === undefined ? undefined : effectiveTaskPermission(owner)),
     permissionConfirmedAt: own === undefined ? owner?.permissionConfirmedAt : task.permissionConfirmedAt,
   }

package/src/core/tasks.ts

@@ -406,6 +406,15 @@ export interface TaskRecord {
    * absent falls back to the host default (agent-default-model).
    */
   model?: string
+  /**
+   * Reasoning effort pinned for that execution route (an adapter-owned id such
+   * as "high"). Absent (or blank) means INHERIT: the session runs at the
+   * model's own default level, exactly as a card written before the field
+   * existed does. The launch sends the value only when the target model's
+   * adapter declares that exact id, so switching a card to a model without
+   * that level never pushes an invalid selection (see core/reasoning-effort.ts).
+   */
+  reasoningEffort?: string
   /**
    * Whether later executions continue in the previous execution's session
    * (issue #1419) instead of minting a fresh conversation per run. Absent or
@@ -535,6 +544,16 @@ export interface NewTaskInput {
   permission?: TaskPermission
   /** Optional pinned model for the execution session; absent = host default. */
   model?: string
+  /** Optional reasoning effort for that model route; empty/absent = the model's own default. */
+  reasoningEffort?: string
+  /**
+   * Opt in to the deployment's new-card defaults: a target this input leaves
+   * out is filled from the configured default (agent preset, permission, model
+   * and the level bound to that model). Absent means the create stores exactly
+   * what it was given, which is what the extension provider's own create path
+   * and the legacy import rely on.
+   */
+  applyCardDefaults?: boolean
   /** Reuse the previous execution's session for later runs (issue #1419). */
   reuseSession?: boolean
   /** Run the subtree as an Agent Team (Team Lead session plus one teammate per direct subtask). */
@@ -699,6 +718,7 @@ export function createTask(input: NewTaskInput, now: number, id: string): TaskRe
     mode: normalizeTargetId(input.mode),
     permission: isTaskPermission(input.permission) ? input.permission : undefined,
     model: normalizeTargetId(input.model),
+    reasoningEffort: normalizeTargetId(input.reasoningEffort),
     reuseSession: input.reuseSession === true ? true : undefined,
     teamRun: input.teamRun === true ? true : undefined,
     // Default OFF: only an explicit true is stored, so a card that never

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

@@ -6,7 +6,8 @@
  */
 import { isValidCron, isValidTimeZone, nextRunAtMs, resolveHostTimeZone } from '../schedule.ts'
 import { DEFAULT_SUBTASK_DEPTH, normalizeSubtaskDepth, taskDepth } from '../subtask.ts'
-import { createTask, withSchedule, type NewTaskInput, type TaskRecord } from '../tasks.ts'
+import { resolveCardTargets, type CardDefaults } from '../card-defaults.ts'
+import { createTask, isTaskPermission, withSchedule, type NewTaskInput, type TaskRecord } from '../tasks.ts'
 
 /** Result of a create transition: the new task (when accepted) + the next ledger. */
 export interface CreateTaskResult {
@@ -23,16 +24,20 @@ export interface CreateTaskResult {
  * appended ledger, or the unchanged ledger when the title is blank or the
  * requested parent link is refused.
  *
- * A subtask inherits the execution targets its parent already pins (workspace,
- * agent preset, permission, model) unless the form supplied its own; the
- * parent human permission confirmation travels with an inherited permission,
- * so a subtask of an already-confirmed elevated card is runnable at once.
+ * The execution targets resolve through {@link resolveCardTargets}: what the
+ * caller sent wins, then the parent's own pins, then - only when the caller
+ * opted in with `applyCardDefaults` - the deployment's configured new-card
+ * defaults. Without the flag the resolution sees no defaults at all, which is
+ * exactly the inline parent inheritance this path has always applied. The
+ * workspace is not part of that resolution: a subtask still takes the parent's
+ * workspace, and the defaults never name one.
  * @param tasks - current ledger.
  * @param input - raw user input (title/description/prompt + optional schedule/parent).
  * @param now - clock instant (ms epoch).
  * @param id - minted task id.
  * @param maxSubtaskDepth - deployment subtask depth limit.
  * @param hostTimeZone - zone a rule that stores no zone of its own follows.
+ * @param cardDefaults - the deployment's new-card defaults, read live at creation.
  */
 export function applyCreateTask(
   tasks: readonly TaskRecord[],
@@ -41,6 +46,7 @@ export function applyCreateTask(
   id: string,
   maxSubtaskDepth: number = DEFAULT_SUBTASK_DEPTH,
   hostTimeZone: string = resolveHostTimeZone(),
+  cardDefaults?: CardDefaults,
 ): CreateTaskResult {
   if (input.title.trim() === '') return { task: undefined, tasks, error: 'title is required' }
   const limit = normalizeSubtaskDepth(maxSubtaskDepth)
@@ -53,18 +59,23 @@ export function applyCreateTask(
       return { task: undefined, tasks, error: `subtask depth limit (${limit}) exceeded` }
     }
   }
-  // A subtask copies the execution targets its parent pins so the card shows
-  // what it will run with — EXCEPT the permission. A copied permission would
-  // also have to copy the parent's human confirmation to stay runnable, and the
-  // child would keep both after being detached: one confirmed parent would mint
-  // unbounded confirmed elevated roots. The permission is resolved live from the
-  // attached ancestors at launch instead (see core/subtask.ts), so detaching
-  // removes the inheritance by construction.
-  const effective: NewTaskInput = parent === undefined ? input : {
+  // The execution targets resolve through the one shared rule: the caller's own
+  // choice, then the parent's own pins (never its permission, see
+  // core/card-defaults.ts), then the deployment's new-card defaults — and only
+  // when the caller asked for them, so a create that never opts in stores
+  // exactly what it sent, as it always has.
+  const seed = resolveCardTargets(
+    input.applyCardDefaults === true ? cardDefaults : undefined,
+    parent === undefined ? undefined : { kind: 'parent', task: parent },
+    { mode: input.mode, permission: input.permission, model: input.model, reasoningEffort: input.reasoningEffort },
+  )
+  const effective: NewTaskInput = {
     ...input,
-    workspaceId: input.workspaceId ?? parent.workspaceId,
-    mode: input.mode ?? parent.mode,
-    model: input.model ?? parent.model,
+    workspaceId: input.workspaceId ?? parent?.workspaceId,
+    mode: seed.mode,
+    permission: isTaskPermission(seed.permission) ? seed.permission : undefined,
+    model: seed.model,
+    reasoningEffort: seed.reasoningEffort,
   }
   let task = createTask(effective, now, id)
   // Arm the requested schedule (new-task dialog). The Host wire gate already

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

@@ -16,7 +16,7 @@ import type { TaskHandoverInput } from '../handover.ts'
  * Editable fields on a task (the update patch surface). `freeze` replaces the
  * continuation-card snapshot (restamping frozenAt); an explicit null clears it.
  */
-export type TaskUpdatePatch = Partial<Pick<TaskRecord, 'title' | 'description' | 'prompt' | 'workspaceId' | 'mode' | 'permission' | 'model' | 'reuseSession' | 'teamRun' | 'goalRun' | 'skipVerification'>> & {
+export type TaskUpdatePatch = Partial<Pick<TaskRecord, 'title' | 'description' | 'prompt' | 'workspaceId' | 'mode' | 'permission' | 'model' | 'reasoningEffort' | 'reuseSession' | 'teamRun' | 'goalRun' | 'skipVerification'>> & {
   freeze?: FreezeSnapshot & { redacted?: boolean } | null
   /** Replaces the handover bundle (restamping bundledAt); an explicit null clears it. */
   handover?: TaskHandoverInput | null
@@ -82,6 +82,7 @@ export function applyUpdateTask(
     const mode = 'mode' in patch ? normalizeTargetId(patch.mode) : undefined
     const permission = 'permission' in patch ? normalizePermission(task.permission, patch.permission) : undefined
     const model = 'model' in patch ? normalizeTargetId(patch.model) : undefined
+    const reasoningEffort = 'reasoningEffort' in patch ? normalizeTargetId(patch.reasoningEffort) : undefined
     const next: TaskRecord = { ...task, ...rest, updatedAt: now }
     // Content fields normalize like creation does (trimmed); an explicit
     // undefined keeps the current value — content cannot be cleared.
@@ -121,6 +122,10 @@ export function applyUpdateTask(
     if (mode !== undefined || 'mode' in patch) next.mode = mode
     if (permission !== undefined || 'permission' in patch) next.permission = permission
     if (model !== undefined || 'model' in patch) next.model = model
+    // The effort is bound to the model route above it: blank text (or an
+    // explicit undefined) returns the card to the model's own default level,
+    // and only the launch decides whether the value can be sent at all.
+    if (reasoningEffort !== undefined || 'reasoningEffort' in patch) next.reasoningEffort = reasoningEffort
     return next
   })
 }

package/src/host/agent-tools.ts

@@ -166,6 +166,7 @@ function taskSummary(
     ...(task.mode === undefined ? {} : { mode: task.mode }),
     ...(task.permission === undefined ? {} : { permission: task.permission }),
     ...(task.model === undefined ? {} : { model: task.model }),
+    ...(task.reasoningEffort === undefined ? {} : { reasoningEffort: task.reasoningEffort }),
     ...(task.reuseSession === true ? { reuseSession: true } : {}),
     ...(task.teamRun === true ? { teamRun: true } : {}),
     // Default-OFF opt-in: only a card that asked for the goal run reports it.
@@ -277,7 +278,7 @@ function buildSetParentTool(host: TaskBoardToolHost): ToolDefinition {
       'Attach an existing task under a parent (making it a subtask) or detach it back to the root board by setting its parentId.',
       'Pass an empty parentId to detach.',
       'The Host refuses the link when the parent is unknown or archived, when the moved task is one of its own descendants, when the resulting depth exceeds the deployment subtask limit (default one level, maximum three), or while the task has an unsettled execution (its link may still be a running cascade parent pointer).',
-      'Running a task runs its whole subtree concurrently; a parent card settles only after its own turn and every direct subtask settle.',
+      'Running a task opens one run group over its subtree concurrently and leaves a subtask that already sits in the done column alone; a parent card settles only after its own turn and every direct subtask it opened have settled.',
     ].join(' '),
     parameters: {
       taskId: { type: 'string', required: true, description: 'The task whose parent link changes.' },
@@ -313,7 +314,7 @@ function buildRunTool(host: TaskBoardToolHost): ToolDefinition {
       'Executions consume real API quota. Sessions are created asynchronously, so read their ids and outcomes back with task_board_get.',
     ].join(' '),
     parameters: {
-      taskId: { type: 'string', required: true, description: 'The task to run; running a root task runs its whole subtree.' },
+      taskId: { type: 'string', required: true, description: 'The task to run; running a root task runs its whole subtree, minus the subtasks that are already in the done column.' },
       rerun: { type: 'boolean', description: 'Re-run a settled task: reset its column to todo before starting (default false).' },
     },
     output: { schema: { type: 'json' }, render: renderJson },
@@ -458,7 +459,7 @@ function buildScheduleTool(host: TaskBoardToolHost): ToolDefinition {
       'Arm, change, or disarm a task scheduled runs. Two kinds of plan exist: a recurring 5-field cron rule (day-of-month and day-of-week follow Vixie semantics: both restricted means OR, otherwise AND), and a one-shot that runs once at a future instant.',
       'For a one-shot pass mode "once" with at (the planned instant, ms since epoch UTC). For a recurring rule pass mode "cron" (or omit mode) with a cron expression, optionally capped by maxRuns (a positive whole number of scheduled executions; omit for unlimited, pass 0 to clear a cap).',
       'The wall clock is read in the rule stored IANA time zone; omit timeZone to use the Host zone reported by task_board_list/task_board_get. DST gaps are skipped and an ambiguous fall-back time fires once, at the earlier instant.',
-      'A due scheduled task runs the same cascade a manual run does, so a root task runs its whole subtask tree.',
+      'A due scheduled task runs the same cascade a manual run does, so a root task runs its whole subtask tree minus the subtasks already in the done column.',
       'The scheduler counts executions it actually starts; once a rule reaches its run budget it stops itself in the ledger, and a manual run never consumes the budget. A schedule whose tree contains an unconfirmed above-default permission is refused and does not consume the budget; the reason is reported in the list board summary as schedulerError.',
       'Missed occurrences during Host downtime are skipped, never queued (a one-shot whose instant passed while the Host was down is stopped as missed); a task that is already running skips its occurrence without consuming the budget.',
     ].join(' '),
@@ -586,7 +587,7 @@ function buildCreateTool(host: TaskBoardToolHost): ToolDefinition {
     name: 'task_board_create',
     description: [
       'Create a task on the DSH task board, or a subtask by passing parentId.',
-      'A subtask inherits every execution target it does not override (workspace, agent preset, permission, model) from its parent, and inherits the parent human permission confirmation together with an inherited binding.',
+      'A subtask inherits every execution target it does not override (workspace, agent preset, permission, model, reasoning effort) from its parent, and inherits the parent human permission confirmation together with an inherited binding.',
       'The deployment caps subtask depth (default one level, maximum three): a subtask of a subtask is refused unless the board is configured deeper.',
       'The task lands in the todo column and does NOT run; call task_board_run to execute it.',
     ].join(' '),
@@ -596,9 +597,10 @@ function buildCreateTool(host: TaskBoardToolHost): ToolDefinition {
       prompt: { type: 'string', description: 'The instruction sent to the execution agent; the title is used when blank.' },
       parentId: { type: 'string', description: 'Parent task id, making this a subtask. Omit for a root task.' },
       workspaceId: { type: 'string', description: 'Workspace id the execution must run in; omit to inherit the workspace this session is in (root task) or the parent value (subtask).' },
-      mode: { type: 'string', description: 'Agent preset id the execution session is composed from; omit for the deployment default or the parent value.' },
-      permission: { type: 'string', enum: [...TASK_PERMISSIONS], description: 'Permission preset for the execution session. Omit to inherit the parent binding; a value above the session default needs a human confirmation in the board UI before the card can run.' },
-      model: { type: 'string', description: 'Pinned model as provider/model (or a model id); omit for the host default or the parent value.' },
+      mode: { type: 'string', description: 'Agent preset id the execution session is composed from; omit to adopt the board new-card default, and the deployment default when none is configured.' },
+      permission: { type: 'string', enum: [...TASK_PERMISSIONS], description: 'Permission preset for the execution session; omit to adopt the board new-card default. An omitted permission is never taken from a parent: the launch resolves the parent binding instead. A value above the session default needs a human confirmation in the board UI before the card can run.' },
+      model: { type: 'string', description: 'Pinned model as provider/model (or a model id); omit to adopt the board new-card default, and the host default when none is configured.' },
+      reasoningEffort: { type: 'string', description: 'Reasoning effort id for that model (an adapter-owned level such as "high"); omit to adopt the board new-card default for that model, and the model own default when none applies. Only an effort the target model declares is sent; an empty string clears it back to the default.' },
       reuseSession: { type: 'boolean', description: 'Continue later runs in the previous execution session instead of a fresh conversation.' },
       teamRun: { type: 'boolean', description: 'Run this task as an Agent Team: running it starts one Team Lead session and the Host spawns a teammate per subtask inside it. Omit or false for one independent session per member. Refused when the deployment serves no Agent Teams service.' },
       goalRun: { type: 'boolean', description: 'Start each run with dsh built-in /goal so the session keeps working continuation rounds until the goal completes. Off by default: omit (or pass false) for a single plain turn, and pass true to opt this card in. It only takes effect while the deployment global native /goal switch is on.' },
@@ -645,6 +647,12 @@ function buildCreateTool(host: TaskBoardToolHost): ToolDefinition {
         ...(args.mode === undefined || args.mode === '' ? {} : { mode: args.mode }),
         ...(args.permission === undefined ? {} : { permission: args.permission }),
         ...(args.model === undefined || args.model === '' ? {} : { model: args.model }),
+        ...(args.reasoningEffort === undefined || args.reasoningEffort === '' ? {} : { reasoningEffort: args.reasoningEffort }),
+        // This tool creates cards on behalf of a deployment that configured its
+        // new-card defaults once: an omitted target adopts them instead of
+        // leaving the card to resolve the host default at run time. Only the
+        // targets the caller omitted are filled.
+        applyCardDefaults: true,
         ...(args.reuseSession === true ? { reuseSession: true } : {}),
         ...(args.teamRun === true ? { teamRun: true } : {}),
         ...(args.goalRun === true ? { goalRun: true } : {}),
@@ -676,7 +684,7 @@ function buildUpdateTool(host: TaskBoardToolHost): ToolDefinition {
   return defineTool({
     name: 'task_board_update',
     description: [
-      'Edit a task board card: title, description, prompt, labels, and the execution targets (workspace, agent preset, permission, model, session reuse).',
+      'Edit a task board card: title, description, prompt, labels, and the execution targets (workspace, agent preset, permission, model, reasoning effort, session reuse).',
       'Only the fields you pass change; pass an empty string to clear a target, or an empty labels array to clear the labels.',
       'Title, description and prompt freeze once the task has started executing; the execution targets stay editable because they only affect future runs.',
       'Changing the pinned permission re-arms the permission confirmation gate.',
@@ -704,6 +712,7 @@ function buildUpdateTool(host: TaskBoardToolHost): ToolDefinition {
         description: 'New permission preset; an empty string clears it back to the session default.',
       },
       model: { type: 'string', description: 'New pinned model; an empty string clears it.' },
+      reasoningEffort: { type: 'string', description: 'New reasoning effort id for the pinned model; an empty string clears it back to the model own default. Only an effort the target model declares is sent at run time.' },
       reuseSession: { type: 'boolean', description: 'Continue later runs in the previous execution session.' },
       teamRun: { type: 'boolean', description: 'Switches this task between a plain cascade (one session per member) and an Agent Team run (Lead session plus a teammate per subtask).' },
       goalRun: { type: 'boolean', description: 'Whether each run starts with dsh built-in /goal (default false, one plain turn). Pass true to opt this card in, or false to return it to the default.' },
@@ -730,6 +739,10 @@ function buildUpdateTool(host: TaskBoardToolHost): ToolDefinition {
       if (has(args, 'workspaceId') && typeof args.workspaceId === 'string') patch.workspaceId = args.workspaceId
       if (has(args, 'mode') && typeof args.mode === 'string') patch.mode = args.mode
       if (has(args, 'model') && typeof args.model === 'string') patch.model = args.model
+      // An empty effort is the wire's clearing value (back to the model's own default).
+      if (has(args, 'reasoningEffort') && typeof args.reasoningEffort === 'string') {
+        patch.reasoningEffort = args.reasoningEffort
+      }
       // An empty permission is the wire's clearing value (back to the session default).
       if (has(args, 'permission') && typeof args.permission === 'string') {
         patch.permission = args.permission === '' ? undefined : args.permission