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

package/src/host-service.ts

@@ -1,15 +1,18 @@
 import type { TypertGateway } from '@deepseek-ai/dsh-api-gateway'
+import { DEFAULT_RUN_LAUNCH_WIDTH, normalizeRunLaunchWidth } from './core/launch-width.ts'
 import { DEFAULT_SESSION_POLL_SECONDS, normalizeSessionPollSeconds, sessionPollMs } from './core/poll-cadence.ts'
 import { reusableSessionId } from './core/session-reuse.ts'
+import { LaunchAdmissionQueue, type QueuedLaunch } from './host/launch-admission.ts'
 import { HostTaskLedger, type OpenedRun, type OpenExecutionReference } from './host-ledger.ts'
-import { HostExecutionRunner, SessionLaunchError, promptText, type SessionCommandDispatcher, type SessionSummary, type TaskBoardWorkspaceRegistry } from './host-runner.ts'
+import { HostExecutionRunner, SessionLaunchError, promptText, type GatewayPeer, type SessionCommandDispatcher, type SessionSummary, type TaskBoardWorkspaceRegistry } from './host-runner.ts'
 import { teammateName } from './core/subtask.ts'
 import { workspaceOwningSession } from './core/workspace-target.ts'
 import { PowerInhibitor } from './power-inhibitor.ts'
 import { TASK_BOARD_SCHEMA_VERSION, type TaskBoardAction, type TaskBoardEventPayload, type TaskBoardSnapshot } from './protocol.ts'
+import type { CardDefaults } from './core/card-defaults.ts'
 import { TaskBoardExtensionRegistry } from './host/extension-registry.ts'
 import type { TaskBoardExtension } from './core/extension.ts'
-import type { ExecutionOutcome, ScheduleMode, TaskRecord, TaskStatus } from './core/tasks.ts'
+import { isTaskPermission, normalizeTargetId, type ExecutionOutcome, type ScheduleMode, type TaskRecord, type TaskStatus } from './core/tasks.ts'
 import { passedAttempt, resolveContract, verificationNeverInvoked, verificationOnlyInvalid, verificationRequired, withAcceptanceDetailCleared, type ExecutionVerification, type ModelCatalogView, type VerificationContract, type VerificationSettings } from './core/verification.ts'
 import type { TaskPermission } from './core/handover.ts'
 
@@ -65,6 +68,35 @@ const MAX_TIMER_DELAY_MS = 2_147_483_647
  */
 const UNREADABLE_SETTLE_POLLS = 24
 
+/**
+ * Why a member of a run never started: the Host stopped while its launch was
+ * still waiting for an admission slot. Recorded rather than left open, so the
+ * card leaves the running column instead of waiting for the next Host start's
+ * interrupted-start recovery.
+ */
+const ABANDONED_LAUNCH_REASON = 'host stopped before this execution started'
+
+/**
+ * The acceptance contract one run group freezes, read once for the whole group.
+ *
+ * The board freezes an execution's acceptance contract BEFORE its session is
+ * prompted. Admission delays the launch, so reading these per execution would
+ * let a settings edit made while later members wait reach some members of one
+ * run and not others. Reading them once per run group — at the group's first
+ * admission, which is its root's — keeps the whole group on one contract and
+ * still freezes it before any member's session is prompted.
+ */
+interface FrozenRunContract {
+  settings: VerificationSettings
+  /** The GLOBAL native-/goal switch, resolved exactly once for the run group. */
+  globalGoalEnabled: boolean
+  /** The host model catalog the group's contracts resolve their route from. */
+  catalog: ModelCatalogView | undefined
+}
+
+/** Reads (or returns the already-read) contract of one run group. */
+type RunContractFreezer = () => Promise<FrozenRunContract>
+
 /**
  * Why an enforced goal execution settled failed while its acceptance DID run:
  * attempts were recorded and none of them passed. The judge answered about the
@@ -105,10 +137,18 @@ export interface ScheduledRunContext {
 }
 
 /**
- * Actions that can move an armed trigger. Only these re-arm the native timer;
- * an unrelated card edit leaves the pending fire untouched.
+ * Actions that can change the instant the schedule timer is armed at. Only
+ * these re-arm the native timer; an unrelated card edit leaves the pending fire
+ * untouched.
+ *
+ * The set is the write surface of a rule itself rather than a guess at the UI
+ * flows that reach it: `create` and `import` land a card that already carries
+ * an enabled rule (the new-task dialog and the one-time browser import),
+ * `set-schedule` edits one, and `delete`/`archive` drop one. `update` is
+ * deliberately absent — the update patch cannot carry a schedule — and neither
+ * can the run, move, lineage, permission, verification or label actions.
  */
-const SCHEDULE_WRITE_ACTIONS: ReadonlySet<TaskBoardAction['kind']> = new Set(['set-schedule', 'delete', 'archive'])
+const SCHEDULE_WRITE_ACTIONS: ReadonlySet<TaskBoardAction['kind']> = new Set(['create', 'import', 'set-schedule', 'delete', 'archive'])
 
 /**
  * The native timer face the Host arms through. The cordis `timer` service
@@ -134,6 +174,29 @@ const PROCESS_TIMERS: HostTimerFace = {
   },
 }
 
+/**
+ * The new-card defaults a snapshot publishes, or undefined when this
+ * deployment configures none. A target the board configures nothing for is
+ * omitted instead of published blank, so the browser can tell "no default
+ * model" from "a blank one" (only a hand-edited settings document can express
+ * the latter).
+ */
+function cardDefaultsOf(defaults: CardDefaults): TaskBoardSnapshot['cardDefaults'] {
+  const mode = normalizeTargetId(defaults.mode)
+  const permission = normalizeTargetId(defaults.permission)
+  const model = normalizeTargetId(defaults.model)
+  const reasoningEffort = normalizeTargetId(defaults.reasoningEffort)
+  const published: NonNullable<TaskBoardSnapshot['cardDefaults']> = {
+    ...(mode === undefined ? {} : { mode }),
+    // The snapshot publishes a permission the board's own vocabulary knows; an
+    // out-of-domain value is ignored here exactly as the create path ignores it.
+    ...(isTaskPermission(permission) ? { permission } : {}),
+    ...(model === undefined ? {} : { model }),
+    ...(reasoningEffort === undefined ? {} : { reasoningEffort }),
+  }
+  return Object.keys(published).length === 0 ? undefined : published
+}
+
 export class TaskBoardHostService {
   readonly ledger: HostTaskLedger
   readonly runner: HostExecutionRunner
@@ -154,6 +217,12 @@ export class TaskBoardHostService {
   private disposed = false
   private pollInFlight = false
   private active = true
+  /**
+   * Admission control for the session-creating half of a run: one board action
+   * opens a whole subtree, and this is what keeps the Host from asking DSH for
+   * every member's session at once (see {@link LaunchAdmissionQueue}).
+   */
+  private readonly launches: LaunchAdmissionQueue
   /**
    * Consecutive unreadable-history polls per open execution (see
    * {@link noteUnreadableInspection}). Cleared as soon as an inspection
@@ -167,6 +236,14 @@ export class TaskBoardHostService {
   private readonly timers: HostTimerFace
   /** Live reader of the global native-/goal switch; frozen per execution. */
   private readonly goalRunEnabled: () => boolean
+  /** Live reader of the deployment's new-card defaults (published and applied per create). */
+  private readonly cardDefaults: () => CardDefaults
+  /**
+   * Live reader of the run-launch admission width: how many launches may be in
+   * flight at once. Read at every admission, so a settings edit bounds the next
+   * launch without remounting the row. Absent means the default.
+   */
+  private readonly runLaunchWidth: () => number
   private lastPowerJson = ''
   private readonly now: () => number
   /** The deployment's workspaces, consulted to resolve a card that pins none. */
@@ -184,12 +261,26 @@ export class TaskBoardHostService {
     now?: () => number
     commandDispatcher?: SessionCommandDispatcher
     workspaceRegistry?: TaskBoardWorkspaceRegistry
+    /**
+     * The owner peer every gateway request the runner makes speaks for.
+     * Production passes the peer bound to the plugin fiber (see
+     * {@link createOwnerPeer}); absent is fine for tests and bare mounts,
+     * where the runner binds one to a fresh root context.
+     */
+    ownerPeer?: GatewayPeer
     /**
      * Permission baseline of the confirmation gate: a fixed value, or a live
      * resolver the board re-reads so a Host Settings change needs no remount.
      */
     sessionDefaultPermission?: TaskPermission | (() => TaskPermission)
     maxSubtaskDepth?: number
+    /**
+     * Live reader of the deployment's new-card defaults (volatile config reads).
+     * The board publishes them for the create dialog and re-reads them for every
+     * create that opts in, so a settings edit reaches the next created card
+     * without remounting the row. Absent means the deployment configures none.
+     */
+    cardDefaults?: () => CardDefaults
     team?: TaskBoardTeamDispatcher
     timers?: HostTimerFace
     /**
@@ -208,18 +299,29 @@ export class TaskBoardHostService {
     verificationSettings?: () => VerificationSettings
     /** The host model catalog the acceptance contract resolves its route from. */
     verificationCatalog?: () => Promise<ModelCatalogView | undefined>
+    /**
+     * Live admission width for run launches: the number of launches (one
+     * session creation and its prompt each) that may be in flight at once. Read
+     * per admission, so editing the setting bounds the next launch of a run that
+     * is still queueing. Absent means the default width.
+     */
+    runLaunchWidth?: () => number
   } = {}) {
     this.ledger = options.ledger ?? new HostTaskLedger(undefined, undefined, {
       sessionDefaultPermission: options.sessionDefaultPermission,
       maxSubtaskDepth: options.maxSubtaskDepth,
+      cardDefaults: options.cardDefaults,
     })
-    this.runner = new HostExecutionRunner(gateway, options.commandDispatcher, options.workspaceRegistry)
+    this.runner = new HostExecutionRunner(gateway, options.commandDispatcher, options.workspaceRegistry, undefined, options.ownerPeer)
     this.workspaceRegistry = options.workspaceRegistry
     this.team = options.team
     this.timers = options.timers ?? PROCESS_TIMERS
     this.power = options.power ?? new PowerInhibitor()
     this.now = options.now ?? Date.now
     this.goalRunEnabled = options.goalRunEnabled ?? (() => false)
+    this.cardDefaults = options.cardDefaults ?? (() => ({}))
+    this.runLaunchWidth = options.runLaunchWidth ?? (() => DEFAULT_RUN_LAUNCH_WIDTH)
+    this.launches = new LaunchAdmissionQueue(() => normalizeRunLaunchWidth(this.runLaunchWidth()))
     this.verificationSettings = options.verificationSettings ?? (() => ({ enabled: false, model: '', reasoningEffort: '' }))
     this.verificationCatalog = options.verificationCatalog ?? (async () => undefined)
     this.extensions = new TaskBoardExtensionRegistry({
@@ -310,6 +412,7 @@ export class TaskBoardHostService {
   snapshot(): TaskBoardSnapshot {
     const state = this.ledger.state()
     const published = this.extensions.published()
+    const cardDefaults = cardDefaultsOf(this.cardDefaults())
     return {
       schemaVersion: TASK_BOARD_SCHEMA_VERSION,
       revision: state.revision,
@@ -323,6 +426,10 @@ export class TaskBoardHostService {
       // service freezes its own read at launch: this mirror is for the FORM
       // (enable/disable + explanation), never for a run already in flight.
       goalRunEnabled: this.goalRunEnabled(),
+      // The new-card defaults are published live for the same reason the switch
+      // is: the create dialog prefills from them, and each creating session
+      // re-reads them for the create it submits.
+      ...(cardDefaults === undefined ? {} : { cardDefaults }),
       ...(Object.keys(published).length === 0 ? {} : { extensions: published }),
     }
   }
@@ -427,9 +534,11 @@ export class TaskBoardHostService {
     }
     const result = this.ledger.applyRequest(requestId, this.withInheritedWorkspace(action, initiator), initiator)
     if (result.runs !== undefined) this.dispatchRuns(result.runs)
-    // A committed schedule write (create / update / toggle / delete) moves the
-    // nearest trigger; re-arm on every action so a newly enabled schedule fires
-    // at its own instant without waiting for the previous target to elapse.
+    // A committed write that can move a rule moves the nearest trigger;
+    // re-arm from the ledger so a created or edited schedule fires at its own
+    // instant instead of waiting out whatever target was armed before it. The
+    // re-arm is derived from the ledger, so a write that moved nothing leaves
+    // the pending fire exactly as it was.
     if (SCHEDULE_WRITE_ACTIONS.has(action.kind)) this.refreshSchedule()
     this.emitStatusChanges(before, initiator)
     if (action.kind === 'delete') this.extensions.emitTaskDeleted({ taskId: action.taskId })
@@ -474,6 +583,14 @@ export class TaskBoardHostService {
 
   dispose(): void {
     this.disposed = true
+    // Launches still waiting for a slot can never start now: settle them so
+    // their cards leave the running column here, instead of waiting for the
+    // next Host start's interrupted-start recovery. Launches already in flight
+    // are left to finish — their session may already exist.
+    const abandoned = this.launches.drain()
+    if (abandoned.length > 0) {
+      safeConsoleError(`[dsh-task-board] ${abandoned.length} run member(s) were still waiting for a launch slot when the Host stopped; each is settled as cancelled`)
+    }
     this.extensions.dispose()
     this.clearScheduleTimer()
     this.clearPollBackoff()
@@ -484,7 +601,7 @@ export class TaskBoardHostService {
     this.listeners.clear()
   }
 
-  private async launch(opened: OpenedRun, others: readonly OpenedRun[] = [], schedule?: ScheduledRunContext): Promise<void> {
+  private async launch(opened: OpenedRun, others: readonly OpenedRun[] = [], schedule?: ScheduledRunContext, freezeContract?: RunContractFreezer): Promise<void> {
     /** The session this launch attached to the execution, once it exists. */
     let attached: string | undefined
     try {
@@ -512,11 +629,16 @@ export class TaskBoardHostService {
       // retrofit the rule that will judge it. A card that opted out resolves the
       // same contract from an OFF switch: the board-wide switch decides the
       // default, the card decides this execution, and both are read here.
-      const settings = this.verificationSettings()
-      // The GLOBAL native-/goal switch is read ONCE here and carried by value
-      // for the whole execution: a settings edit after this point can only
+      //
+      // The read is the run GROUP's when the queue handed one down: admission
+      // delays a member's launch, so a per-execution read would let a settings
+      // edit made while later members wait reach some members of one run and not
+      // others. One group, one contract — and still frozen before the group's
+      // first session is prompted.
+      const { settings, globalGoalEnabled, catalog } = await (freezeContract ?? (() => this.freezeRunContract()))()
+      // The GLOBAL native-/goal switch is read ONCE per run group and carried by
+      // value for the whole execution: a settings edit after this point can only
       // affect executions that start later.
-      const globalGoalEnabled = this.goalRunEnabled() === true
       // The card must ASK for the goal run: the option is off by default, so an
       // absent value is a plain turn exactly like an explicit false.
       const goalEnabled = globalGoalEnabled && opened.task.goalRun === true
@@ -525,7 +647,7 @@ export class TaskBoardHostService {
       const skippedBy: ExecutionVerification['applicability'] = opened.task.skipVerification === true ? 'skipped' : 'disabled'
       const contract = resolveContract(
         { ...settings, enabled: settings.enabled && opened.task.skipVerification !== true },
-        await this.verificationCatalog(),
+        catalog,
       )
       // An execution that will not become a goal run can never fire the
       // completion gate, so it is marked with the reason that actually applied:
@@ -549,6 +671,8 @@ export class TaskBoardHostService {
         // The frozen global switch travels with the launch, so the runner's
         // arming decision is exactly the one made above.
         goalEnabled,
+        // The same catalog snapshot the acceptance contract was frozen from.
+        catalog,
         // Bind the session to the execution before the prompt is queued, so the
         // completion gate can never observe the agent without its binding.
         onSession: (id) => {
@@ -573,16 +697,60 @@ export class TaskBoardHostService {
       // failed launch can never silently spend the user's run budget. A manual
       // run, and a launch that DID reach a session, are never refunded.
       if (schedule !== undefined && attached === undefined && launchedSession === undefined) {
-        this.ledger.refundScheduledOccurrence(opened.task.id, this.now())
+        this.refundUnstartedSchedule(opened.task.id)
       }
       this.settleAndNotify(opened.task.id, opened.execution.id, 'failed', error instanceof Error ? error.message : String(error))
     }
   }
 
+  /**
+   * Read the acceptance contract one run group freezes, in the order the board
+   * has always read it: the acceptance settings, then the global native-/goal
+   * switch, then the model catalog that both resolves the contract's route and
+   * decides the reasoning effort the session may be given.
+   */
+  private async freezeRunContract(): Promise<FrozenRunContract> {
+    const settings = this.verificationSettings()
+    const globalGoalEnabled = this.goalRunEnabled() === true
+    const catalog = await this.verificationCatalog()
+    return { settings, globalGoalEnabled, catalog }
+  }
+
+  /**
+   * A {@link RunContractFreezer} that reads once and hands the SAME value to
+   * every later caller of one run group. A read that fails is not cached: the
+   * next member reads again, exactly as a per-execution read would have.
+   */
+  private contractFreezerForRunGroup(): RunContractFreezer {
+    let pending: Promise<FrozenRunContract> | undefined
+    return () => {
+      pending ??= this.freezeRunContract().catch((error: unknown) => {
+        pending = undefined
+        throw error
+      })
+      return pending
+    }
+  }
+
+  /**
+   * Give back the occurrence a launch consumed, for a launch that never reached
+   * a session: a failed launch, or one the Host abandoned while it was still
+   * waiting for an admission slot. A manual run, and a launch that DID reach a
+   * session, are never refunded.
+   */
+  private refundUnstartedSchedule(taskId: string): void {
+    this.ledger.refundScheduledOccurrence(taskId, this.now())
+    // The refund runs after the fire already armed the next target, and a
+    // refunded occurrence can restore one the fire had just cleared (a rule
+    // that spent its last run). Re-arm so the restored occurrence is served
+    // at its own instant rather than lost until some unrelated write.
+    this.refreshSchedule()
+  }
+
   private scheduleTeammate(opened: OpenedRun, leadSessionId: string): void {
-    void this.spawnTeammate(opened, leadSessionId).catch(error => {
+    this.enqueueLaunch(opened, () => this.spawnTeammate(opened, leadSessionId).catch(error => {
       safeConsoleError('[dsh-task-board] teammate spawn settlement failed', error)
-    })
+    }))
   }
 
   /**
@@ -966,14 +1134,22 @@ export class TaskBoardHostService {
    * member then launches on its own so one refused participant cannot hold the
    * others back. A team run's members are spawned inside the root's Lead
    * session instead, once that session exists.
+   *
+   * Every launch of one run set goes through the admission queue, which admits
+   * at most `runLaunchWidth` of them at a time — the whole subtree still opens,
+   * members just enter the running column in batches. Order inside the group is
+   * the order they are enqueued here, so the root's session always exists before
+   * any member's, and one member's launch settling (or failing) is what admits
+   * the next. All members share the one contract this group freezes.
    */
   private dispatchRuns(runs: readonly OpenedRun[], schedule?: ScheduledRunContext): void {
     if (runs.length === 0) return
     const root = runs.find(run => run.dispatch !== 'teammate') ?? runs[0]
     const others = runs.filter(run => run !== root)
-    this.scheduleLaunch(root, others, schedule)
+    const freezeContract = this.contractFreezerForRunGroup()
+    this.scheduleLaunch(root, others, schedule, freezeContract)
     for (const run of others) {
-      if (run.dispatch !== 'teammate') this.scheduleLaunch(run, [], schedule)
+      if (run.dispatch !== 'teammate') this.scheduleLaunch(run, [], schedule, freezeContract)
     }
   }
 
@@ -987,10 +1163,58 @@ export class TaskBoardHostService {
     this.ledger.setVerification(taskId, executionId, { ...verification, applicability })
   }
 
-  private scheduleLaunch(opened: OpenedRun, others: readonly OpenedRun[] = [], schedule?: ScheduledRunContext): void {
-    void this.launch(opened, others, schedule).catch(error => {
+  private scheduleLaunch(opened: OpenedRun, others: readonly OpenedRun[] = [], schedule?: ScheduledRunContext, freezeContract?: RunContractFreezer): void {
+    this.enqueueLaunch(opened, () => this.launch(opened, others, schedule, freezeContract).catch(error => {
       safeConsoleError('[dsh-task-board] execution launch settlement failed', error)
-    })
+    }), schedule)
+  }
+
+  /**
+   * Hand one launch to the admission queue, or abandon it on the spot when the
+   * Host is already stopping: a queue entry created after {@link dispose} would
+   * otherwise never be drained, and its card would sit in the running column
+   * until the next Host start recovered it.
+   */
+  private enqueueLaunch(opened: OpenedRun, start: () => Promise<void>, schedule?: ScheduledRunContext): void {
+    const launch: QueuedLaunch = {
+      groupId: opened.execution.runGroupId ?? opened.task.id,
+      start: async () => {
+        // Waiting for a slot is time the execution can be settled in: a manual
+        // settle, or a team run folded onto its Lead's verdict, can close a
+        // member's execution before it ever started. Starting it then would
+        // create a session no execution is watching, so a launch whose
+        // execution is already closed is dropped instead.
+        if (!this.isExecutionOpen(opened)) return
+        await start()
+      },
+      abandon: () => this.abandonQueuedRun(opened, schedule),
+    }
+    if (this.disposed) {
+      launch.abandon()
+      return
+    }
+    this.launches.enqueue(launch)
+  }
+
+  /** Whether one opened execution is still open in the ledger. */
+  private isExecutionOpen(opened: OpenedRun): boolean {
+    const execution = this.ledger.getTask(opened.task.id)?.executions.find(entry => entry.id === opened.execution.id)
+    return execution !== undefined && execution.endedAt === undefined
+  }
+
+  /**
+   * Take one launch that never started out of the running column.
+   *
+   * Settled as CANCELLED, not failed: nothing about the run's work went wrong —
+   * the Host stopped before the launch got a slot, which is exactly what the
+   * next start's interrupted-start recovery records for an execution that never
+   * reached a session. A scheduled occurrence that never reached a session is
+   * refunded on the same terms as any other pre-session failure, so a run the
+   * Host never started cannot silently spend the user's run budget.
+   */
+  private abandonQueuedRun(opened: OpenedRun, schedule?: ScheduledRunContext): void {
+    if (schedule !== undefined) this.refundUnstartedSchedule(opened.task.id)
+    this.settleAndNotify(opened.task.id, opened.execution.id, 'cancelled', ABANDONED_LAUNCH_REASON)
   }
 
   private schedulePoll(): void {

package/src/index.ts

@@ -18,10 +18,12 @@ import type {} from '@deepseek-ai/dsh-tools'
 import type { ToolDefinition } from '@deepseek-ai/dsh-tools'
 import type { LlmRuntime } from '@deepseek-ai/dsh-llm'
 import { TaskBoardHostService, type HostTimerFace, type TaskBoardTeamDispatcher } from './host-service.ts'
+import { createOwnerPeer } from './host-runner.ts'
 import { parseTaskDraft, TaskParseError } from './host-ai.ts'
 import { TASK_PERMISSIONS, isTaskPermission, type TaskPermission } from './core/tasks.ts'
 import { DEFAULT_SUBTASK_DEPTH, SUBTASK_DEPTH_MAX, SUBTASK_DEPTH_MIN } from './core/subtask.ts'
 import { DEFAULT_SESSION_POLL_SECONDS, SESSION_POLL_MAX_SECONDS, SESSION_POLL_MIN_SECONDS } from './core/poll-cadence.ts'
+import { DEFAULT_RUN_LAUNCH_WIDTH, RUN_LAUNCH_WIDTH_MAX, RUN_LAUNCH_WIDTH_MIN } from './core/launch-width.ts'
 import {
   DEFAULT_VERIFICATION_BUDGET_SECONDS,
   DEFAULT_VERIFICATION_CALL_TIMEOUT_SECONDS,
@@ -33,6 +35,7 @@ import {
   verificationCallTimeoutMs,
 } from './core/verification-budget.ts'
 import { DEFAULT_SESSION_PERMISSION } from './core/handover.ts'
+import type { CardDefaults } from './core/card-defaults.ts'
 import { buildTaskBoardTools, TASK_BOARD_TOOL_NAMES } from './host/agent-tools.ts'
 import { PLUGIN_TOOL_SECTION_ORDERS, visibleToolText } from './tool-surface.ts'
 import { makeTaskBoardRoutes } from './host-routes.ts'
@@ -106,6 +109,17 @@ export interface Config {
    * at all, so this cadence only bounds how quickly a running card settles.
    */
   sessionPollSeconds?: Volatile<number>
+  /**
+   * How many run launches this board may have in flight at once (1..16,
+   * default 3). One run opens its whole subtree, so without a bound the Host
+   * asks DSH for every member's session in the same tick; this is the mechanism
+   * that enforces the repository's measured guidance for heavy implementation
+   * subagents. Members wait their turn instead of being dropped: the subtree
+   * still opens completely, they only enter the running column in batches. Read
+   * at each admission, so an edit bounds the next launch of a run that is still
+   * queueing.
+   */
+  runLaunchWidth?: Volatile<number>
   /**
    * Continuable-subagent provider the Agent Teams service uses to compose a
    * teammate. Matches the Agent Teams tool plugin's `freshProvider` default;
@@ -128,6 +142,33 @@ export interface Config {
    * becomes a goal run.
    */
   goalRunEnabled?: Volatile<boolean>
+  /**
+   * Agent preset a NEW card starts from (volatile, default blank = not set).
+   * A prefill, never a pin: the create dialog opens with it selected, the
+   * caller may override it, and the card stores what it was created with. It
+   * reaches the create path only when that caller opts in with
+   * `applyCardDefaults`, so the extension provider's own create and the legacy
+   * import are untouched.
+   */
+  cardDefaultMode?: Volatile<string>
+  /**
+   * Permission a NEW card starts from (volatile, default blank = not set), one
+   * of the three presets. A prefill like the rest: a value above
+   * `sessionDefaultPermission` still has to be confirmed by a human before the
+   * card may run, because the pre-execution gate is what decides that.
+   */
+  cardDefaultPermission?: Volatile<TaskPermission | ''>
+  /**
+   * Model a NEW card starts from (volatile, default blank = not set).
+   */
+  cardDefaultModel?: Volatile<string>
+  /**
+   * Reasoning level a NEW card starts from (volatile, default blank = not set).
+   * Bound to `cardDefaultModel` exactly as a card's own level is bound to its
+   * own model: it applies only while the card's final model IS that default
+   * model, and a blank `cardDefaultModel` makes it inert.
+   */
+  cardDefaultReasoningEffort?: Volatile<string>
   /**
    * Goal acceptance for executions this board starts (default ON). When on,
    * update_goal(action: complete) inside a task execution is refused until an
@@ -205,10 +246,20 @@ export interface ConfigInput {
   maxSubtaskDepth?: number
   /** Roster-poll cadence in seconds while the board has work to reconcile. */
   sessionPollSeconds?: number
+  /** Concurrent run launches allowed at once, 1..16. */
+  runLaunchWidth?: number
   /** Continuable-subagent provider the Agent Teams service composes a teammate from. */
   teamProvider?: string
   /** Global native /goal switch; default off, frozen per execution. */
   goalRunEnabled?: boolean
+  /** Agent preset a new card starts from; blank = not set. */
+  cardDefaultMode?: string
+  /** Permission a new card starts from; blank = not set. */
+  cardDefaultPermission?: TaskPermission | ''
+  /** Model a new card starts from; blank = not set. */
+  cardDefaultModel?: string
+  /** Reasoning level a new card starts from; blank = not set. */
+  cardDefaultReasoningEffort?: string
   /** Goal acceptance switch. */
   goalVerification?: boolean
   /** Judge model route for goal acceptance; blank inherits the host default. */
@@ -230,8 +281,13 @@ export const Config: z<ConfigInput, Config> = z.object({
   sessionDefaultPermission: z.union(TASK_PERMISSIONS),
   maxSubtaskDepth: z.number().min(SUBTASK_DEPTH_MIN).max(SUBTASK_DEPTH_MAX).default(DEFAULT_SUBTASK_DEPTH).volatile(),
   sessionPollSeconds: z.number().min(SESSION_POLL_MIN_SECONDS).max(SESSION_POLL_MAX_SECONDS).default(DEFAULT_SESSION_POLL_SECONDS).volatile(),
+  runLaunchWidth: z.number().min(RUN_LAUNCH_WIDTH_MIN).max(RUN_LAUNCH_WIDTH_MAX).default(DEFAULT_RUN_LAUNCH_WIDTH).volatile(),
   teamProvider: z.string().min(1).default(DEFAULT_TEAM_PROVIDER),
   goalRunEnabled: z.boolean().default(false).volatile(),
+  cardDefaultMode: z.string().default('').volatile(),
+  cardDefaultPermission: z.union([...TASK_PERMISSIONS, '']).default('').volatile(),
+  cardDefaultModel: z.string().default('').volatile(),
+  cardDefaultReasoningEffort: z.string().default('').volatile(),
   goalVerification: z.boolean().default(true).volatile(),
   goalVerificationModel: z.string().default('').volatile(),
   goalVerificationReasoningEffort: z.string().default('').volatile(),
@@ -465,6 +521,70 @@ export function resolveLlmRuntime(ctx: Context): LlmRuntime | undefined {
   }
 }
 
+/**
+ * The subset of `sessionController` the board uses to wake a cold persisted
+ * session before running a slash command on it (issue #1861).
+ */
+interface SessionControllerFace {
+  resolveAgent(
+    sessionId: Parameters<Context['agents']['get']>[0],
+  ): Promise<
+    | { readonly agent: Parameters<Context['commands']['execute']>[0] }
+    | { readonly error: { readonly message?: string } }
+  >
+}
+
+/**
+ * Resolve the optional `sessionController` service. Like the tool registry and
+ * the llm runtime, it is read dynamically so capture-only test contexts that do
+ * not mount the full session controller still activate the board.
+ * @param ctx - the plugin context.
+ * @returns the session controller face, or undefined when unavailable.
+ */
+export function resolveSessionController(ctx: Context): SessionControllerFace | undefined {
+  try {
+    const controller = (ctx as { get?: (name: string) => unknown }).get?.('sessionController') as SessionControllerFace | undefined
+    return controller !== undefined && typeof controller.resolveAgent === 'function' ? controller : undefined
+  } catch {
+    return undefined
+  }
+}
+
+/**
+ * Resolve the live Agent for an execution session, resuming a cold persisted
+ * session through `sessionController.resolveAgent` when it is not yet in
+ * `ctx.agents` (issue #1861).
+ *
+ * A fresh run (`session/create`) or a session the browser is currently
+ * following is already in `ctx.agents`, so the fast path returns immediately.
+ * A scheduled or manual reuse of a cold session — one that `session/list`
+ * reports as idle from disk without activating its Agent — is not in
+ * `ctx.agents` when `pinAndPrompt` runs `/permission` ahead of
+ * `session/selectModel` and `session/prompt`; delegating to
+ * `sessionController.resolveAgent` resumes it with its recorded preset and
+ * model-selection state, matching what those gateway endpoints do next.
+ * @param ctx - the plugin context.
+ * @param sessionId - the target execution session id.
+ * @returns the live Agent for `sessionId`.
+ */
+export async function resolveExecutionAgent(
+  ctx: Context,
+  sessionId: Parameters<Context['agents']['get']>[0],
+): Promise<Parameters<Context['commands']['execute']>[0]> {
+  const live = ctx.agents.get(sessionId)
+  if (live !== undefined) return live
+  const controller = resolveSessionController(ctx)
+  if (controller !== undefined) {
+    const resolved = await controller.resolveAgent(sessionId)
+    if ('agent' in resolved && resolved.agent !== undefined) return resolved.agent
+    const detail = 'error' in resolved && typeof resolved.error?.message === 'string' && resolved.error.message !== ''
+      ? `: ${resolved.error.message}`
+      : ''
+    throw new Error(`execution session ${sessionId} is not available${detail}`)
+  }
+  throw new Error(`execution session ${sessionId} is not available`)
+}
+
 /**
  * Activate the board's host half: ledger, routes, cron scheduler, power
  * inhibitor, and the model-facing announcement.
@@ -491,6 +611,12 @@ function applyImpl(ctx: Context, config?: Config): void {
   const maxSubtaskDepth = (): number => readConfigField(config?.maxSubtaskDepth, DEFAULT_SUBTASK_DEPTH)
   /** Current roster-poll cadence in seconds (read live: the settings card edits it in place). */
   const sessionPollSeconds = (): number => readConfigField(config?.sessionPollSeconds, DEFAULT_SESSION_POLL_SECONDS)
+  /**
+   * Current run-launch admission width. Read live on every admission, so the
+   * settings card bounds the next launch of a run that is still queueing without
+   * remounting the row; the Host clamps a hand-edited value into the schema range.
+   */
+  const runLaunchWidth = (): number => readConfigField(config?.runLaunchWidth, DEFAULT_RUN_LAUNCH_WIDTH)
   /**
    * The baseline the permission confirmation gate judges against: the row's own
    * `sessionDefaultPermission` when the deployment pins one, otherwise the Host's
@@ -529,19 +655,40 @@ function applyImpl(ctx: Context, config?: Config): void {
    * executions that start afterwards.
    */
   const goalRunEnabled = (): boolean => readConfigField(config?.goalRunEnabled, DEFAULT_GOAL_RUN)
+  /**
+   * Live reader of the new-card defaults, read at every use like the switch
+   * above: the create dialog prefills from the published snapshot, and each
+   * creating session re-reads them when it submits the create. A blank value
+   * means "not set" and reaches the resolver as an absent target.
+   */
+  const cardDefaults = (): CardDefaults => {
+    const permission = readConfigField<TaskPermission | ''>(config?.cardDefaultPermission, '')
+    return {
+      mode: readConfigField(config?.cardDefaultMode, '').trim() || undefined,
+      permission: isTaskPermission(permission) ? permission : undefined,
+      model: readConfigField(config?.cardDefaultModel, '').trim() || undefined,
+      reasoningEffort: readConfigField(config?.cardDefaultReasoningEffort, '').trim() || undefined,
+    }
+  }
+  // The 0.2.1 gateway requires every request to name the peer it speaks for:
+  // the board calls as the host-local owner, so its peer is minted on this
+  // fiber and aborts with it (see createOwnerPeer).
+  const ownerPeer = createOwnerPeer(ctx)
   const host = new TaskBoardHostService(ctx.typertGateway, {
     workspaceRegistry: ctx.workspaceRegistry,
+    ownerPeer,
     sessionDefaultPermission,
     maxSubtaskDepth: maxSubtaskDepth(),
     goalRunEnabled,
+    runLaunchWidth,
+    cardDefaults,
     verificationSettings,
     verificationCatalog,
     timers: resolveHostTimers(ctx),
     team: buildTeamDispatcher(ctx, config?.teamProvider ?? DEFAULT_TEAM_PROVIDER),
     commandDispatcher: {
       async execute(sessionId, line, signal) {
-        const agent = ctx.agents.get(sessionId)
-        if (agent === undefined) throw new Error(`execution session ${sessionId} is not available`)
+        const agent = await resolveExecutionAgent(ctx, sessionId)
         return (await ctx.commands.execute(agent, line, [], signal))?.result
       },
     },