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

package/src/client/board/NewTaskModal.tsx

@@ -4,6 +4,7 @@
  */
 import { useEffect, useRef, useState } from 'react'
 import type { BoardController } from '../../core/controller.ts'
+import { resolveCardTargets, type CardTargetSource } from '../../core/card-defaults.ts'
 import { isValidCron, nextRunAtMs } from '../../core/schedule.ts'
 import { parseFreezeRequest } from '../../core/freeze-snapshot.ts'
 import { effectiveTaskPermission } from '../../core/subtask.ts'
@@ -15,7 +16,10 @@ import { CollapsibleSection, ModalShell, TaskContentFields, TaskTagFields, clean
 import type { OverlayPhase } from './overlay.tsx'
 import { formatHostTimestamp } from './TaskCard.tsx'
 import { readParseModelPreference, writeParseModelPreference } from './parse-model-pref.ts'
-import { inheritPresetLabel, isBuiltinPreset, presetLabel } from './preset-label.ts'
+import { inheritPresetLabel, presetChoiceRows, presetLabel } from './preset-label.ts'
+import { ReasoningEffortField } from './ReasoningEffortField.tsx'
+import { reconcileReasoningEffort } from './model-options.ts'
+import { parentAwaitsTeamRunPromotion, promoteParentForTeamRun } from './team-run-promotion.ts'
 import css from '../board.module.css'
 
 export interface NewTaskModalProps {
@@ -46,15 +50,32 @@ export function NewTaskModal({ controller, onClose, initialTask, defaultWorkspac
   const [title, setTitle] = useState(initialTask?.title ?? '')
   const [description, setDescription] = useState(initialTask?.description ?? '')
   const [prompt, setPrompt] = useState(initialTask?.prompt ?? '')
+  // The four execution targets this dialog opens on, resolved by the one rule
+  // the Host create path also uses (core/card-defaults.ts): what the card is
+  // created from (a duplicate's source, a subtask's parent) first, the board's
+  // new-card defaults second, blank when neither supplies a value. Resolving it
+  // from the SAME function the ledger uses is what keeps the dialog from
+  // drifting from what a create without an explicit choice stores.
+  const [seed] = useState(() => {
+    const source: CardTargetSource | undefined = parentTask !== undefined
+      ? { kind: 'parent', task: parentTask }
+      : initialTask !== undefined ? { kind: 'duplicate', task: initialTask } : undefined
+    return resolveCardTargets(controller.getSnapshot().host?.cardDefaults, source)
+  })
   // 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.
+  // permission stays UNSET unless a default supplies one: 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. A parent's permission never travels here at all.
   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 ?? parentTask?.model ?? '')
+  const [mode, setMode] = useState(seed.mode)
+  const [permission, setPermission] = useState(seed.permission)
+  const [model, setModel] = useState(seed.model)
+  // The effort belongs to the model pin: the resolved seed carries the source
+  // card's pair and applies the configured default level only while the final
+  // model IS the configured default model; '' follows the model/Host default.
+  const [reasoningEffort, setReasoningEffort] = useState(seed.reasoningEffort)
   const inheritedPermission = parentTask === undefined ? undefined : effectiveTaskPermission(parentTask)
   const [reuseSession, setReuseSession] = useState(initialTask?.reuseSession ?? false)
   // Unchecked by default: a new task runs one plain turn unless the user opts
@@ -100,14 +121,14 @@ export function NewTaskModal({ controller, onClose, initialTask, defaultWorkspac
   const [parsePending, setParsePending] = useState(false)
   const [parseError, setParseError] = useState<string | undefined>(undefined)
   const parseAbort = useRef<AbortController | undefined>(undefined)
-  const parseModels = options.models ?? []
+  const models = 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)
+  const modelKnown = model === '' || models.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.
@@ -124,8 +145,8 @@ export function NewTaskModal({ controller, onClose, initialTask, defaultWorkspac
   // no longer offers falls back to the Host default; an empty value is the
   // Host-default choice and is never overwritten by the roster (issue #1621).
   useEffect(() => {
-    if (parseModel === '' || parseModels.length === 0) return
-    if (parseModels.some(option => option.id === parseModel)) return
+    if (parseModel === '' || models.length === 0) return
+    if (models.some(option => option.id === parseModel)) return
     setParseModel('')
     writeParseModelPreference('')
   }, [parseModel, options.models])
@@ -215,10 +236,15 @@ export function NewTaskModal({ controller, onClose, initialTask, defaultWorkspac
       ...(parentTask === undefined ? {} : { parentId: parentTask.id }),
       freeze,
       handover,
-      workspaceId: workspaceId === '' ? undefined : workspaceId,
-      mode: mode === '' ? undefined : mode,
-      permission: permission === '' ? undefined : permission as TaskPermission,
-      model: model === '' ? undefined : model,
+      // A cleared picker is OMITTED, never sent as an empty value: absence is
+      // how "no pin, resolved at run time" is stored, so blanking a field the
+      // dialog opened prefilled really unpins it. This dialog never sends
+      // `applyCardDefaults` — the prefill above is the whole feature here.
+      ...(workspaceId === '' ? {} : { workspaceId }),
+      ...(mode === '' ? {} : { mode }),
+      ...(permission === '' ? {} : { permission: permission as TaskPermission }),
+      ...(model === '' ? {} : { model }),
+      ...(reasoningEffort === '' ? {} : { reasoningEffort }),
       ...(reuseSession ? { reuseSession: true } : {}),
       ...(goalRun ? { goalRun: true } : {}),
       ...(skipVerification ? { skipVerification: true } : {}),
@@ -247,6 +273,11 @@ export function NewTaskModal({ controller, onClose, initialTask, defaultWorkspac
       setError(controller.getSnapshot().transportError ?? t('new.required'))
       return
     }
+    // The join is confirmed, so a parent that just gained a subtask is opted in
+    // where Agent Teams are served. The write is a convenience, not part of the
+    // creation: a refused one (the card was archived meanwhile) already
+    // surfaced through the snapshot and never fails the created task.
+    await promoteParentForTeamRun(controller, parentTask)
     if (isDuplicate && archiveOriginal && initialTask !== undefined) {
       if (onDuplicateSuccess !== undefined) {
         await onDuplicateSuccess(initialTask.id)
@@ -283,10 +314,11 @@ export function NewTaskModal({ controller, onClose, initialTask, defaultWorkspac
     : isDuplicate ? t('new.duplicateTitle') : t('board.new')
 
   // Agent-preset picker rows: the four built-in presets first, then every other
-  // roster row (user presets). The inherit option names the preset a run
-  // actually lands on when the card pins nothing.
-  const builtinPresets = options.presets.filter(preset => isBuiltinPreset(preset.id))
-  const customPresets = options.presets.filter(preset => !isBuiltinPreset(preset.id))
+  // roster row (user presets), each labelled with its default/unavailable
+  // suffixes by the one row builder the settings card's default-preset field
+  // also renders through. The inherit option names the preset a run actually
+  // lands on when the card pins nothing.
+  const presetRows = presetChoiceRows(options.presets)
   const inheritLabel = inheritPresetLabel(options.presets)
   const selectedPreset = options.presets.find(preset => preset.id === mode)
   const modeLabel = mode === '' ? inheritLabel : selectedPreset === undefined ? mode : presetLabel(selectedPreset)
@@ -301,6 +333,9 @@ export function NewTaskModal({ controller, onClose, initialTask, defaultWorkspac
   const modelLabel = model === ''
     ? t('exec.model.default')
     : (options.models ?? []).find(item => item.id === model)?.name ?? model
+  // The effort is part of the model pin, so a pinned one rides the model's own
+  // summary entry instead of standing as a region-level value of its own.
+  const modelSummary = reasoningEffort === '' ? modelLabel : `${modelLabel} · ${reasoningEffort}`
   // Collapsed-region summaries: what each closed region currently holds, so a
   // collapse never hides the configuration without a trace.
   // A host-default model adds only the long parenthetical name to the
@@ -309,7 +344,7 @@ export function NewTaskModal({ controller, onClose, initialTask, defaultWorkspac
     workspaceLabel,
     modeLabel,
     permissionLabel,
-    ...(model === '' ? [] : [modelLabel]),
+    ...(model === '' ? [] : [modelSummary]),
   ].join(' · ')
   const tagCount = cleanTags(tags).length
   const labelsSummary = tagCount === 0 ? t('new.summary.none') : t('new.summary.labelCount', { count: String(tagCount) })
@@ -378,7 +413,7 @@ export function NewTaskModal({ controller, onClose, initialTask, defaultWorkspac
                 }}
               >
                 <option value="">{t('exec.model.default')}</option>
-                {parseModels.map(option => (
+                {models.map(option => (
                   <option key={option.id} value={option.id}>{option.name ?? option.id}</option>
                 ))}
               </select>
@@ -405,9 +440,14 @@ export function NewTaskModal({ controller, onClose, initialTask, defaultWorkspac
       )}
 
       {parentTask !== undefined && (
-        <p className={css.detailText} data-dsh-part="subtask-inherit">
-          {t('detail.parent')}: {parentTask.title} · {t('new.subtaskInherit')}
-        </p>
+        <>
+          <p className={css.detailText} data-dsh-part="subtask-inherit">
+            {t('detail.parent')}: {parentTask.title} · {t('new.subtaskInherit')}
+          </p>
+          {parentAwaitsTeamRunPromotion(controller, parentTask) && (
+            <p className={css.detailText}>{t('exec.teamRunAutoHint')}</p>
+          )}
+        </>
       )}
 
       <CollapsibleSection title={t('new.section.content')} defaultOpen>
@@ -460,25 +500,17 @@ export function NewTaskModal({ controller, onClose, initialTask, defaultWorkspac
           >
             <option value="">{inheritLabel}</option>
             {!modeKnown && <option value={mode}>{mode}{t('exec.mode.removed')}</option>}
-            {builtinPresets.length > 0 && (
+            {presetRows.builtin.length > 0 && (
               <optgroup label={t('exec.mode.builtinGroup')}>
-                {builtinPresets.map(preset => (
-                  <option key={preset.id} value={preset.id} disabled={preset.broken !== undefined}>
-                    {presetLabel(preset)}
-                    {preset.isDefault ? t('exec.mode.defaultSuffix') : ''}
-                    {preset.broken !== undefined ? t('exec.mode.brokenSuffix') : ''}
-                  </option>
+                {presetRows.builtin.map(row => (
+                  <option key={row.id} value={row.id} disabled={row.disabled}>{row.label}</option>
                 ))}
               </optgroup>
             )}
-            {customPresets.length > 0 && (
+            {presetRows.custom.length > 0 && (
               <optgroup label={t('exec.mode.customGroup')}>
-                {customPresets.map(preset => (
-                  <option key={preset.id} value={preset.id} disabled={preset.broken !== undefined}>
-                    {presetLabel(preset)}
-                    {preset.isDefault ? t('exec.mode.defaultSuffix') : ''}
-                    {preset.broken !== undefined ? t('exec.mode.brokenSuffix') : ''}
-                  </option>
+                {presetRows.custom.map(row => (
+                  <option key={row.id} value={row.id} disabled={row.disabled}>{row.label}</option>
                 ))}
               </optgroup>
             )}
@@ -506,15 +538,29 @@ export function NewTaskModal({ controller, onClose, initialTask, defaultWorkspac
           <select
             className={css.select}
             value={model}
-            onChange={event => { setModel(event.target.value) }}
+            onChange={event => {
+              // The effort belongs to the model: switching to a model that
+              // cannot honor the picked level drops it instead of carrying it.
+              const next = event.target.value
+              setModel(next)
+              setReasoningEffort(current => reconcileReasoningEffort(models, next, current))
+            }}
           >
             <option value="">{t('exec.model.default')}</option>
             {!modelKnown && <option value={model}>{model}{t('exec.model.unknown')}</option>}
-            {options.models?.map(item => (
+            {models.map(item => (
               <option key={item.id} value={item.id}>{item.name ?? item.id}</option>
             ))}
           </select>
         </label>
+
+        <ReasoningEffortField
+          models={models}
+          modelId={model}
+          value={reasoningEffort}
+          pending={pending}
+          onChange={setReasoningEffort}
+        />
       </CollapsibleSection>
 
       <CollapsibleSection title={t('new.section.run')} summary={runSummary}>

package/src/client/board/ReasoningEffortField.tsx

@@ -0,0 +1,50 @@
+/**
+ * Reasoning-effort field: one picker shared by both execution-target editors
+ * (the create dialog and the detail page), so the two never describe the same
+ * capability differently. The levels are the ones the picked model's catalog
+ * entry declares; an empty value is a real choice — "follow the model or Host
+ * default" — and is the default state.
+ *
+ * A stored level the roster no longer lists (the model left the roster, or its
+ * adapter changed) stays shown and labelled, but is not offered again, so the
+ * field never silently shows a different value than the one the card will ask
+ * for while the choosable set stays exactly the levels the model declares.
+ */
+import type { ExecutionModelOption } from '../../core/controller.ts'
+import { t } from '../locales.ts'
+import css from '../board.module.css'
+import { reasoningEffortsFor, reasoningHintKey, reasoningPickerEnabled } from './model-options.ts'
+
+/** The controlled reasoning-effort picker. */
+export function ReasoningEffortField({ models, modelId, value, pending, onChange }: {
+  /** The roster the picked model is looked up in. */
+  models: readonly ExecutionModelOption[]
+  /** The model this card pins; '' means "no pin". */
+  modelId: string
+  /** The selected effort; '' means "follow the model or Host default". */
+  value: string
+  /** Whether a mutation is in flight (the field locks with the rest of the form). */
+  pending: boolean
+  onChange: (next: string) => void
+}) {
+  const efforts = reasoningEffortsFor(models, modelId)
+  const unlisted = value !== '' && !efforts.includes(value)
+  return (
+    <>
+      <label className={css.field}>
+        <span className={css.fieldLabel}>{t('exec.reasoning')}</span>
+        <select
+          className={css.select}
+          value={value}
+          disabled={pending || !reasoningPickerEnabled(models, modelId)}
+          onChange={event => { onChange(event.target.value) }}
+        >
+          <option value="">{t('exec.reasoning.inherit')}</option>
+          {unlisted && <option value={value} disabled>{value}{t('exec.reasoning.unknown')}</option>}
+          {efforts.map(effort => <option key={effort} value={effort}>{effort}</option>)}
+        </select>
+      </label>
+      <p className={css.detailText}>{t(reasoningHintKey(models, modelId))}</p>
+    </>
+  )
+}

package/src/client/board/TaskDetail.tsx

@@ -12,7 +12,7 @@ import { isValidCron } from '../../core/schedule.ts'
 import { MANUAL_STATUSES, TASK_PERMISSIONS, canMoveTask, hasOpenExecution, tagTone, type ExecutionRecord, type ScheduleMode, type TaskPermission, type TaskRecord } from '../../core/tasks.ts'
 import { canEditTaskContent } from '../../core/use-cases/task-update.ts'
 import { requiresPermissionConfirmation } from '../../core/handover.ts'
-import { DEFAULT_SUBTASK_DEPTH, directSubtasks, taskDepth } from '../../core/subtask.ts'
+import { DEFAULT_SUBTASK_DEPTH, directSubtasks, joinsCascadeRun, taskDepth } from '../../core/subtask.ts'
 import { t, type TaskBoardKey } from '../locales.ts'
 import { SCHEDULE_PRESETS } from '../schedule-presets.ts'
 import { budgetLabel, defaultZonedInputValue, endedLabel, nextRunLabel, parseZonedInput, runCapOption, skippedLabel, zonedInputValue, zoneChoices } from '../schedule-zone.ts'
@@ -24,6 +24,8 @@ import { LinkSubtaskModal } from './LinkSubtaskModal.tsx'
 import { NewTaskModal } from './NewTaskModal.tsx'
 import { useDialog, usePresence, type OverlayPhase } from './overlay.tsx'
 import { inheritPresetLabel, presetLabel } from './preset-label.ts'
+import { ReasoningEffortField } from './ReasoningEffortField.tsx'
+import { reconcileReasoningEffort } from './model-options.ts'
 import { formatHostTimestamp, formatTime } from './TaskCard.tsx'
 import { STATUS_KEY } from './status-key.ts'
 import { VerificationReport } from './VerificationReport.tsx'
@@ -98,16 +100,18 @@ function ExecutionSettingsSection({ controller, task, pending, executionOptions,
   goalRunEnabled: boolean
 }) {
   const options = executionOptions
+  const models = options.models ?? []
   const workspaceId = task.workspaceId ?? ''
   const mode = task.mode ?? ''
   const permission = task.permission ?? ''
   const model = task.model ?? ''
+  const reasoningEffort = task.reasoningEffort ?? ''
   // A pinned target may disappear from the runtime (workspace deleted,
   // preset removed); keep it selectable as a stale row instead of silently
   // dropping it, so the user sees exactly what the task will ask for.
   const workspaceKnown = workspaceId === '' || options.workspaces.some(item => item.workspaceId === workspaceId)
   const modeKnown = mode === '' || options.presets.some(item => item.id === mode)
-  const modelKnown = model === '' || (options.models ?? []).some(item => item.id === model)
+  const modelKnown = model === '' || models.some(item => item.id === model)
   return (
     <section className={css.detailSection}>
       <h4>{t('detail.executionSettings')}</h4>
@@ -166,15 +170,35 @@ function ExecutionSettingsSection({ controller, task, pending, executionOptions,
           className={css.select}
           value={model}
           disabled={pending}
-          onChange={event => { controller.updateTask(task.id, { model: event.target.value === '' ? undefined : event.target.value }) }}
+          onChange={event => {
+            // The effort is part of this pin: switching to a model that cannot
+            // honor the stored level clears it in the same action instead of
+            // leaving a value the next run would have to reject. The empty
+            // string carries a clear across the JSON transport, where an
+            // `undefined` value would lose the key entirely; the ledger
+            // normalizes blank targets back to "pinned nothing".
+            const next = event.target.value
+            const effort = reconcileReasoningEffort(models, next, reasoningEffort)
+            controller.updateTask(task.id, {
+              model: next,
+              ...(effort === reasoningEffort ? {} : { reasoningEffort: effort }),
+            })
+          }}
         >
           <option value="">{t('exec.model.default')}</option>
           {!modelKnown && <option value={model}>{model}{t('exec.model.unknown')}</option>}
-          {options.models?.map(item => (
+          {models.map(item => (
             <option key={item.id} value={item.id}>{item.name ?? item.id}</option>
           ))}
         </select>
       </label>
+      <ReasoningEffortField
+        models={models}
+        modelId={model}
+        value={reasoningEffort}
+        pending={pending}
+        onChange={effort => { controller.updateTask(task.id, { reasoningEffort: effort }) }}
+      />
       <label className={css.scheduleToggle}>
         <input
           type="checkbox"
@@ -550,6 +574,18 @@ function ScheduleSection({ controller, task, pending }: { controller: BoardContr
   )
 }
 
+/**
+ * The run hint of one card: how many subtasks a run opens, counting the same
+ * members the Host will launch (`joinsCascadeRun` leaves a finished subtask
+ * alone), or why it opens none even though the card has subtasks.
+ */
+function subtaskRunHint(parentId: string, children: readonly TaskRecord[]): string {
+  const runnable = children.filter(child => joinsCascadeRun(child, parentId))
+  return runnable.length > 0
+    ? t('detail.subtasks.runHint', { count: String(runnable.length) })
+    : t('detail.subtasks.runHintSettled')
+}
+
 /**
  * The subtask block: the parent link, the direct subtasks with their status,
  * and the actions that grow or prune the tree. Every gate here mirrors the
@@ -620,7 +656,7 @@ function SubtaskSection({ controller, task, pending, archived, snapshot }: {
           </ul>
         )}
       {children.length > 0 && (
-        <p className={css.detailText}>{t('detail.subtasks.runHint', { count: String(children.length) })}</p>
+        <p className={css.detailText}>{subtaskRunHint(task.id, children)}</p>
       )}
       {!archived && (canAddChild
         ? (controller.isHostBacked()
@@ -894,7 +930,7 @@ export function TaskDetail({ controller, task, phase = 'open' }: { controller: B
               className={css.primaryButton}
               disabled={busy || pending}
               title={subtaskChildren.length > 0
-                ? t('detail.subtasks.runHint', { count: String(subtaskChildren.length) })
+                ? subtaskRunHint(current.id, subtaskChildren)
                 : undefined}
               onClick={() => {
                 void controller.rerunTask(current.id).then(() => {

package/src/client/board/model-options.ts

@@ -0,0 +1,178 @@
+/**
+ * Execution model options: the picker rows built from the official
+ * `session/modelCatalog` reply, and the reasoning-effort derivation both
+ * execution-target editors read off them (the create dialog and the detail
+ * page share one contract here, so they cannot promise different levels).
+ *
+ * The pickers must offer each model's real reasoning levels, which only the
+ * catalog declares — so the reply is normalized once, here, instead of every
+ * picker re-reading the wire shape. The fallback discovery path carries no
+ * capability metadata at all; its rows stay silent about reasoning rather than
+ * claiming a model supports none.
+ */
+import type { ExecutionModelOption } from '../../core/controller.ts'
+import type { TaskBoardKey } from '../locales.ts'
+
+/** One model's declared reasoning capability, as a picker row carries it. */
+type ModelReasoning = NonNullable<ExecutionModelOption['reasoning']>
+
+/** A plain JSON object, or undefined for anything else (including arrays). */
+function record(value: unknown): Record<string, unknown> | undefined {
+  return typeof value === 'object' && value !== null && !Array.isArray(value) ? value as Record<string, unknown> : undefined
+}
+
+/** A non-empty string, or undefined. */
+function text(value: unknown): string | undefined {
+  return typeof value === 'string' && value !== '' ? value : undefined
+}
+
+/** The effort ids an adapter published for one model, in catalog order. */
+function effortIdsOf(reasoning: Record<string, unknown>): string[] {
+  const efforts: string[] = []
+  for (const entry of Array.isArray(reasoning.efforts) ? reasoning.efforts : []) {
+    const id = text(record(entry)?.id)
+    if (id !== undefined && !efforts.includes(id)) efforts.push(id)
+  }
+  return efforts
+}
+
+/**
+ * What the catalog declares about one model's reasoning: a published
+ * `reasoning` block is what "this route reasons" means, and a model published
+ * without one is declared to have none. A model the reply never described at
+ * all is a different state, expressed by the row carrying no capability.
+ */
+function reasoningOf(model: Record<string, unknown>): ModelReasoning {
+  const reasoning = record(model.reasoning)
+  if (reasoning === undefined) return { supported: false }
+  const efforts = effortIdsOf(reasoning)
+  return { supported: true, ...(efforts.length === 0 ? {} : { efforts }) }
+}
+
+/**
+ * One picker row, or undefined when the entry carries no usable id.
+ * @param withCapability - whether this reply declares reasoning metadata at
+ * all; the flat discovery list does not, so its rows stay silent about it.
+ */
+function rowOf(model: Record<string, unknown>, provider: string | undefined, withCapability: boolean): ExecutionModelOption | undefined {
+  const id = text(model.id)
+  if (id === undefined) return undefined
+  const reasoning = withCapability ? reasoningOf(model) : undefined
+  return {
+    id: provider === undefined ? id : `${provider}/${id}`,
+    name: text(model.name) ?? id,
+    ...(provider === undefined ? {} : { provider }),
+    ...(reasoning === undefined ? {} : { reasoning }),
+  }
+}
+
+/**
+ * Normalize a `session/modelCatalog` reply into picker rows: one row per model
+ * of every provider group, keyed by the qualified route an execution pins.
+ * @param value - the raw catalog reply.
+ * @returns the rows, empty when the reply is unreadable.
+ */
+export function modelOptionsFromCatalog(value: unknown): ExecutionModelOption[] {
+  const options: ExecutionModelOption[] = []
+  const groups = record(value)?.groups
+  for (const entry of Array.isArray(groups) ? groups : []) {
+    const group = record(entry)
+    if (group === undefined) continue
+    const provider = text(group.id) ?? text(group.provider)
+    for (const item of Array.isArray(group.models) ? group.models : []) {
+      const model = record(item)
+      if (model === undefined) continue
+      const row = rowOf(model, provider, true)
+      if (row !== undefined) options.push(row)
+    }
+  }
+  return options
+}
+
+/**
+ * Normalize the flat `llm/discoverModels` list into picker rows. That reply
+ * names models only, so every row leaves the reasoning capability unknown.
+ * @param value - the raw discovery list.
+ * @returns the rows, empty when the list is unreadable.
+ */
+export function modelOptionsFromDiscoveredModels(value: unknown): ExecutionModelOption[] {
+  const options: ExecutionModelOption[] = []
+  for (const item of Array.isArray(value) ? value : []) {
+    const model = record(item)
+    if (model === undefined) continue
+    const row = rowOf(model, undefined, false)
+    if (row !== undefined) options.push(row)
+  }
+  return options
+}
+
+/**
+ * The picker rows of a model roster: the qualified `provider/model` route as
+ * the value a pin stores, and the provider beside the model name so two
+ * providers offering one model name stay distinguishable.
+ * @param models - the roster rows.
+ * @returns the choice rows, in roster order.
+ */
+export function modelChoiceRows(models: readonly ExecutionModelOption[]): Array<{ value: string; label: string }> {
+  return models.map(model => ({
+    value: model.id,
+    label: (model.provider === undefined ? '' : model.provider + ' · ') + (model.name ?? model.id),
+  }))
+}
+
+/**
+ * The capability row the roster publishes for one model route.
+ * @returns undefined when no model is pinned, or the roster does not describe
+ * the pinned one — an unknown model is not the same as a model without
+ * reasoning.
+ */
+export function reasoningOfModel(
+  models: readonly ExecutionModelOption[],
+  modelId: string,
+): ExecutionModelOption['reasoning'] | undefined {
+  if (modelId === '') return undefined
+  return models.find(item => item.id === modelId)?.reasoning
+}
+
+/**
+ * The effort ids the picker offers for a model, in catalog order.
+ * @returns an empty list when the model is unpinned, unknown, declares no
+ * reasoning, or publishes no selectable level.
+ */
+export function reasoningEffortsFor(models: readonly ExecutionModelOption[], modelId: string): string[] {
+  const reasoning = reasoningOfModel(models, modelId)
+  return reasoning?.supported === true ? [...reasoning.efforts ?? []] : []
+}
+
+/** Whether the effort picker may be operated: a pinned model with declared, selectable levels. */
+export function reasoningPickerEnabled(models: readonly ExecutionModelOption[], modelId: string): boolean {
+  return reasoningEffortsFor(models, modelId).length > 0
+}
+
+/**
+ * The effort to keep when the picked model changes. Only a model that declares
+ * its levels can invalidate one: a model the roster cannot describe keeps the
+ * stored value, because the roster has no grounds to call it invalid.
+ * @param effort - the effort currently stored/selected ('' = follow the default).
+ * @returns the effort to keep.
+ */
+export function reconcileReasoningEffort(
+  models: readonly ExecutionModelOption[],
+  modelId: string,
+  effort: string,
+): string {
+  if (effort === '') return ''
+  const reasoning = reasoningOfModel(models, modelId)
+  if (reasoning === undefined) return modelId === '' ? '' : effort
+  return reasoning.efforts?.includes(effort) === true ? effort : ''
+}
+
+/**
+ * The copy explaining why the picker is in its current state. One lookup for
+ * both editors, so the create dialog and the detail page never drift apart.
+ */
+export function reasoningHintKey(models: readonly ExecutionModelOption[], modelId: string): TaskBoardKey {
+  if (modelId === '') return 'exec.reasoning.hint.pickModel'
+  if (reasoningOfModel(models, modelId) === undefined) return 'exec.reasoning.hint.unknownModel'
+  return reasoningPickerEnabled(models, modelId) ? 'exec.reasoning.hint.inherit' : 'exec.reasoning.hint.noEfforts'
+}

package/src/client/board/preset-label.ts

@@ -42,3 +42,35 @@ export function inheritPresetLabel(presets: readonly ExecutionPresetOption[]): s
   if (fallback === undefined) return t('exec.mode.inherit')
   return t('exec.mode.inheritWith', { preset: presetLabel(fallback) })
 }
+
+/** One preset row a picker renders: the stored id, its label, and whether it may be picked. */
+export interface PresetChoiceRow {
+  /** The value a pin stores. */
+  id: string
+  /** Display label, already carrying the default and unavailable suffixes. */
+  label: string
+  /** True when the preset cannot compose a session: the row is shown but not selectable. */
+  disabled: boolean
+}
+
+/**
+ * The picker rows of one roster, split into the built-in and the user presets.
+ * Both pickers render these rows — the create dialog's mode select and the
+ * settings card's default-preset field — so their wording and their
+ * unavailable rows cannot drift apart.
+ * @param presets - the roster options.
+ * @returns one row list per group, in roster order.
+ */
+export function presetChoiceRows(presets: readonly ExecutionPresetOption[]): { builtin: PresetChoiceRow[]; custom: PresetChoiceRow[] } {
+  const row = (preset: ExecutionPresetOption): PresetChoiceRow => ({
+    id: preset.id,
+    label: presetLabel(preset)
+      + (preset.isDefault ? t('exec.mode.defaultSuffix') : '')
+      + (preset.broken !== undefined ? t('exec.mode.brokenSuffix') : ''),
+    disabled: preset.broken !== undefined,
+  })
+  return {
+    builtin: presets.filter(preset => isBuiltinPreset(preset.id)).map(row),
+    custom: presets.filter(preset => !isBuiltinPreset(preset.id)).map(row),
+  }
+}