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

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

@@ -0,0 +1,58 @@
+/**
+ * The agent-preset roster the execution-target pickers read: one read of the
+ * generated api-remotes face, and its normalization into the option rows the
+ * board controller and the settings card's new-card-defaults topic both
+ * consume.
+ *
+ * The roster is a runtime fact of the deployment, not ledger state. The
+ * namespace mounts with the official api-remotes assembly, so the read itself
+ * is wired through a scoped inject at the call site (see src/client/index.ts);
+ * this module owns only the shape both consumers agree on, so neither has to
+ * know how the wire face answers.
+ */
+import type { ClientRemote } from '@deepseek-ai/dsh-api-remotes/client'
+import type { ExecutionPresetOption } from '../../core/controller.ts'
+
+/** The generated Remote namespace the mode pickers read their roster from. */
+export type PresetRemote = ClientRemote['agentPresets']
+
+/** One agent-preset row the wire face answers with. */
+export interface PresetRosterRow {
+  id: string
+  name?: string
+  description?: string
+  /** Why this preset cannot compose a session; absent when it can. */
+  broken?: string
+  isDefault: boolean
+}
+
+/**
+ * Read the agent-preset roster of one deployment. The caller passes the
+ * namespace resolved inside its scoped inject, so a host that serves no such
+ * namespace never reaches here; a host that serves it answers `ok: false`
+ * instead, which leaves the caller's options untouched.
+ * @param remote - the `remote.agentPresets` namespace.
+ * @returns the roster, or a failed read the caller ignores.
+ */
+export async function readPresetRoster(remote: PresetRemote): Promise<{ ok: boolean; presets: readonly PresetRosterRow[] }> {
+  const response = await remote.list()
+  if (!response.ok) return { ok: false, presets: [] }
+  return { ok: true, presets: response.value.presets }
+}
+
+/**
+ * Normalize one roster into the picker rows the UI consumes. A preset that
+ * cannot compose a session keeps its `broken` reason: the pickers show it and
+ * disable it, so a missing preset never looks like a missing roster.
+ * @param presets - the roster rows.
+ * @returns the picker options.
+ */
+export function presetOptionsFromRoster(presets: readonly PresetRosterRow[]): ExecutionPresetOption[] {
+  return presets.map(preset => ({
+    id: preset.id,
+    name: preset.name,
+    description: preset.description,
+    broken: preset.broken,
+    isDefault: preset.isDefault,
+  }))
+}

package/src/client/board/team-run-promotion.ts

@@ -0,0 +1,39 @@
+/**
+ * Team-run promotion for a parent card that just gained a subtask. A card with
+ * subtasks is exactly what the Agent Team mode is for, so the two join actions
+ * (create a subtask, link an existing task) opt the parent in — but only after
+ * the Host confirmed the join, and only where the deployment serves Agent
+ * Teams. A refused join changes nothing, and a parent that already opted in is
+ * left alone rather than rewritten.
+ *
+ * Nothing here runs on mount or from a render effect: an existing card is only
+ * ever touched by the user's own join action, so switching the option off by
+ * hand stays off.
+ */
+import type { BoardController } from '../../core/controller.ts'
+import type { TaskRecord } from '../../core/tasks.ts'
+
+/**
+ * Whether a join would promote this parent: the deployment serves Agent Teams
+ * and the parent has not opted in yet.
+ * @param controller - the board controller (the snapshot carries both facts).
+ * @param parent - the task that gained a subtask, if there is one.
+ */
+export function parentAwaitsTeamRunPromotion(controller: BoardController, parent: TaskRecord | undefined): boolean {
+  if (parent === undefined) return false
+  const snapshot = controller.getSnapshot()
+  if (snapshot.host?.teamRunAvailable !== true) return false
+  // The freshest record wins: the card may have been edited since this modal
+  // opened with its own copy.
+  return (snapshot.tasks.find(task => task.id === parent.id) ?? parent).teamRun !== true
+}
+
+/**
+ * Opt the parent in after the Host confirmed the join.
+ * @returns true when the opt-in was written; false when it did not apply.
+ */
+export async function promoteParentForTeamRun(controller: BoardController, parent: TaskRecord | undefined): Promise<boolean> {
+  if (parent === undefined) return false
+  if (!parentAwaitsTeamRunPromotion(controller, parent)) return false
+  return await controller.updateTask(parent.id, { teamRun: true })
+}

package/src/client/index.ts

@@ -24,7 +24,9 @@ import type {} from '@deepseek-ai/dsh-client-ui-settings/client'
 // Type-only: pulls the workspace plugin's Context merge (ctx.uiWorkspace), the
 // multi-instance navigation face that replaced ISessions.open().
 import type {} from '@deepseek-ai/dsh-client-ui-workspace/client'
-import { BoardController, TASK_BOARD_PANEL_ID } from '../core/controller.ts'
+import { BoardController, TASK_BOARD_PANEL_ID, type ExecutionModelOption, type ExecutionPresetOption } from '../core/controller.ts'
+import { modelOptionsFromCatalog, modelOptionsFromDiscoveredModels } from './board/model-options.ts'
+import { presetOptionsFromRoster, readPresetRoster, type PresetRemote } from './board/preset-roster.ts'
 import { mainViewSessionId } from './main-session.ts'
 import { LocalStorageTaskStore } from '../core/store.ts'
 import { claimTaskboardApply, releaseTaskboardApply } from './apply-guard.ts'
@@ -140,33 +142,6 @@ declare module '@deepseek-ai/cordis' {
  */
 export const inject = ['slots', 'sessions', 'workspaces', 'connection', 'configForms', 'locale', 'remote', 'remote.session', 'uiWorkspace', 'layout']
 
-/** The generated Remote namespace the mode picker reads its roster from. */
-type PresetRemote = ClientRemote['agentPresets']
-
-/** One agent-preset row the mode picker consumes. */
-interface PresetRosterRow {
-  id: string
-  name?: string
-  description?: string
-  /** Why this preset cannot compose a session; absent when it can. */
-  broken?: string
-  isDefault: boolean
-}
-
-/**
- * Read the agent-preset roster through the generated api-remotes face. The
- * caller passes the namespace resolved inside its scoped inject, so a host
- * that serves no such namespace never reaches here; a host that serves it
- * answers `ok: false` instead, which leaves the picker options untouched.
- * @param remote - the `remote.agentPresets` namespace.
- * @returns the roster, or a failed read the caller ignores.
- */
-async function readPresetRoster(remote: PresetRemote): Promise<{ ok: boolean; presets: readonly PresetRosterRow[] }> {
-  const response = await remote.list()
-  if (!response.ok) return { ok: false, presets: [] }
-  return { ok: true, presets: response.value.presets }
-}
-
 /**
  * Mount the task board.
  * @param ctx - client root context (services: sessions, workspaces).
@@ -229,6 +204,48 @@ export function apply(ctx: ClientContext): void {
   })
   ctx.effect(() => () => { settingsCard.dispose() }, 'task-board: settings card')
 
+  // The agent-preset roster is a runtime fact of the deployment, not ledger
+  // state, and TWO surfaces read it: the board's mode pickers and the settings
+  // card's new-card-defaults topic. It is wired here, outside the board view,
+  // because the settings card stays reachable while the board itself is
+  // disabled — that is where it is switched back on — and its default-preset
+  // field must not lose the roster with the view. The namespace mounts with the
+  // official api-remotes assembly, which the page applies beside this entry: at
+  // mount time it is usually still absent, and reading it through
+  // `remote.agentPresets` before it lands throws ("cannot get property ...
+  // without inject"), so a one-shot probe would leave both pickers with nothing
+  // but "inherit" for the page lifetime. A hard inject is no better — it would
+  // pend the whole plugin on a deployment that never mounts the namespace. The
+  // scoped inject runs the feed exactly when the namespace exists and re-runs it
+  // if the namespace is replaced; the reconnect read inside covers a deployment
+  // change behind the same namespace.
+  let presetRoster: readonly ExecutionPresetOption[] | undefined
+  let liveController: BoardController | undefined
+  const pushPresetOptions = async (presetRemote: PresetRemote): Promise<void> => {
+    try {
+      const roster = await readPresetRoster(presetRemote)
+      if (!roster.ok) return
+      const presets = presetOptionsFromRoster(roster.presets)
+      presetRoster = presets
+      settingsCard.setPresetRoster(presets)
+      liveController?.setExecutionOptions({ presets })
+    } catch (error) {
+      // A failed roster read leaves the previous options in place: the pickers
+      // stay usable, the default-preset field keeps the inherit choice alone,
+      // and the next reconnect retries the read.
+      console.error('[dsh-task-board] agent preset roster read failed', error)
+    }
+  }
+  const presetRosterFeed = ctx.inject(['remote.agentPresets'], (inner) => {
+    const presetRemote = inner.get('remote.agentPresets') as PresetRemote | undefined
+    if (presetRemote === undefined) return
+    void pushPresetOptions(presetRemote)
+    // Subscribed inside the injected scope, so a namespace that goes away takes
+    // its listener with it instead of leaving one per remount.
+    return inner.on('connection/reset', () => { void pushPresetOptions(presetRemote) })
+  })
+  ctx.effect(() => () => { void presetRosterFeed.dispose() }, 'task-board: agent preset roster')
+
   // The sidebar entry and board view mount once the settings form settles;
   // while the form is still loading, the composition default is unknown, so
   // nothing mounts yet. Only an unavailable form (no settings surface served)
@@ -275,12 +292,35 @@ export function apply(ctx: ClientContext): void {
     clientService.attach(controller)
 
     const disposers: Array<() => void> = []
+    // The board follows the live controller for the roster feed wired above,
+    // which serves the settings card whether or not the view is mounted.
+    liveController = controller
+    if (presetRoster !== undefined) controller.setExecutionOptions({ presets: presetRoster })
+
+    // The new-card defaults are written through the very settings form this
+    // plugin binds (that is the card's save), and the Host republishes its
+    // snapshot on that write. Its SSE frame carries the value as of BEFORE the
+    // write, though, so a mirror that only followed frames would hand the create
+    // dialog the previous defaults for the rest of the page session — the
+    // "configure a default, create a card, get nothing" report. Follow the form
+    // instead: when the four defaults it holds change, re-read the authoritative
+    // snapshot. The signature keeps one write to one GET (the form announces a
+    // settled document more than once) and keeps an unrelated settings write, or
+    // any board action, from pulling the ledger again.
+    let followedDefaults = cardDefaultSignature(settingsForm.getSnapshot().value)
+    disposers.push(settingsForm.subscribe(() => {
+      const next = cardDefaultSignature(settingsForm.getSnapshot().value)
+      if (next === followedDefaults) return
+      followedDefaults = next
+      controller.refreshHostState()
+    }))
 
     // Execution-target option feeds: the workspace list drives the workspace
     // picker, and the agent-preset roster drives the mode picker. Both are
     // runtime facts (not ledger state), so the wiring pushes them into the
-    // controller on change; the preset roster is re-read after reconnects
-    // because a reconnect may serve a different deployment.
+    // controller on change; the preset roster feed itself lives beside the
+    // settings card (see apply) because that card's new-card-defaults topic
+    // reads the same roster while this view may not be mounted at all.
     const pushWorkspaceOptions = (): void => {
       const snapshot = workspaces.list.getSnapshot()
       controller.setExecutionOptions({
@@ -299,47 +339,9 @@ export function apply(ctx: ClientContext): void {
       const created = await workspaces.create({ path })
       return { workspaceId: created.workspaceId }
     })
-    const pushPresetOptions = async (presetRemote: PresetRemote): Promise<void> => {
-      try {
-        const roster = await readPresetRoster(presetRemote)
-        if (!roster.ok) return
-        controller.setExecutionOptions({
-          presets: roster.presets.map(preset => ({
-            id: preset.id,
-            name: preset.name,
-            description: preset.description,
-            broken: preset.broken,
-            isDefault: preset.isDefault,
-          })),
-        })
-      } catch (error) {
-        // A failed roster read leaves the previous options in place; the
-        // picker stays usable and the next reconnect retries the read.
-        console.error('[dsh-task-board] agent preset roster read failed', error)
-      }
-    }
-    // The roster namespace mounts with the official api-remotes assembly,
-    // which the page applies beside this entry: at mount time the namespace is
-    // usually still absent, and reading it through `remote.agentPresets`
-    // before it lands throws ("cannot get property ... without inject"), so a
-    // one-shot probe leaves the mode picker with nothing but "inherit" for the
-    // page lifetime. A hard inject is no better — it would pend the whole
-    // board on a deployment that never mounts the namespace. The scoped inject
-    // runs the feed exactly when the namespace exists and re-runs it if the
-    // namespace is replaced; the reconnect read inside covers a deployment
-    // change behind the same namespace.
-    const presetRosterFeed = ctx.inject(['remote.agentPresets'], (inner) => {
-      const presetRemote = inner.get('remote.agentPresets') as PresetRemote | undefined
-      if (presetRemote === undefined) return
-      void pushPresetOptions(presetRemote)
-      // Subscribed inside the injected scope, so a namespace that goes away
-      // takes its listener with it instead of leaving one per remount.
-      return inner.on('connection/reset', () => { void pushPresetOptions(presetRemote) })
-    })
-    disposers.push(() => { void presetRosterFeed.dispose() })
     const pushModelOptions = async (): Promise<void> => {
       try {
-        let models: Array<{ id: string; name?: string; provider?: string }> = []
+        let models: ExecutionModelOption[] = []
         let sessionRemote: ClientRemote['session'] | undefined
         try {
           sessionRemote = (remote as Partial<ClientRemote>).session
@@ -348,15 +350,7 @@ export function apply(ctx: ClientContext): void {
         }
         if (typeof sessionRemote?.modelCatalog === 'function') {
           const res = await sessionRemote.modelCatalog()
-          if (res.ok && Array.isArray(res.value?.groups)) {
-            for (const g of res.value.groups) {
-              const provider = (g as { id?: string; provider?: string }).id ?? (g as { id?: string; provider?: string }).provider
-              for (const m of g.models ?? []) {
-                const qualifiedId = provider ? `${provider}/${m.id}` : m.id
-                models.push({ id: qualifiedId, name: m.name ?? m.id, provider })
-              }
-            }
-          }
+          if (res.ok) models = modelOptionsFromCatalog(res.value)
         }
         if (models.length === 0) {
           const conn = ctx.get('connection') as {
@@ -368,11 +362,8 @@ export function apply(ctx: ClientContext): void {
           } | undefined
           if (conn?.api) {
             if (typeof conn.api.llm?.discoverModels === 'function') {
-              const res = await conn.api.llm.discoverModels() as { result?: { value?: { models?: Array<{ id: string; name?: string }> } } }
-              const list = res?.result?.value?.models
-              if (Array.isArray(list)) {
-                models = list.map(m => ({ id: m.id, name: m.name }))
-              }
+              const res = await conn.api.llm.discoverModels() as { result?: { value?: { models?: unknown } } }
+              models = modelOptionsFromDiscoveredModels(res?.result?.value?.models)
             }
             const catalogFn = typeof conn.api.session?.modelCatalog === 'function'
               ? conn.api.session.modelCatalog
@@ -380,17 +371,8 @@ export function apply(ctx: ClientContext): void {
                 ? conn.api.sessions.modelCatalog
                 : undefined
             if (models.length === 0 && catalogFn !== undefined) {
-              const res = await catalogFn() as { result?: { value?: { groups?: Array<{ id?: string; provider?: string; models?: Array<{ id: string; name?: string }> }> } } }
-              const groups = res?.result?.value?.groups
-              if (Array.isArray(groups)) {
-                for (const g of groups) {
-                  const provider = g.id ?? g.provider
-                  for (const m of g.models ?? []) {
-                    const qualifiedId = provider ? `${provider}/${m.id}` : m.id
-                    models.push({ id: qualifiedId, name: m.name ?? m.id, provider })
-                  }
-                }
-              }
+              const res = await catalogFn() as { result?: { value?: unknown } }
+              models = modelOptionsFromCatalog(res?.result?.value)
             }
           }
         }
@@ -427,6 +409,7 @@ export function apply(ctx: ClientContext): void {
       for (const dispose of disposers.splice(0)) dispose()
       clientService.detach()
       controller.dispose()
+      liveController = undefined
       uiDisposer = undefined
     }
   }
@@ -480,6 +463,27 @@ export function bindSettingsForm(ctx: ClientContext): ConfigForm<TaskBoardSettin
   })
 }
 
+/**
+ * The four new-card defaults one settings document holds, as a change
+ * signature.
+ *
+ * Deliberately nothing but those four keys: the settings form also carries the
+ * board's own switches and the acceptance configuration, and an edit to one of
+ * those says nothing about the defaults the create dialog prefills from. Not a
+ * second normalization of Host state — the value never leaves this comparison.
+ * @param value - the settings form's effective section, if it has one.
+ * @returns a stable string that changes exactly when the defaults do.
+ */
+function cardDefaultSignature(value: unknown): string {
+  const section = (value ?? {}) as Record<string, unknown>
+  return JSON.stringify([
+    section.cardDefaultMode,
+    section.cardDefaultPermission,
+    section.cardDefaultModel,
+    section.cardDefaultReasoningEffort,
+  ])
+}
+
 /**
  * The profile entry id this package's own row carries, for a page that serves
  * no family binder.

package/src/client/locales.ts

@@ -247,6 +247,14 @@ export const zh = {
   'exec.permission.danger-full-access': '完全访问',
   'exec.model.default': '宿主默认（agent-default-model）',
   'exec.model.unknown': '（未知模型/回退默认）',
+  'exec.reasoning': '思考档位',
+  'exec.reasoning.inherit': '沿用模型/宿主默认',
+  'exec.reasoning.unknown': '（未知档位）',
+  'exec.reasoning.hint.pickModel': '先选择要钉住的模型，才能设置它的思考档位。',
+  'exec.reasoning.hint.unknownModel': '无法从当前名册确认该模型的可选档位；已保存的值原样保留。',
+  'exec.reasoning.hint.noEfforts': '该模型没有可选的思考档位，始终沿用模型/宿主的默认值。',
+  'exec.reasoning.hint.inherit': '留空即沿用该模型/宿主的默认档位。',
+  'exec.teamRunAutoHint': '创建或关联子任务成功后，父任务会自动开启 Agent Team 执行（可随时手动关闭）。',
   'exec.reuseSession': '在同一对话继续',
   'exec.teamRun': '用 Agent Team 执行（Leader/teammate）',
   'exec.teamRunHint': '开启后：执行本任务只启动一个 Leader 会话，每个子任务由它派生为 teammate 并在该会话内并行工作（子任务自身的权限钉住不适用）。关闭则每个成员各开独立会话。',
@@ -292,6 +300,8 @@ export const zh = {
   'settings.maxSubtaskDepth': '子任务深度上限',
   'settings.maxSubtaskDepthHint': '默认 1：一个任务只允许一层子任务，子任务不能再创建或关联子任务。最大 3。执行父任务会并发执行它的整棵子任务树，层级越深，一次执行开启的会话越多。',
   'settings.maxSubtaskDepthOption': '{depth} 层',
+  'settings.runLaunchWidth': '并发启动上限',
+  'settings.runLaunchWidthHint': '默认 3。一次执行会开启整棵子任务树，但同一刻最多只有这么多个成员在创建会话并入队 Prompt，其余成员排队等待——全部都会启动，只是分批进入运行列。默认值取自本仓「重型实施子代理并发 ≤ 3」的实测纪律。取值 1–16：越大启动越快，Host 的内存与 swap 压力越高。执行中修改只影响尚未入列的启动。',
   'settings.runBehaviorTitle': '运行行为',
   'settings.runBehaviorCardHint': '全局原生 /goal 执行开关（总开关，默认关闭）。',
   'settings.goalRunGlobal': '全局启用 DSH 原生 /goal 执行',
@@ -321,6 +331,11 @@ export const zh = {
   'settings.goalVerificationEffortFallback': '所选推理强度 {requested} 不被目标模型支持，已回退为 {resolved}。',
   'settings.goalVerificationEffortFallbackNone': '所选推理强度 {requested} 不被目标模型支持，已回退为该模型默认档位（不显式传参）。',
   'settings.goalVerificationModelInvalid': '配置的验收模型不是 provider/model 形式，已回退宿主默认。',
+  'settings.cardDefaultsTitle': '新建卡片默认值',
+  'settings.cardDefaultsCardHint': '新建对话框打开时预填的 Agent 预设、权限、模型与思考档位；留空即不设置，创建卡片的行为与未配置时完全一致。它们只是预填，不改变任何既有语义，新建的卡片仍可随时修改；思考档位默认值只在卡片最终钉住的模型就是这里的默认模型时才生效。',
+  'settings.cardDefaultModeHint': '留空不钉住任何值，新建卡片照旧继承部署默认预设。取值优先级为：新建对话框里的显式选择 > 复制源卡或父任务已钉住的值 > 这里的默认值；子任务沿用父卡已钉住的值。',
+  'settings.cardDefaultPermissionHint': '留空为不设置（用会话默认）。高于会话默认权限基线的默认值仍只是预填：卡片执行前照旧需要人工确认。子任务从不沿用父卡的权限，只在父卡未钉住、且这里设置了默认值时才预填。',
+  'settings.cardDefaultModelHint': '留空为宿主默认（agent-default-model）。对话框里的显式选择优先于源卡/父卡已钉住的值，后者优先于这里的默认值；自己选了模型的调用方不借用任何默认档位。',
   'running.executing': '执行中',
   'running.verifying': '验收中',
   'running.repairing': '验收未通过修复中',
@@ -395,7 +410,8 @@ export const zh = {
   'detail.subtasks.link': '关联现有任务',
   'detail.subtasks.detach': '解除关联',
   'detail.subtasks.runningLock': '子任务正在执行，结算后才能解除关联或改挂父任务',
-  'detail.subtasks.runHint': '执行本任务会同时并发执行它的 {count} 个子任务；子任务失败不影响其它子任务继续执行。',
+  'detail.subtasks.runHint': '执行本任务会同时并发执行它 {count} 个未完成的子任务；已在完成列的子任务不会重复执行，子任务失败不影响其它子任务继续执行。',
+  'detail.subtasks.runHintSettled': '这个任务的子任务都已在完成列；执行本任务不会重复执行它们，要让某个子任务再跑一次，把它移回待办列或单独执行它。',
   'detail.subtasks.waiting': '等待子任务结算',
   'detail.subtasks.depthLimit': '当前子任务深度上限为 {depth} 层，子任务不能再创建或关联子任务。',
   'detail.subtasks.hostOnly': '连接 Host 后才能创建或关联子任务。',
@@ -677,6 +693,14 @@ export const en: Record<keyof typeof zh, string> = {
   'exec.permission.danger-full-access': 'Full Access',
   'exec.model.default': 'Host default (agent-default-model)',
   'exec.model.unknown': ' (unknown / fallback to default)',
+  'exec.reasoning': 'Reasoning effort',
+  'exec.reasoning.inherit': 'Model or Host default',
+  'exec.reasoning.unknown': ' (unknown effort)',
+  'exec.reasoning.hint.pickModel': 'Pin a model first, then choose its reasoning effort.',
+  'exec.reasoning.hint.unknownModel': "The current roster cannot confirm this model's effort levels; the stored value is kept as it is.",
+  'exec.reasoning.hint.noEfforts': 'This model offers no selectable reasoning effort, so the model or Host default always applies.',
+  'exec.reasoning.hint.inherit': 'Leave it empty to follow the model or Host default.',
+  'exec.teamRunAutoHint': 'Once a subtask is created or linked, the parent task turns on Agent Team execution automatically (you can switch it off at any time).',
   'exec.reuseSession': 'Continue in the same conversation',
   'exec.teamRun': 'Run with an Agent Team (Lead + teammates)',
   'exec.teamRunHint': 'On: running this task starts one Lead session and spawns a teammate per subtask inside it, working in parallel (a subtask permission pin does not apply). Off: every member gets its own independent session.',
@@ -722,6 +746,8 @@ export const en: Record<keyof typeof zh, string> = {
   'settings.maxSubtaskDepth': 'Subtask depth limit',
   'settings.maxSubtaskDepthHint': 'Default 1: a task may carry one level of subtasks, and a subtask cannot create or link further subtasks. Maximum 3. Running a task also runs its whole subtask tree concurrently, and every extra level opens more sessions per run.',
   'settings.maxSubtaskDepthOption': '{depth} levels',
+  'settings.runLaunchWidth': 'Concurrent run launches',
+  'settings.runLaunchWidthHint': 'Default 3. A run opens its whole subtree, but only this many members create their session and queue their prompt at the same time; the rest wait their turn. Every member still starts, entering the running column in batches. The default comes from this repository\'s measured guidance for heavy implementation subagents (at most three). Range 1 to 16: a larger width starts runs sooner and costs the Host more memory and swap. Edited during a run, it bounds the launches that have not been admitted yet.',
   'settings.runBehaviorTitle': 'Run behavior',
   'settings.runBehaviorCardHint': 'The global native /goal switch (master control, off by default).',
   'settings.goalRunGlobal': 'Global: run tasks with dsh native /goal',
@@ -750,6 +776,11 @@ export const en: Record<keyof typeof zh, string> = {
   'settings.goalVerificationRouteMissing': 'The host serves no model catalog, so no judge route resolves: with acceptance on, a goal completion claim is refused and recorded as an acceptance anomaly.',
   'settings.goalVerificationEffortFallback': 'The selected reasoning effort {requested} is not supported by the target model; it falls back to {resolved}.',
   'settings.goalVerificationEffortFallbackNone': 'The selected reasoning effort {requested} is not supported by the target model; it falls back to that model default level (not sent explicitly).',
+  'settings.cardDefaultsTitle': 'New-card defaults',
+  'settings.cardDefaultsCardHint': 'What the new-task dialog opens with: agent preset, permission, model and reasoning effort. Blank sets nothing, so creating a card behaves exactly as it does unconfigured. They are only prefills and change no existing meaning, and every new card stays editable; the default reasoning effort applies only while a card ends up on the configured default model.',
+  'settings.cardDefaultModeHint': 'Blank pins nothing: a new card keeps following the deployment default preset. A target resolves as the explicit choice in the new-task dialog, then the value carried over from the source card or parent, then this default; a subtask keeps what its parent already pinned.',
+  'settings.cardDefaultPermissionHint': 'Blank sets nothing (the session default applies). A default above the session permission baseline is still only a prefill: the card still needs a human confirmation before it may run. A subtask never carries its parent permission; this default fills in only where the parent pinned none.',
+  'settings.cardDefaultModelHint': 'Blank is the host default (agent-default-model). An explicit choice in the dialog wins over the value carried over from the source card or parent, which wins over this default; a caller that pins a model of its own borrows no default reasoning level.',
   'settings.goalVerificationModelInvalid': 'The configured judge model is not a provider/model route; the host default is used instead.',
   'running.executing': 'Executing',
   'running.verifying': 'Verifying',
@@ -825,7 +856,8 @@ export const en: Record<keyof typeof zh, string> = {
   'detail.subtasks.link': 'Link existing task',
   'detail.subtasks.detach': 'Detach',
   'detail.subtasks.runningLock': 'This subtask is running; it can be detached or re-linked once it settles',
-  'detail.subtasks.runHint': 'Running this task also runs its {count} subtasks concurrently; one subtask failing does not stop the others.',
+  'detail.subtasks.runHint': 'Running this task also runs its {count} unfinished subtasks concurrently; a subtask already in the done column is not run again, and one subtask failing does not stop the others.',
+  'detail.subtasks.runHintSettled': 'Every subtask of this task is already in the done column; running this task does not repeat them. To run one again, move it back to the todo column or run it on its own.',
   'detail.subtasks.waiting': 'Waiting for subtasks',
   'detail.subtasks.depthLimit': 'The subtask depth limit is {depth}; a subtask cannot create or link further subtasks.',
   'detail.subtasks.hostOnly': 'Connect to the Host to create or link subtasks.',

package/src/client/settings-entry-form.ts

@@ -52,7 +52,6 @@ function pendingSnapshot<T>(): ConfigFormSnapshot<T> {
     user: undefined,
     revision: undefined,
     writable: false,
-    mode: 'host',
   }
 }
 

package/src/core/card-defaults.ts

@@ -0,0 +1,132 @@
+/**
+ * New-card defaults: the execution targets a freshly created card starts from,
+ * and how they combine with what the caller picked and with the card a subtask
+ * or a duplicate is created from.
+ *
+ * Framework-free (no cordis, no runtime imports) because BOTH halves compile
+ * it: the Host resolves the seed when it writes the card, and the browser
+ * resolves the same seed to open the new-task dialog on it. One pure function
+ * is the only place the rules live, so the dialog and the ledger cannot drift.
+ *
+ * Every target is resolved in ONE order: what the caller picked wins over the
+ * value carried over from the card this one is created from, which wins over
+ * the board's new-card defaults, and a target nothing supplies stays blank
+ * ("no pin, resolved at run time"). A duplicate is a copy of its source and a
+ * subtask is derived from its parent, so both keep the source's own pins and
+ * fill only the fields that source left unset.
+ *
+ * The permission of a PARENT is the one exception: it never participates. The
+ * permission is not copied onto a card at creation — doing so would also have
+ * to copy the parent's human confirmation to stay runnable, and a detached
+ * child would keep both, so one confirmed parent would mint unbounded confirmed
+ * elevated roots. It is resolved along the ancestor chain at launch instead
+ * (core/subtask.ts), which is what makes detaching remove the inheritance by
+ * construction. A duplicate is not a hierarchy link, so it copies the
+ * permission like every other target. The board's own default permission is not
+ * a parent binding either and does apply to a subtask; it only pre-fills the
+ * card, and a value above the session baseline still needs a human
+ * confirmation before the card may run.
+ *
+ * The reasoning level is bound to the model route it was chosen for and never
+ * crosses to another one:
+ *
+ *   - a level the caller picked is used as it stands;
+ *   - a caller that pinned a model of its own inherits no level at all, not
+ *     even one the same model happens to carry on the source card;
+ *   - otherwise the source card's level travels with the source value it was
+ *     stored on, exactly as the card's own model/level pair does, and wins over
+ *     the board default level, so a board that configures none behaves exactly
+ *     as the create path always has;
+ *   - a board default level applies only while the card's final model IS the
+ *     configured default model, and a blank default model makes it inert —
+ *     a level the resolved model does not declare could only be refused by
+ *     model selection at run time.
+ */
+import type { TaskRecord } from './tasks.ts'
+
+/** The board's configured new-card defaults; a blank target means "not set". */
+export interface CardDefaults {
+  /** Agent preset a new card starts from. */
+  mode?: string
+  /** Permission a new card starts from. */
+  permission?: string
+  /** Model a new card starts from. */
+  model?: string
+  /** Reasoning level a new card starts from, for the model above. */
+  reasoningEffort?: string
+}
+
+/** The card a new one is created from, and how it is derived from it. */
+export interface CardTargetSource {
+  /** A copy of the source card, or a subtask of it. */
+  kind: 'duplicate' | 'parent'
+  /** The source card's execution targets. */
+  task: Pick<TaskRecord, 'mode' | 'permission' | 'model' | 'reasoningEffort'>
+}
+
+/** The resolved targets of the card about to be created; blank means "unset". */
+export interface CardTargetSeed {
+  mode: string
+  permission: string
+  model: string
+  reasoningEffort: string
+}
+
+/** Trim one optional target: blank text means "not set", like every stored pin. */
+function textOf(value: string | undefined): string {
+  return value?.trim() ?? ''
+}
+
+/**
+ * Resolve the execution targets a new card starts from.
+ * @param defaults - the board's configured new-card defaults, if any.
+ * @param source - the card this one is created from (a duplicate or a parent), if any.
+ * @param picked - what the caller chose explicitly; a non-blank value wins.
+ * @returns the four targets, blank where nothing supplies a value.
+ */
+export function resolveCardTargets(
+  defaults: CardDefaults | undefined,
+  source: CardTargetSource | undefined,
+  picked?: Partial<CardTargetSeed>,
+): CardTargetSeed {
+  const defaultMode = textOf(defaults?.mode)
+  const defaultPermission = textOf(defaults?.permission)
+  const defaultModel = textOf(defaults?.model)
+  // A default level with no default model of its own names no route to bind to
+  // (only a hand-edited settings document can express that), so it is inert.
+  const defaultEffort = defaultModel === '' ? '' : textOf(defaults?.reasoningEffort)
+  const chosen = {
+    mode: textOf(picked?.mode),
+    permission: textOf(picked?.permission),
+    model: textOf(picked?.model),
+    reasoningEffort: textOf(picked?.reasoningEffort),
+  }
+  const copied = source === undefined ? undefined : {
+    mode: textOf(source.task.mode),
+    permission: textOf(source.task.permission),
+    model: textOf(source.task.model),
+    reasoningEffort: textOf(source.task.reasoningEffort),
+  }
+
+  /** The value carried over from the source card, or the board default. */
+  const inherited = (key: 'mode' | 'permission' | 'model'): string => {
+    const fallback = key === 'mode' ? defaultMode : key === 'model' ? defaultModel : defaultPermission
+    // A parent's binding never travels; a duplicate's does (it is not a link).
+    if (copied === undefined || (key === 'permission' && source?.kind === 'parent')) return fallback
+    return copied[key] === '' ? fallback : copied[key]
+  }
+
+  const mode = chosen.mode === '' ? inherited('mode') : chosen.mode
+  const permission = chosen.permission === '' ? inherited('permission') : chosen.permission
+  const model = chosen.model === '' ? inherited('model') : chosen.model
+
+  let reasoningEffort = chosen.reasoningEffort
+  if (reasoningEffort === '' && chosen.model === '') {
+    // The caller pinned no model of its own, so the level follows the source
+    // pair first and the board default second.
+    const sourced = copied === undefined ? '' : copied.reasoningEffort
+    reasoningEffort = sourced !== '' ? sourced : (model !== '' && model === defaultModel ? defaultEffort : '')
+  }
+
+  return { mode, permission, model, reasoningEffort }
+}