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

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[]
 }
@@ -60,6 +64,17 @@ function isDefinitionWithdrawn(error: unknown): boolean {
 
 const SERVICE_UNAVAILABLE_ATTEMPTS = 5
 const SERVICE_UNAVAILABLE_BACKOFF_MS = 2_000
+/**
+ * Largest number of history pages one inspection walks back. A session whose
+ * window is wider than this cannot be resolved from its log, which the caller
+ * treats as an unreadable history rather than as pending work.
+ */
+const HISTORY_PAGE_LIMIT = 100
+
+/** One-line text of a gateway or stream failure, for a decideable reason. */
+function failureText(error: unknown): string {
+  return error instanceof Error ? error.message : String(error)
+}
 
 function delay(ms: number): Promise<void> {
   return new Promise(resolve => { setTimeout(resolve, ms) })
@@ -87,7 +102,14 @@ export interface SessionCommandDispatcher {
 }
 
 export type ExecutionInspection =
-  | { outcome: 'pending' }
+  /**
+   * No verdict yet. `unreadable` separates "the work may still be in progress"
+   * from "this session's history could not be read at all": a reader failure is
+   * not progress, and the caller decides how long to keep waiting before it
+   * reports the execution as undeterminable instead of holding a card open
+   * forever.
+   */
+  | { outcome: 'pending'; unreadable?: true; reason?: string }
   | { outcome: 'succeeded' }
   | { outcome: 'failed'; error: string }
   | { outcome: 'cancelled'; error: string }
@@ -136,6 +158,13 @@ export interface PromptContext {
   peers?: readonly PromptPeer[]
   /** 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).
+   */
+  schedule?: { triggeredAt: number; timeZone: string; cron: string }
 }
 
 /**
@@ -147,13 +176,27 @@ function peerPromptPreamble(context: PromptContext): string | undefined {
   const peers = context.peers ?? []
   if (peers.length === 0) return undefined
   if (context.team === true) {
-    const lines = peers.map(peer => `- ${escapeProvenanceDelimiter(peer.title)}（teammate: ${peer.name ?? teammateName(peer.title, peer.id)}）`)
+    const lines = peers.map(peer => `- ${escapeProvenanceDelimiter(peer.title)}（teammate: ${peer.name ?? teammateName(peer.title, peer.id, peer.id)}）`)
     return `本任务是 Agent Team 的 Lead：本次运行不额外开启独立会话，以下 ${peers.length} 个子任务成员已在本会话中作为 teammate 启动。用 list_agents / send_message / wait_agent 协调它们，用任务看板工具读写它们在看板上的卡片：\n${lines.join('\n')}`
   }
   const lines = peers.map(peer => `- ${escapeProvenanceDelimiter(peer.title)}（任务 ${peer.id}）`)
   return `本次运行同时并发开启 ${peers.length} 个独立 DSH 会话执行下列子任务成员（可用 task_board_* 工具查看它们的进度）：\n${lines.join('\n')}`
 }
 
+/**
+ * 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
+ * scheduler fires on a wall clock in a specific IANA zone, which is not
+ * necessarily the zone of whatever session the run lands in.
+ */
+function schedulePromptPreamble(context: PromptContext): string | undefined {
+  const schedule = context.schedule
+  if (schedule === undefined) return undefined
+  const stamp = new Date(schedule.triggeredAt).toISOString()
+  return `本次执行由任务看板的定时规则自动触发：触发时间 ${stamp}（UTC），规则时区 ${schedule.timeZone}，cron 表达式 ${schedule.cron}。需要判断「今天」「现在」或计算时间窗口时，以该时区的触发时间为准。`
+}
+
 /**
  * Build the execution prompt for one task.
  * @param task - the task being launched.
@@ -167,11 +210,14 @@ export function promptText(task: TaskRecord, context: PromptContext = {}): strin
     ? undefined
     : `交接包引用（来自任务看板续接卡片，冻结于 ${new Date(handover.bundledAt).toISOString()}）：\n${handover.references.map(reference => `- ${reference}`).join('\n')}`
   // Tag prompts come first: they are the run's standing context (business line,
-  // output location), the handover preamble is a per-card note, and the task
-  // body is the instruction itself.
+  // output location), the handover preamble is a per-card note, the scheduled
+  // section states why this run exists, and the task body is the instruction.
   const tagPreamble = tagPromptPreamble(task)
+  const handoverSection = handoverPreamble
+  const schedulePreamble = schedulePromptPreamble(context)
   const runPreamble = peerPromptPreamble(context)
-  const preambles = [tagPreamble, handoverPreamble, runPreamble].filter((part): part is string => part !== undefined)
+  const preambles = [tagPreamble, handoverSection, schedulePreamble, runPreamble]
+    .filter((part): part is string => part !== undefined)
   const preamble = preambles.length === 0 ? undefined : preambles.join('\n\n')
   const freeze = task.freeze
   if (freeze === undefined) {
@@ -182,6 +228,27 @@ export function promptText(task: TaskRecord, context: PromptContext = {}): strin
   return preamble === undefined ? declaration : `${preamble}\n\n${declaration}`
 }
 
+/**
+ * The parts of an objective the built-in `/goal` command reads as an operation
+ * rather than as an objective: an exact `clear`/`pause`/`resume`/`edit`
+ * (case-insensitive) and a leading `edit <objective>`.
+ */
+const GOAL_COMMAND_KEYWORD = /^(?:clear|pause|resume|edit)$|^edit\s/i
+
+/**
+ * Build the objective the built-in `/goal` command receives. A prompt whose
+ * text would be read as a goal operation is prefixed with a neutral label: the
+ * instruction stays intact, and the command arms an objective instead of
+ * clearing, pausing, or editing an unrelated goal (or refusing for a missing
+ * one).
+ * @param prompt - the composed execution prompt.
+ * @returns the objective text for `/goal <objective>`.
+ */
+export function goalObjective(prompt: string): string {
+  const text = prompt.trim()
+  return GOAL_COMMAND_KEYWORD.test(text) ? `Goal: ${text}` : text
+}
+
 /**
  * Build the tag section of the execution prompt (issue #1521). Only tags with
  * a non-blank `promptPrefix` contribute; a task whose tags are all bare names
@@ -235,6 +302,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 }
 }
@@ -265,6 +334,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,
@@ -275,10 +356,14 @@ 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 } = {}): 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
 
@@ -306,8 +391,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)
       } catch (error) {
         throw new SessionLaunchError(reused, error)
       }
@@ -318,9 +407,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)
     } catch (error) {
       throw new SessionLaunchError(sessionId, error)
     }
@@ -365,6 +455,7 @@ export class HostExecutionRunner {
     task: TaskRecord,
     permission: TaskPermission | undefined,
     context: PromptContext = {},
+    onGoalArmed?: (armed: boolean) => void,
   ): Promise<void> {
     if (permission !== undefined) {
       if (this.commands === undefined) throw new Error('permission command dispatcher is unavailable')
@@ -393,6 +484,103 @@ export class HostExecutionRunner {
       mode: 'queue' as const,
       content: [{ type: 'text' as const, text: promptText(task, context) }],
     })
+    const armed = await this.armGoal(sessionId, task, context)
+    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
+    }
+  }
+
+  /**
+   * Arm dsh's built-in goal on the session. The task prompt is queued FIRST, so
+   * the session's first turn carries the instruction verbatim; `/goal
+   * <objective>` then turns the same text into a persistent objective, and
+   * 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.
+   * 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.
+   */
+  private async armGoal(sessionId: ExecutionSessionId, task: TaskRecord, context: PromptContext): Promise<boolean> {
+    if (task.goalRun === false) return false
+    if (this.commands === undefined) {
+      console.warn('[dsh-task-board] no command dispatcher is available; task ' + task.id + ' runs without /goal')
+      return false
+    }
+    try {
+      const command = await this.commands.execute(
+        sessionId,
+        '/goal ' + goalObjective(promptText(task, context)),
+        AbortSignal.timeout(30_000),
+      )
+      if (command === undefined) {
+        console.warn('[dsh-task-board] /goal was not acknowledged for session ' + sessionId + '; the run continues as a plain turn')
+        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
+    }
+  }
+
+  /**
+   * The verdict an armed dsh goal imposes on an otherwise completed turn.
+   *
+   * A goal run is one session working many automatic continuation rounds:
+   * dsh's goal-round driver queues the next round whenever the agent goes
+   * idle, so the first completed `turn/end` is not the execution's result.
+   * Settling there would leave the card in `done` while the session keeps
+   * working, and a scheduled task would fire a second, concurrent session.
+   * The session projection is the authority: an `active` goal keeps the
+   * execution pending, a `blocked` goal fails it with the recorded reason, and
+   * any other phase (complete, paused, or no goal at all) leaves the turn
+   * verdict in place.
+   *
+   * An unreadable projection falls back to that turn verdict: a cohort whose
+   * gateway withdrew `session/projections` must not hang every execution.
+   */
+  private async goalVerdict(sessionId: string): Promise<ExecutionInspection | undefined> {
+    let projections: { values?: { goal?: unknown } } | null
+    try {
+      projections = await this.invoke('session', 'projections', { sessionId }) as { values?: { goal?: unknown } } | null
+    } catch (error) {
+      console.warn('[dsh-task-board] session/projections failed while reading the goal phase; settling from the turn result', error)
+      return undefined
+    }
+    const goal = projections?.values?.goal
+    if (goal === undefined || goal === null) return undefined
+    const view = (goal as { goal?: { phase?: unknown; blockedReason?: { message?: unknown } } }).goal
+    if (view?.phase === 'active') return { outcome: 'pending' }
+    if (view?.phase === 'blocked') {
+      const message = view.blockedReason?.message
+      return {
+        outcome: 'failed',
+        error: 'goal is blocked: ' + (typeof message === 'string' && message !== '' ? message : 'no reason recorded'),
+      }
+    }
+    return undefined
   }
 
   async listRunning(): Promise<{ known: true; count: number; items: SessionSummary[] } | { known: false }> {
@@ -424,8 +612,17 @@ export class HostExecutionRunner {
     }
   }
 
-  /** Resolve an execution outcome from the session list and bounded history pages. */
-  async inspect(sessionId: string, startedAt = 0, sessions?: readonly SessionSummary[]): Promise<ExecutionInspection> {
+  /**
+   * Resolve an execution outcome from the session list and bounded history pages.
+   * @param sessionId - the session the execution runs in.
+   * @param startedAt - instant the execution opened; earlier events are not its own.
+   * @param sessions - roster from the caller's own poll, when it already has one.
+   * @param options.whileRunning - read the first completed turn even while the
+   *   roster reports the session as running. A durable Agent Teams teammate
+   *   stays alive after its turn ends, so `running` never clears for it and the
+   *   turn it completed is the only verdict it will ever expose.
+   */
+  async inspect(sessionId: string, startedAt = 0, sessions?: readonly SessionSummary[], options: { whileRunning?: boolean } = {}): Promise<ExecutionInspection> {
     let items: readonly SessionSummary[]
     if (sessions !== undefined) {
       items = sessions
@@ -455,7 +652,7 @@ export class HostExecutionRunner {
       this.scanMemos.delete(sessionId)
       return { outcome: 'cancelled', error: 'execution session no longer exists' }
     }
-    if (summary.running) return { outcome: 'pending' }
+    if (summary.running && options.whileRunning !== true) return { outcome: 'pending' }
 
     let opening: { cursor: number; records: readonly SessionHistoryRecord[]; hasMore: boolean }
     try {
@@ -465,12 +662,12 @@ export class HostExecutionRunner {
       if (typeof iterator.return === 'function') await iterator.return()
       const follow = next.done === true ? undefined : next.value as { type?: string; cursor?: number; records?: readonly SessionHistoryRecord[]; hasMore?: boolean }
       if (follow === undefined || follow.type !== 'snapshot' || typeof follow.cursor !== 'number' || follow.records === undefined || typeof follow.hasMore !== 'boolean') {
-        return { outcome: 'pending' }
+        return { outcome: 'pending', unreadable: true, reason: 'session/follow returned no opening frame' }
       }
       opening = { cursor: follow.cursor, records: follow.records, hasMore: follow.hasMore }
     } catch (error) {
       console.warn('[dsh-task-board] session/follow failed during execution inspection; keeping the outcome pending', error)
-      return { outcome: 'pending' }
+      return { outcome: 'pending', unreadable: true, reason: 'session/follow failed: ' + failureText(error) }
     }
     const openingEvents = opening.records.map(record => ({ event: recordEvent(record) }))
     const newestSeq = openingEvents.reduce<number | undefined>((newest, entry) => newest === undefined ? entry.event.seq : Math.max(newest, entry.event.seq), undefined)
@@ -478,7 +675,7 @@ export class HostExecutionRunner {
     const events: Array<{ event: { type: string; seq: number; time: number; data: unknown } }> = [...openingEvents]
     let beforeSeq: number | undefined
     let reachedExecutionBoundary = !opening.hasMore
-    for (let page = 0; page < 100 && !reachedExecutionBoundary; page += 1) {
+    for (let page = 0; page < HISTORY_PAGE_LIMIT && !reachedExecutionBoundary; page += 1) {
       let history: SessionPage
       try {
         history = await this.invoke('session', 'page', {
@@ -489,7 +686,7 @@ export class HostExecutionRunner {
         }) as SessionPage
       } catch (error) {
         console.warn('[dsh-task-board] session/page failed during execution inspection; keeping the outcome pending', error)
-        return { outcome: 'pending' }
+        return { outcome: 'pending', unreadable: true, reason: 'session/page failed: ' + failureText(error) }
       }
       const pageEntries = pageEvents(history)
       events.push(...pageEntries)
@@ -502,7 +699,9 @@ export class HostExecutionRunner {
       if (oldestSeq === undefined || oldestSeq === beforeSeq) return { outcome: 'pending' }
       beforeSeq = oldestSeq
     }
-    if (!reachedExecutionBoundary) return { outcome: 'pending' }
+    if (!reachedExecutionBoundary) {
+      return { outcome: 'pending', unreadable: true, reason: 'history scan did not reach the execution start within ' + HISTORY_PAGE_LIMIT + ' pages' }
+    }
     const turnEnd = events
       .filter(entry => entry.event.type === 'turn/end' && (startedAt <= 0 || entry.event.time >= startedAt))
       .sort((a, b) => a.event.seq - b.event.seq)[0]
@@ -512,7 +711,7 @@ export class HostExecutionRunner {
     }
     this.scanMemos.delete(sessionId)
     const reason = nonCompletedTurnEnd(turnEnd.event.data)
-    if (reason === undefined) return { outcome: 'succeeded' }
+    if (reason === undefined) return await this.goalVerdict(sessionId) ?? { outcome: 'succeeded' }
     // `error` keeps its historical wording; every other non-completed reason
     // (aborted / blocked / max-tokens / interrupted) now reports instead of
     // silently counting as success.