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

package/src/host-routes.ts

@@ -208,7 +208,7 @@ export function makeTaskBoardRoutes(
         if (parsed.action.kind !== 'import' && Buffer.byteLength(body.raw) > ACTION_LIMIT) {
           return writeJson(res, 413, { ok: false, error: 'body-too-large' }, { 'cache-control': 'no-store' })
         }
-        writeJson(res, 200, service.apply(parsed.requestId, parsed.action, parsed.initiator), { 'cache-control': 'no-store' })
+        writeJson(res, 200, await service.apply(parsed.requestId, parsed.action, parsed.initiator), { 'cache-control': 'no-store' })
       } catch (error) {
         const message = error instanceof Error ? error.message : String(error)
         writeJson(res, message === 'body-too-large' ? 413 : 400, { ok: false, error: message }, { 'cache-control': 'no-store' })
@@ -289,5 +289,18 @@ export function makeTaskBoardRoutes(
       }
     },
   }
-  return [state, action, events, parse]
+  const verification: WebRoute = {
+    kind: 'exact',
+    path: `${TASK_BOARD_API_PREFIX}/verification`,
+    handler: async (req, res): Promise<void> => {
+      if (req.method !== 'GET') return writeJson(res, 405, { ok: false, error: 'method-not-allowed' }, { 'cache-control': 'no-store' })
+      if (!guard(req, res)) return
+      try {
+        writeJson(res, 200, await service.verificationOptions(), { 'cache-control': 'no-store' })
+      } catch (error) {
+        writeJson(res, 500, { ok: false, error: error instanceof Error ? error.message : String(error) }, { 'cache-control': 'no-store' })
+      }
+    },
+  }
+  return [state, action, events, parse, verification]
 }

package/src/host-runner.ts

@@ -3,9 +3,13 @@ import type { SessionAddress, SessionHistoryRecord, SessionListValue, SessionPag
 import type { CommandResult } from '@deepseek-ai/dsh-commands/types'
 import type { Workspace } from '@deepseek-ai/dsh-workspace/types'
 import { teammateName } from './core/subtask.ts'
+import { mostRecentWorkspaceId } from './core/workspace-target.ts'
 import type { TaskPermission, TaskRecord } from './core/tasks.ts'
 
-/** Host services needed to validate a task's workspace before creating a session. */
+/**
+ * Host services needed to validate a task's workspace before creating a
+ * session, and to resolve the workspace an unpinned card runs in.
+ */
 export interface TaskBoardWorkspaceRegistry {
   list(): readonly Workspace[]
 }
@@ -155,12 +159,12 @@ export interface PromptContext {
   /** True when those members run as teammates inside this session (Team Lead). */
   team?: boolean
   /**
-   * Scheduled-run provenance: the instant the cron rule actually fired and the
-   * IANA zone its wall clock was read in. Present only for a cron-triggered
-   * run, so the model can resolve an unqualified date in the run's own terms
-   * instead of guessing from the Host clock (issue #1722).
+   * Scheduled-run provenance: the instant the rule actually fired, its kind,
+   * and the IANA zone its wall clock was read in. Present only for a
+   * timer-triggered run, so the model can resolve an unqualified date in the
+   * run's own terms instead of guessing from the Host clock (issue #1722).
    */
-  schedule?: { triggeredAt: number; timeZone: string; cron: string }
+  schedule?: { triggeredAt: number; timeZone: string; mode: 'cron' | 'once'; cron?: string }
 }
 
 /**
@@ -180,16 +184,20 @@ function peerPromptPreamble(context: PromptContext): string | undefined {
 }
 
 /**
- * The scheduled-run section: this execution was triggered by the card's cron
- * rule rather than by a person. It states the firing instant, the rule's zone,
- * and the rule text, so the run's own clock is unambiguous — the board's
+ * The scheduled-run section: this execution was triggered by the card's
+ * schedule rather than by a person. It states the firing instant, the rule's
+ * zone, and the rule text, so the run's own clock is unambiguous — the board's
  * scheduler fires on a wall clock in a specific IANA zone, which is not
- * necessarily the zone of whatever session the run lands in.
+ * necessarily the zone of whatever session the run lands in. A one-shot says
+ * so explicitly, so the run does not expect a recurrence.
  */
 function schedulePromptPreamble(context: PromptContext): string | undefined {
   const schedule = context.schedule
   if (schedule === undefined) return undefined
   const stamp = new Date(schedule.triggeredAt).toISOString()
+  if (schedule.mode === 'once') {
+    return `本次执行由任务看板的单次定时自动触发：计划时间 ${stamp}（UTC），时区 ${schedule.timeZone}。这是一次性计划，本次执行之后该卡片不会再自动执行。需要判断「今天」「现在」或计算时间窗口时，以该时区的触发时间为准。`
+  }
   return `本次执行由任务看板的定时规则自动触发：触发时间 ${stamp}（UTC），规则时区 ${schedule.timeZone}，cron 表达式 ${schedule.cron}。需要判断「今天」「现在」或计算时间窗口时，以该时区的触发时间为准。`
 }
 
@@ -298,6 +306,8 @@ function nonCompletedTurnEnd(data: unknown): string | undefined {
  */
 function invokeWireArgs(namespace: string, method: string, request: Record<string, unknown>): Record<string, unknown> {
   if (namespace === 'agentPresets' && method === 'list') return {}
+  // session/modelCatalog declares zero parameters, so its args must be {}.
+  if (namespace === 'session' && method === 'modelCatalog') return {}
   if (namespace === 'session' && method === 'list') return { _request: request }
   return { request }
 }
@@ -328,6 +338,18 @@ export class HostExecutionRunner {
     return this.gateway.stream({ namespace, method, args: { request }, ...(signal === undefined ? {} : { signal }) })
   }
 
+  /**
+   * The workspace an unpinned run lands in: the deployment's most recently used
+   * one. Undefined when the deployment serves no workspace registry or has
+   * registered none yet; the launch then keeps the "let the Host decide" shape,
+   * which is the only remaining path to the Host's own working directory.
+   * @returns the workspace id to create the session in, when one is known.
+   */
+  private recentWorkspaceId(): string | undefined {
+    if (this.workspaceRegistry === undefined) return undefined
+    return mostRecentWorkspaceId(this.workspaceRegistry.list())
+  }
+
   /**
    * Launch one execution. Without `options.reuseSessionId` a fresh session is
    * created, renamed, pinned, and prompted (the historical contract). With it,
@@ -338,10 +360,31 @@ export class HostExecutionRunner {
    * @param options - optional session to continue in.
    * @returns the session id the execution runs in.
    */
-  async launch(task: TaskRecord, options: { reuseSessionId?: string; promptContext?: PromptContext } = {}): Promise<string> {
+  async launch(task: TaskRecord, options: {
+    reuseSessionId?: string
+    promptContext?: PromptContext
+    onSession?: (sessionId: string) => void
+    onGoalArmed?: (armed: boolean) => void
+    /**
+     * GLOBAL native /goal switch, resolved by the caller ONCE per execution and
+     * carried here so the decision is frozen for this launch.
+     *
+     * Frozen deliberately: a settings edit made while the run is in flight must
+     * not arm, disarm or otherwise change the goal/acceptance contract of a run
+     * already running. Absent means off — the default for every deployment that
+     * never touched the switch, including cards written before the option
+     * existed. A plain single turn is what an off switch produces; the task-level
+     * `goalRun` still applies on top of it (both must ASK for a goal).
+     */
+    goalEnabled?: boolean
+  } = {}): Promise<string> {
     // A handover bundle overrides the legacy pin fields: the bundle is the
-    // authoritative execution triplet for a continuation card (issue #5).
-    const workspaceId = task.handover?.workspaceId ?? task.workspaceId
+    // authoritative execution triplet for a continuation card (issue #5). A
+    // card that pins nothing is resolved to the deployment's most recently used
+    // workspace instead of being left to `session.create`, whose own fallback is
+    // the Host process working directory (the desktop app's profile directory) —
+    // never the project the user was in when the card was written.
+    const workspaceId = task.handover?.workspaceId ?? task.workspaceId ?? this.recentWorkspaceId()
     const mode = task.handover?.mode ?? task.mode
     const permission = task.handover?.permission ?? task.permission
 
@@ -369,8 +412,12 @@ export class HostExecutionRunner {
         // whose session was composed from a different preset now fails closed
         // instead of silently running under the wrong composition, matching
         // the fresh branch's `agentPreset` assertion (issue #1708).
+        // Report the session before anything is queued into it, so the board
+        // can bind the execution first and a completion claim can never arrive
+        // at the gate without its binding.
+        options.onSession?.(reused)
         await this.assertReusedPreset(reused, mode)
-        await this.pinAndPrompt(reused, task, permission, options.promptContext)
+        await this.pinAndPrompt(reused, task, permission, options.promptContext, options.onGoalArmed, options.goalEnabled === true)
       } catch (error) {
         throw new SessionLaunchError(reused, error)
       }
@@ -381,9 +428,10 @@ export class HostExecutionRunner {
       ...(mode === undefined ? {} : { agentPreset: mode }),
     }) as { sessionId: ExecutionSessionId }
     const sessionId = created.sessionId
+    options.onSession?.(sessionId)
     try {
       await this.invoke('session', 'rename', { sessionId, title: task.title })
-      await this.pinAndPrompt(sessionId, task, permission, options.promptContext)
+      await this.pinAndPrompt(sessionId, task, permission, options.promptContext, options.onGoalArmed, options.goalEnabled === true)
     } catch (error) {
       throw new SessionLaunchError(sessionId, error)
     }
@@ -428,6 +476,8 @@ export class HostExecutionRunner {
     task: TaskRecord,
     permission: TaskPermission | undefined,
     context: PromptContext = {},
+    onGoalArmed?: (armed: boolean) => void,
+    goalEnabled = false,
   ): Promise<void> {
     if (permission !== undefined) {
       if (this.commands === undefined) throw new Error('permission command dispatcher is unavailable')
@@ -456,7 +506,25 @@ export class HostExecutionRunner {
       mode: 'queue' as const,
       content: [{ type: 'text' as const, text: promptText(task, context) }],
     })
-    await this.armGoal(sessionId, task, context)
+    const armed = await this.armGoal(sessionId, task, context, goalEnabled)
+    onGoalArmed?.(armed)
+  }
+
+  /**
+   * Read the host's model catalog: the default route an unconfigured session
+   * starts at, and each provider's models with the reasoning metadata its
+   * adapter exposes. The acceptance settings card and the frozen contract both
+   * resolve against it, so "inherit host" means the host's own configuration
+   * rather than a session's or a card's pinned model.
+   * @returns the raw catalog value, or undefined when this cohort serves none.
+   */
+  async modelCatalog(): Promise<unknown> {
+    try {
+      return await this.invoke('session', 'modelCatalog', {})
+    } catch (error) {
+      console.warn('[dsh-task-board] session/modelCatalog failed; the acceptance settings fall back to the configured route', error)
+      return undefined
+    }
   }
 
   /**
@@ -466,17 +534,28 @@ export class HostExecutionRunner {
    * dsh's goal-round driver keeps starting continuation rounds until the agent
    * marks it complete (see {@link goalVerdict} for how the run settles).
    *
-   * Opt-out: a task whose `goalRun` is an explicit false runs one plain turn.
+   * Two switches gate the arming, and BOTH must ask for it:
+   * - the GLOBAL native-/goal switch (`goalEnabled`, default OFF), frozen when
+   *   this execution started; and
+   * - the task's own `goalRun` (absent means off, only an explicit true opts
+   *   the card into a goal run).
+   *
    * A refusal (no command dispatcher, no `/goal` command in this cohort, an
-   * objective the command rejects) is reported and the run continues as that
-   * plain turn: the task was asked to run, and a missing goal mode must not
-   * lose the work.
+   * objective the command rejects) is reported and the run continues as a plain
+   * turn: the task was asked to run, and a missing goal mode must not lose the
+   * work.
+   * @param sessionId - the session to arm in.
+   * @param task - the task being run.
+   * @param context - the run's prompt context.
+   * @param goalEnabled - the GLOBAL switch, frozen for this execution.
+   * @returns whether `/goal` was really armed.
    */
-  private async armGoal(sessionId: ExecutionSessionId, task: TaskRecord, context: PromptContext): Promise<void> {
-    if (task.goalRun === false) return
+  private async armGoal(sessionId: ExecutionSessionId, task: TaskRecord, context: PromptContext, goalEnabled: boolean): Promise<boolean> {
+    if (!goalEnabled) return false
+    if (task.goalRun !== true) return false
     if (this.commands === undefined) {
       console.warn('[dsh-task-board] no command dispatcher is available; task ' + task.id + ' runs without /goal')
-      return
+      return false
     }
     try {
       const command = await this.commands.execute(
@@ -486,13 +565,16 @@ export class HostExecutionRunner {
       )
       if (command === undefined) {
         console.warn('[dsh-task-board] /goal was not acknowledged for session ' + sessionId + '; the run continues as a plain turn')
-        return
+        return false
       }
       if (command.kind !== 'success') {
         console.warn('[dsh-task-board] /goal was refused for session ' + sessionId + ': ' + (command.text ?? 'no reason reported') + '; the run continues as a plain turn')
+        return false
       }
+      return true
     } catch (error) {
       console.warn('[dsh-task-board] could not arm /goal on session ' + sessionId + '; the run continues as a plain turn', error)
+      return false
     }
   }