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

package/src/host/agent-tools.ts

@@ -23,11 +23,13 @@ import {
   TASK_PERMISSIONS,
   type ExecutionRecord,
   type NewTaskInput,
+  type ScheduleMode,
   type ScheduleRule,
   type TaskPermission,
   type TaskRecord,
   type TaskTag,
 } from '../core/tasks.ts'
+import type { SetSchedulePatch } from '../core/use-cases/task-schedule.ts'
 import type { TaskUpdatePatch } from '../core/use-cases/task-update.ts'
 import type { TaskBoardAction, TaskBoardSnapshot } from '../protocol.ts'
 
@@ -93,11 +95,22 @@ export function callingSessionId(exec: { agent?: unknown }): string | undefined
 function scheduleView(schedule: ScheduleRule): Record<string, unknown> {
   return {
     enabled: schedule.enabled,
-    cron: schedule.cron,
+    mode: schedule.mode,
+    // A one-shot has no cron, and carries its planned instant instead.
+    ...(schedule.cron === undefined ? {} : { cron: schedule.cron }),
+    ...(schedule.at === undefined ? {} : { at: schedule.at }),
     // Absent means the rule follows the Host zone, which the board view reports.
     ...(schedule.timeZone === undefined ? {} : { timeZone: schedule.timeZone }),
     ...(schedule.nextRunAt === undefined ? {} : { nextRunAt: schedule.nextRunAt }),
     ...(schedule.lastTriggeredAt === undefined ? {} : { lastTriggeredAt: schedule.lastTriggeredAt }),
+    // The run budget: what the scheduler has already opened, its cap (absent =
+    // unlimited), and how the rule stopped or what it last skipped.
+    runCount: schedule.runCount,
+    ...(schedule.maxRuns === undefined ? {} : { maxRuns: schedule.maxRuns }),
+    ...(schedule.endedAt === undefined ? {} : { endedAt: schedule.endedAt }),
+    ...(schedule.endedReason === undefined ? {} : { endedReason: schedule.endedReason }),
+    ...(schedule.skippedAt === undefined ? {} : { skippedAt: schedule.skippedAt }),
+    ...(schedule.skippedReason === undefined ? {} : { skippedReason: schedule.skippedReason }),
   }
 }
 
@@ -114,8 +127,11 @@ function executionView(execution: ExecutionRecord): Record<string, unknown> {
     ...(execution.result === undefined ? {} : { result: execution.result }),
     ...(execution.error === undefined ? {} : { error: execution.error }),
     // The session that asked for the run (audit only; client-asserted by the
-    // browser, the calling session here).
+    // browser, the calling session here). On an external record it names the
+    // outside agent instead, which is what distinguishes it in the history.
     ...(execution.initiatedBy === undefined ? {} : { initiatedBy: execution.initiatedBy }),
+    // Set only by record-external-outcome: the Host observed no session for it.
+    ...(execution.external === true ? { external: true } : {}),
     ...(execution.runGroupId === undefined ? {} : { cascade: true }),
     // A deferred cascade parent has settled its own turn but still waits for
     // its subtasks; that is not a stuck card and the model must not retry it.
@@ -150,10 +166,11 @@ 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-ON switch: only the opt-out is a deviation worth reporting.
-    ...(task.goalRun === false ? { goalRun: false } : {}),
+    // Default-OFF opt-in: only a card that asked for the goal run reports it.
+    ...(task.goalRun === true ? { goalRun: true } : {}),
     // Default-OFF opt-out: the deviation is what a reader must be told.
     ...(task.skipVerification === true ? { skipVerification: true } : {}),
     ...(task.schedule === undefined ? {} : { schedule: scheduleView(task.schedule) }),
@@ -261,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.' },
@@ -297,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 },
@@ -341,7 +358,9 @@ function buildManageTool(host: TaskBoardToolHost): ToolDefinition {
       'Move, archive, restore, delete, or settle one task board card.',
       'move-backlog, move-todo, move-running, move-done and move-failed are the manual column moves and cover every column; a card the runner is executing (one with an open execution) cannot be moved.',
       'A manual move writes the card column only and never fabricates an execution record, so the card reports a declaration rather than evidence of a run: done/failed declare work finished (or failed) outside a Host-run execution — human work, an external system, a decision made elsewhere — and running says the work is under way without a tracked session. Use task_board_run when the work should actually run in a session here.',
+      'record-external-outcome is the record-backed version of move-done and move-failed: use it when YOU, or another agent outside this Host, actually finished or failed the card with your own model, so the terminal column and the run history both derive from one execution record. It takes result (succeeded or failed) and initiatedBy (who completed it, for example your own agent name) plus an optional summary, and it is refused while the card still has an open execution: the Host stays the only authority over a run it is executing. It cannot record running or cancelled — those remain Host-only.',
       'settle force-closes the open execution of a card the board can no longer observe (a stuck running card) and records it cancelled with the caller as the reason, so the card returns to the todo column and can be run again.',
+      'reset-verification clears the acceptance anomalies (timeouts, authentication failures, an unresolvable judge route, or an attempt the time budget ended) recorded on a card open execution, so the next update_goal(action: complete) runs a fresh acceptance. It is refused unless that execution really carries such anomalies, it never clears a quality verdict, and a spent anomaly budget otherwise HOLDS the card open instead of failing it: tell the user the acceptance environment is unusable and that this action is how they clear it once they have fixed it.',
       'archive takes the whole subtask tree off the board and is refused while any member has an unsettled execution; restore brings the task, its ancestors and its subtree back; delete removes one card and is refused while it still has subtasks (detach or delete them first) or while it runs.',
       'It cannot confirm a permission binding: the confirmation gate is a human act performed in the board UI.',
     ].join(' '),
@@ -350,13 +369,59 @@ function buildManageTool(host: TaskBoardToolHost): ToolDefinition {
       action: {
         type: 'string',
         required: true,
-        enum: ['move-todo', 'move-backlog', 'move-running', 'move-done', 'move-failed', 'archive', 'restore', 'delete', 'settle'],
+        enum: ['move-todo', 'move-backlog', 'move-running', 'move-done', 'move-failed', 'archive', 'restore', 'delete', 'settle', 'reset-verification', 'record-external-outcome'],
         description: 'The lifecycle operation to perform.',
       },
+      // Only record-external-outcome reads these two; every other action
+      // ignores them, so the model can pass them without a second tool call.
+      result: {
+        type: 'string',
+        enum: ['succeeded', 'failed'],
+        description: 'record-external-outcome only: the verdict the outside agent actually reached.',
+      },
+      initiatedBy: {
+        type: 'string',
+        description: 'record-external-outcome only: who finished the work outside this Host (for example your own agent name).',
+      },
+      summary: {
+        type: 'string',
+        description: 'record-external-outcome only: optional free-text note stored with the recorded outcome.',
+      },
     },
     output: { schema: { type: 'json' }, render: renderJson },
     async execute(args, exec) {
       const initiator = callingSessionId(exec)
+      if (args.action === 'record-external-outcome') {
+        const result = args.result
+        const by = typeof args.initiatedBy === 'string' ? args.initiatedBy.trim() : ''
+        if (result !== 'succeeded' && result !== 'failed') {
+          return refused('missing-result', 'record-external-outcome needs result=succeeded or result=failed')
+        }
+        if (by === '') {
+          return refused('missing-initiator', 'record-external-outcome needs initiatedBy naming who completed the work outside this Host')
+        }
+        if (!host.snapshot().tasks.some(task => task.id === args.taskId)) {
+          return refused('task-not-found', 'no task with id ' + args.taskId)
+        }
+        try {
+          const snapshot = await host.apply(crypto.randomUUID(), {
+            kind: 'record-external-outcome',
+            taskId: args.taskId,
+            result,
+            initiatedBy: by,
+            ...(typeof args.summary === 'string' && args.summary.trim() !== '' ? { summary: args.summary } : {}),
+          }, initiator)
+          const task = snapshot.tasks.find(item => item.id === args.taskId)
+          return json({
+            ok: true,
+            action: args.action,
+            ...(task === undefined ? {} : { task: taskSummary(task, snapshot.tasks, snapshot.sessionDefaultPermission) }),
+            note: 'The outcome is recorded as its own execution, so the terminal column and the run history agree. Read it back with task_board_get.',
+          })
+        } catch (error) {
+          return refused('refused', messageOf(error))
+        }
+      }
       const actions: Record<string, TaskBoardAction> = {
         'move-todo': { kind: 'move', taskId: args.taskId, status: 'todo' },
         'move-backlog': { kind: 'move', taskId: args.taskId, status: 'backlog' },
@@ -365,6 +430,7 @@ function buildManageTool(host: TaskBoardToolHost): ToolDefinition {
         'move-failed': { kind: 'move', taskId: args.taskId, status: 'failed' },
         archive: { kind: 'archive', taskId: args.taskId },
         settle: { kind: 'settle', taskId: args.taskId },
+        'reset-verification': { kind: 'reset-verification', taskId: args.taskId },
         restore: { kind: 'restore', taskId: args.taskId },
         delete: { kind: 'delete', taskId: args.taskId },
       }
@@ -390,37 +456,46 @@ function buildScheduleTool(host: TaskBoardToolHost): ToolDefinition {
   return defineTool({
     name: 'task_board_schedule',
     description: [
-      'Arm, change, or disarm a task scheduled runs (5-field cron; day-of-month and day-of-week follow Vixie semantics: both restricted means OR, otherwise AND).',
-      'The cron 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 schedule whose tree contains an unconfirmed above-default permission is refused and rolls to its next occurrence; the reason is reported in the list board summary as schedulerError.',
-      'Missed occurrences during Host downtime are skipped, never queued; a task that is already running skips its occurrence.',
+      '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 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(' '),
     parameters: {
       taskId: { type: 'string', required: true, description: 'The task whose schedule changes.' },
       enabled: { type: 'boolean', description: 'Arm (true) or disarm (false) the schedule.' },
-      cron: { type: 'string', description: '5-field cron expression: minute hour day-of-month month day-of-week.' },
+      mode: { type: 'string', enum: ['cron', 'once'], description: 'The kind of plan: "cron" for a recurring rule, "once" for a single future instant. Omit to keep the stored kind.' },
+      cron: { type: 'string', description: '5-field cron expression of a recurring rule: minute hour day-of-month month day-of-week.' },
+      at: { type: 'integer', description: 'Planned instant of a one-shot, in milliseconds since the Unix epoch (UTC). Must be in the future.' },
       timeZone: {
         type: 'string',
-        description: 'IANA zone the cron wall clock is read in (for example Asia/Shanghai). Omit to keep the stored zone, or pass an empty string to clear it back to the Host zone.',
+        description: 'IANA zone the wall clock is read in (for example Asia/Shanghai). Omit to keep the stored zone, or pass an empty string to clear it back to the Host zone.',
       },
+      maxRuns: { type: 'integer', description: 'Maximum scheduled executions of a recurring rule (positive whole number). Omit to keep the stored cap; pass 0 to clear it back to unlimited.' },
     },
     output: { schema: { type: 'json' }, render: renderJson },
     async execute(args, exec) {
-      if (args.enabled === undefined && args.cron === undefined && args.timeZone === undefined) {
-        return refused('nothing-to-change', 'pass enabled and/or cron and/or timeZone')
+      if (args.enabled === undefined && args.mode === undefined && args.cron === undefined && args.at === undefined
+        && args.timeZone === undefined && args.maxRuns === undefined) {
+        return refused('nothing-to-change', 'pass enabled, mode, cron, at, timeZone and/or maxRuns')
       }
       // A missing card must read as a missing card: the ledger reports an
       // unknown id through the same refusal as a malformed cron.
       if (!host.snapshot().tasks.some(task => task.id === args.taskId)) {
         return refused('task-not-found', 'no task with id ' + args.taskId)
       }
-      const patch: { enabled?: boolean; cron?: string; timeZone?: string | null } = {
+      const patch: SetSchedulePatch = {
         ...(args.enabled === undefined ? {} : { enabled: args.enabled }),
+        ...(args.mode === undefined ? {} : { mode: args.mode as ScheduleMode }),
         ...(args.cron === undefined ? {} : { cron: args.cron }),
+        ...(args.at === undefined ? {} : { at: args.at }),
         // An empty string is the documented way to clear the stored zone, so
         // the model never has to emit an explicit null through JSON args.
         ...(args.timeZone === undefined ? {} : { timeZone: args.timeZone === '' ? null : args.timeZone }),
+        // 0 is the documented way to clear a run cap back to unlimited.
+        ...(args.maxRuns === undefined ? {} : { maxRuns: args.maxRuns <= 0 ? null : args.maxRuns }),
       }
       try {
         const snapshot = await host.apply(crypto.randomUUID(), { kind: 'set-schedule', taskId: args.taskId, patch }, callingSessionId(exec))
@@ -512,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(' '),
@@ -522,12 +597,13 @@ 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. Default true (omit to keep it); pass false for a single plain turn.' },
+      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.' },
       skipVerification: { type: 'boolean', description: 'Run this task without the board acceptance gate: update_goal may mark the goal complete without a passing acceptance, and the execution record is marked skipped. Default false (omit to inherit the board-wide acceptance switch). Only affects executions started afterwards.' },
       tags: {
         type: 'array',
@@ -544,10 +620,13 @@ function buildCreateTool(host: TaskBoardToolHost): ToolDefinition {
       schedule: {
         type: 'object',
         additionalProperties: false,
-        description: 'Arm a 5-field cron schedule at creation time (Host local time zone).',
+        description: 'Arm a schedule at creation time. Use mode "once" with at for a single future run, or mode "cron" (or omit mode) with a 5-field cron expression, optionally capped by maxRuns.',
         properties: {
           enabled: { type: 'boolean', required: true, description: 'Whether the schedule is armed.' },
-          cron: { type: 'string', required: true, description: '5-field cron: minute hour day-of-month month day-of-week.' },
+          mode: { type: 'string', enum: ['cron', 'once'], description: 'The kind of plan: "cron" for a recurring rule, "once" for a single future instant.' },
+          cron: { type: 'string', description: '5-field cron of a recurring rule: minute hour day-of-month month day-of-week.' },
+          at: { type: 'integer', description: 'Planned instant of a one-shot, in milliseconds since the Unix epoch (UTC). Must be in the future.' },
+          maxRuns: { type: 'integer', description: 'Maximum scheduled executions of a recurring rule (positive whole number); omit for unlimited.' },
         },
       },
     },
@@ -568,12 +647,26 @@ 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 === false ? { goalRun: false } : {}),
+        ...(args.goalRun === true ? { goalRun: true } : {}),
     ...(args.skipVerification === true ? { skipVerification: true } : {}),
         ...(tags.length === 0 ? {} : { tags }),
-        ...(args.schedule === undefined ? {} : { schedule: { enabled: args.schedule.enabled, cron: args.schedule.cron } }),
+        ...(args.schedule === undefined ? {} : {
+          schedule: {
+            enabled: args.schedule.enabled,
+            ...(args.schedule.mode === undefined ? {} : { mode: args.schedule.mode as ScheduleMode }),
+            ...(args.schedule.cron === undefined ? {} : { cron: args.schedule.cron }),
+            ...(args.schedule.at === undefined ? {} : { at: args.schedule.at }),
+            ...(args.schedule.maxRuns === undefined ? {} : { maxRuns: args.schedule.maxRuns }),
+          },
+        }),
       }
       try {
         const snapshot = await host.apply(crypto.randomUUID(), { kind: 'create', id, input }, callingSessionId(exec))
@@ -591,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.',
@@ -619,9 +712,10 @@ 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 true). Pass false to run one plain turn instead.' },
+      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.' },
       skipVerification: { type: 'boolean', description: 'Whether this task runs without the board acceptance gate (default false, inherit the board-wide switch). Pass true to opt out; pass false to opt back in. Only affects executions started afterwards.' },
       tags: {
         type: 'array',
@@ -645,13 +739,17 @@ 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
       }
       if (has(args, 'reuseSession')) patch.reuseSession = args.reuseSession === true
       if (has(args, 'teamRun')) patch.teamRun = args.teamRun === true
-      if (has(args, 'goalRun')) patch.goalRun = args.goalRun === false ? false : true
+      if (has(args, 'goalRun')) patch.goalRun = args.goalRun === true ? true : false
       if (has(args, 'skipVerification')) patch.skipVerification = args.skipVerification === true ? true : false
       if (has(args, 'tags')) {
         const tags = args.tags ?? []

package/src/host/launch-admission.ts

@@ -0,0 +1,140 @@
+/**
+ * Admission control for the session-creating half of a run.
+ *
+ * One board action can open a whole subtree, and a team run hands every member
+ * of it to the Lead at once. Both paths used to fire every launch in the same
+ * tick, so the Host asked DSH for N sessions at once — the burst the repository's
+ * measured guidance caps at three heavy implementation subagents
+ * (docs/multi-agent-resources.md), with no mechanism enforcing it.
+ *
+ * The queue is SERVICE-wide, not per run group: the pressure it bounds is the
+ * machine's (the Host process's memory and the swap it drives), and two run
+ * groups opened from two tabs share one Host. Admission is round-robin across
+ * run groups — FIFO inside a group, so a group's first run (the Lead, which
+ * carries the run shape and the teammate namespace) always starts before its
+ * members — so a large subtree cannot starve a run opened after it, and no
+ * entry can be starved.
+ *
+ * The width is read through a live callback, so a settings edit takes effect on
+ * the next admission without remounting anything.
+ *
+ * @module dsh-task-board/host/launch-admission
+ */
+
+/** One launch the queue has not started yet. */
+export interface QueuedLaunch {
+  /** Run group this launch belongs to; the unit of round-robin fairness. */
+  readonly groupId: string
+  /**
+   * Perform the launch. The slot is held until this promise settles, which
+   * makes "in flight" mean "still creating and prompting its session".
+   * A rejection is swallowed here so one broken launch can never wedge the
+   * slot; the caller owns reporting.
+   */
+  start(): Promise<void>
+  /**
+   * Called by {@link LaunchAdmissionQueue.drain} for a launch that never
+   * started, so the caller can take its execution out of the running column.
+   */
+  abandon(): void
+}
+
+export class LaunchAdmissionQueue {
+  /** Waiting launches per run group, in arrival order. */
+  private readonly waiting = new Map<string, QueuedLaunch[]>()
+  /** Run groups in round-robin order. */
+  private rotation: string[] = []
+  /** Slot holders of the launches in flight, one per admitted launch. */
+  private readonly inFlight = new Set<() => void>()
+  /** Highest number of launches in flight at once; observability and tests. */
+  peakInFlight = 0
+
+  /**
+   * @param width - live admission width (already normalized by the caller).
+   */
+  constructor(private readonly width: () => number) {}
+
+  /** Launches the queue has not admitted yet. */
+  get pendingCount(): number {
+    let total = 0
+    for (const queue of this.waiting.values()) total += queue.length
+    return total
+  }
+
+  /** Launches currently holding a slot. */
+  get inFlightCount(): number {
+    return this.inFlight.size
+  }
+
+  /** Admit one launch, immediately if a slot is free. */
+  enqueue(launch: QueuedLaunch): void {
+    const queue = this.waiting.get(launch.groupId)
+    if (queue === undefined) {
+      this.waiting.set(launch.groupId, [launch])
+      this.rotation.push(launch.groupId)
+    } else {
+      queue.push(launch)
+    }
+    this.pump()
+  }
+
+  /**
+   * Abandon every waiting launch: the queue is being torn down, so an entry
+   * that never started can never start. Launches already in flight are left
+   * alone — their session may already exist, and the callers that own them
+   * settle them through the normal path.
+   * @returns the abandoned launches, in abandonment order.
+   */
+  drain(): QueuedLaunch[] {
+    const abandoned: QueuedLaunch[] = []
+    for (const groupId of this.rotation) {
+      for (const launch of this.waiting.get(groupId) ?? []) abandoned.push(launch)
+    }
+    this.rotation = []
+    this.waiting.clear()
+    for (const launch of abandoned) launch.abandon()
+    return abandoned
+  }
+
+  private pump(): void {
+    while (this.inFlight.size < this.width()) {
+      const launch = this.takeNext()
+      if (launch === undefined) return
+      this.admit(launch)
+    }
+  }
+
+  /** The next launch by round-robin across groups and FIFO inside one. */
+  private takeNext(): QueuedLaunch | undefined {
+    while (this.rotation.length > 0) {
+      const groupId = this.rotation.shift()
+      if (groupId === undefined) return undefined
+      const queue = this.waiting.get(groupId)
+      if (queue === undefined || queue.length === 0) {
+        this.waiting.delete(groupId)
+        continue
+      }
+      const launch = queue.shift()
+      if (launch === undefined) continue
+      if (queue.length === 0) this.waiting.delete(groupId)
+      // A group that still has work goes to the back of the rotation, so every
+      // other run group gets its turn before this one's next member.
+      else this.rotation.push(groupId)
+      return launch
+    }
+    return undefined
+  }
+
+  private admit(launch: QueuedLaunch): void {
+    const release = (): void => {
+      this.inFlight.delete(release)
+      this.pump()
+    }
+    this.inFlight.add(release)
+    if (this.inFlight.size > this.peakInFlight) this.peakInFlight = this.inFlight.size
+    void Promise.resolve()
+      .then(() => launch.start())
+      .catch(() => { /* a rejected launch still releases its slot; the caller reports it */ })
+      .then(release)
+  }
+}