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

package/src/index.ts

@@ -18,10 +18,24 @@ 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,
+  VERIFICATION_BUDGET_MAX_SECONDS,
+  VERIFICATION_BUDGET_MIN_SECONDS,
+  VERIFICATION_CALL_TIMEOUT_MAX_SECONDS,
+  VERIFICATION_CALL_TIMEOUT_MIN_SECONDS,
+  verificationBudgetMs,
+  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'
@@ -88,12 +102,73 @@ export interface Config {
    * of the root task opens, so the ceiling is deliberately small.
    */
   maxSubtaskDepth?: Volatile<number>
+  /**
+   * How often, in seconds, the Host re-reads the DSH session roster while the
+   * board has something to reconcile: a running card, an open execution, or an
+   * active provider extension. An idle board with none of those does not poll
+   * 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;
    * only team-mode runs use it.
    */
   teamProvider?: string
+  /**
+   * GLOBAL native /goal switch (default OFF), the master control over whether
+   * this board starts a run with dsh's built-in /goal at all. A run uses native
+   * /goal only when THIS is on AND the task's own `goalRun` is not off; while
+   * it is off every task runs one plain turn.
+   *
+   * The value is frozen when an execution starts, so toggling it only affects
+   * executions that begin afterwards and never re-writes a task's stored
+   * `goalRun` preference. A run that consequently does not execute native
+   * /goal is marked as such (its acceptance applicability is `goal-disabled`)
+   * and is never reported as a passed goal acceptance or failed for lacking a
+   * completion call. Independent of `goalVerification`; acceptance governs the
+   * completing call of a goal-form run, this switch governs whether the run
+   * 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
@@ -119,6 +194,23 @@ export interface Config {
    * sent, and the fallback to the model's own default is reported.
    */
   goalVerificationReasoningEffort?: Volatile<string>
+  /**
+   * Ceiling of ONE judge request of a goal acceptance, in seconds
+   * (30..600, default 150). One acceptance issues six judge requests (three
+   * criteria times two rounds), so a ceiling that is too small turns a slow but
+   * healthy judge route into a wall of timeouts, and every timeout was charged
+   * as an acceptance anomaly. Raise it for a reasoning model reading a long
+   * trace.
+   */
+  goalVerificationCallTimeoutSeconds?: Volatile<number>
+  /**
+   * Total ceiling of ONE goal acceptance attempt, in seconds (120..1800,
+   * default eight times the per-call default). Keep it at or above
+   * `goalVerificationCallTimeoutSeconds` times six or an acceptance can never
+   * finish: the attempt then ends early with a budget stop that judges nothing
+   * and spends no acceptance budget.
+   */
+  goalVerificationBudgetSeconds?: Volatile<number>
 }
 
 /**
@@ -152,14 +244,32 @@ export interface ConfigInput {
   sessionDefaultPermission?: TaskPermission
   /** Subtask depth limit, 1..3. */
   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. */
   goalVerificationModel?: string
   /** Judge reasoning effort; blank inherits the host default. */
   goalVerificationReasoningEffort?: string
+  /** Ceiling of one judge request of a goal acceptance, in seconds. */
+  goalVerificationCallTimeoutSeconds?: number
+  /** Total ceiling of one goal acceptance attempt, in seconds. */
+  goalVerificationBudgetSeconds?: number
 }
 
 export const Config: z<ConfigInput, Config> = z.object({
@@ -170,15 +280,31 @@ export const Config: z<ConfigInput, Config> = z.object({
   proxyTokenEnv: z.string().min(1).default(DEFAULT_PROXY_TOKEN_ENV),
   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(),
+  goalVerificationCallTimeoutSeconds: z.number().min(VERIFICATION_CALL_TIMEOUT_MIN_SECONDS).max(VERIFICATION_CALL_TIMEOUT_MAX_SECONDS).default(DEFAULT_VERIFICATION_CALL_TIMEOUT_SECONDS).volatile(),
+  goalVerificationBudgetSeconds: z.number().min(VERIFICATION_BUDGET_MIN_SECONDS).max(VERIFICATION_BUDGET_MAX_SECONDS).default(DEFAULT_VERIFICATION_BUDGET_SECONDS).volatile(),
 })
 
 /** Schema default for the goal-acceptance switch, re-read for hand-built contexts. */
 export const DEFAULT_GOAL_VERIFICATION = true
 
+/**
+ * Schema default for the GLOBAL native-/goal switch, re-read for hand-built
+ * contexts. Deliberately false: a deployment that never configured it (and
+ * every card written before the option existed) runs plain single turns.
+ */
+export const DEFAULT_GOAL_RUN = false
+
 declare module '@deepseek-ai/cordis' {
   interface Events {
     /**
@@ -395,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.
@@ -419,6 +609,14 @@ function applyImpl(ctx: Context, config?: Config): void {
   const preventIdleSleep = (): boolean => readConfigField(config?.preventIdleSleep, false)
   /** Current subtask depth limit (read live: the settings card edits it in place). */
   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
@@ -435,6 +633,15 @@ function applyImpl(ctx: Context, config?: Config): void {
     model: readConfigField(config?.goalVerificationModel, ''),
     reasoningEffort: readConfigField(config?.goalVerificationReasoningEffort, ''),
   })
+  /**
+   * The acceptance time ceilings, read live: raising one must unblock a card
+   * whose acceptance is stuck on a slow judge route without a remount, so
+   * these deliberately are NOT frozen into the per-execution contract.
+   */
+  const verificationCallTimeoutMsLive = (): number =>
+    verificationCallTimeoutMs(readConfigField(config?.goalVerificationCallTimeoutSeconds, DEFAULT_VERIFICATION_CALL_TIMEOUT_SECONDS))
+  const verificationBudgetMsLive = (): number =>
+    verificationBudgetMs(readConfigField(config?.goalVerificationBudgetSeconds, DEFAULT_VERIFICATION_BUDGET_SECONDS))
   // The catalog reader needs the service, and the service needs the reader;
   // the reader only runs after start(), so a late holder is enough.
   let hostForCatalog: TaskBoardHostService | undefined
@@ -442,18 +649,46 @@ function applyImpl(ctx: Context, config?: Config): void {
     const runner = hostForCatalog?.runner
     return runner === undefined ? undefined : normalizeCatalog(await runner.modelCatalog())
   }
+  /**
+   * Live reader of the GLOBAL native-/goal switch. The service calls it exactly
+   * once per execution and carries the value, so a settings edit only reaches
+   * 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
       },
     },
@@ -461,7 +696,7 @@ function applyImpl(ctx: Context, config?: Config): void {
   hostForCatalog = host
   // Configuration before start(): a disabled row must not take the first
   // scheduler tick, which would roll schedules the board is not running.
-  host.setConfiguration(enabled(), preventIdleSleep())
+  host.setConfiguration(enabled(), preventIdleSleep(), sessionPollSeconds())
   host.start()
 
   // External providers. The board publishes its registration service so any
@@ -543,6 +778,8 @@ function applyImpl(ctx: Context, config?: Config): void {
         // deployment records it; the acceptance degrades to the trajectory alone
         // when it does not.
         workspaceChanges: () => probeWorkspaceChanges(ctx),
+        callTimeoutMs: verificationCallTimeoutMsLive,
+        budgetMs: verificationBudgetMsLive,
         logger: {
           warn: (message: string, ...rest: unknown[]) => {
             const logger = (ctx as { logger?: { warn?: (...args: unknown[]) => void } }).logger
@@ -586,7 +823,7 @@ function applyImpl(ctx: Context, config?: Config): void {
   }, 'task-board: host ledger, scheduler, and routes')
 
   let disposeSection: (() => void) | undefined
-  let applied: { enabled: boolean; announceToAgent: boolean; preventIdleSleep: boolean; maxSubtaskDepth: number } | undefined
+  let applied: { enabled: boolean; announceToAgent: boolean; preventIdleSleep: boolean; maxSubtaskDepth: number; sessionPollSeconds: number } | undefined
 
   // Apply the current values to the host service and the announcement. A
   // commit that changes nothing visible is a no-op, so following a coarse
@@ -594,13 +831,19 @@ function applyImpl(ctx: Context, config?: Config): void {
   // under one disposer: re-registering first tears the old one down so a
   // duplicate-name registration never throws.
   const sync = (): void => {
-    const next = { enabled: enabled(), announceToAgent: announceToAgent(), preventIdleSleep: preventIdleSleep(), maxSubtaskDepth: maxSubtaskDepth() }
-    if (applied !== undefined && applied.enabled === next.enabled && applied.announceToAgent === next.announceToAgent && applied.preventIdleSleep === next.preventIdleSleep && applied.maxSubtaskDepth === next.maxSubtaskDepth) {
+    const next = {
+      enabled: enabled(),
+      announceToAgent: announceToAgent(),
+      preventIdleSleep: preventIdleSleep(),
+      maxSubtaskDepth: maxSubtaskDepth(),
+      sessionPollSeconds: sessionPollSeconds(),
+    }
+    if (applied !== undefined && applied.enabled === next.enabled && applied.announceToAgent === next.announceToAgent && applied.preventIdleSleep === next.preventIdleSleep && applied.maxSubtaskDepth === next.maxSubtaskDepth && applied.sessionPollSeconds === next.sessionPollSeconds) {
       return
     }
     applied = next
     host.ledger.setMaxSubtaskDepth(next.maxSubtaskDepth)
-    host.setConfiguration(next.enabled, next.preventIdleSleep)
+    host.setConfiguration(next.enabled, next.preventIdleSleep, next.sessionPollSeconds)
     setToolsEnabled(next.enabled)
     if (disposeSection !== undefined) {
       disposeSection()