@linxin666/dsh-client-ui-task-board 0.1.16 → 0.1.17

package/src/core/controller.ts

@@ -22,7 +22,7 @@ import {
 import { applyCreateTask } from './use-cases/task-create.ts'
 import { applyDeleteTask } from './use-cases/task-delete.ts'
 import { applyScheduleNextRun as applyScheduleRollForward, applySetSchedule } from './use-cases/task-schedule.ts'
-import { applyUpdateTask } from './use-cases/task-update.ts'
+import { applyUpdateTask, type TaskUpdatePatch } from './use-cases/task-update.ts'
 
 /** The sessions face the controller needs for navigation awareness. */
 export interface SessionsControllerFace {
@@ -47,11 +47,36 @@ export interface ControllerDeps {
   reconcileDebounceMs?: number
 }
 
+/** One workspace option the execution-target pickers offer. */
+export interface ExecutionWorkspaceOption {
+  workspaceId: string
+  /** Display label (workspace title; the wiring falls back to the path). */
+  title: string
+}
+
+/** One agent-preset option the execution-target pickers offer. */
+export interface ExecutionPresetOption {
+  id: string
+  name?: string
+  description?: string
+  /** Why this preset cannot compose a session; the pickers disable it. */
+  broken?: string
+  isDefault: boolean
+}
+
+/** The execution-target option sets the UI feeds into the controller. */
+export interface ExecutionOptionsSnapshot {
+  workspaces: readonly ExecutionWorkspaceOption[]
+  presets: readonly ExecutionPresetOption[]
+}
+
 /** Immutable controller snapshot for UI subscriptions. */
 export interface ControllerSnapshot {
   tasks: readonly TaskRecord[]
   boardOpen: boolean
   selectedTaskId: string | undefined
+  /** Picker option sets (workspace list + agent-preset roster). */
+  executionOptions: ExecutionOptionsSnapshot
 }
 
 /** The selected task (resolved from the ledger), or undefined. */
@@ -85,6 +110,7 @@ export class BoardController {
   private tasks: TaskRecord[] = []
   private boardOpen = false
   private selectedTaskId: string | undefined
+  private executionOptions: ExecutionOptionsSnapshot = { workspaces: [], presets: [] }
   private listeners = new Set<() => void>()
   private disposers: Array<() => void> = []
   private readonly now: () => number
@@ -132,6 +158,7 @@ export class BoardController {
       tasks: this.tasks,
       boardOpen: this.boardOpen,
       selectedTaskId: this.selectedTaskId,
+      executionOptions: this.executionOptions,
     }
   }
 
@@ -186,11 +213,20 @@ export class BoardController {
     return task
   }
 
-  updateTask(id: string, patch: Partial<Pick<TaskRecord, 'title' | 'description' | 'prompt'>>): void {
+  updateTask(id: string, patch: TaskUpdatePatch): void {
     this.tasks = [...applyUpdateTask(this.tasks, id, patch, this.now())]
     this.persistAndNotify()
   }
 
+  /**
+   * Replace (a part of) the picker option sets the UI feeds (workspace list
+   * and agent-preset roster come from the runtime, not the ledger).
+   */
+  setExecutionOptions(patch: Partial<ExecutionOptionsSnapshot>): void {
+    this.executionOptions = { ...this.executionOptions, ...patch }
+    this.notify()
+  }
+
   moveTask(id: string, status: TaskStatus): void {
     this.tasks = this.tasks.map(task => task.id === id ? withStatus(task, status, this.now()) : task)
     this.persistAndNotify()

package/src/core/execution.ts

@@ -15,17 +15,35 @@
  */
 import type { ExecutionRecord, TaskRecord } from './tasks.ts'
 
+/** One list-row summary the execution service reads (the narrow slice of a SessionSummary). */
+export interface ExecutionSessionSummary {
+  running: boolean
+  completed?: boolean
+  /** Empty-log bit: the preset can only be recomposed while the session is blank. */
+  blank?: boolean
+  /** The preset the session currently runs (absent on deployments without presets). */
+  agentPreset?: string
+}
+
 /** The narrow sessions face the service needs. */
 export interface SessionsExecutionFace {
   list: {
     getSnapshot(): {
       /** Baseline arrival lifecycle — 'pending' until the host list has loaded. */
       phase: 'pending' | 'ready'
-      byId: Record<string, { running: boolean; completed?: boolean }>
+      byId: Record<string, ExecutionSessionSummary>
     }
     subscribe(fn: () => void): () => void
   }
   binding(id: string): { session: SessionDriver } | undefined
+  /** Record a host-confirmed preset switch so the list label moves immediately. */
+  noteAgentPreset?(sessionId: string, agentPreset: string): void
+}
+
+/** The narrow agent-preset wire face the service needs (`agentPreset.select`). */
+export interface PresetsExecutionFace {
+  /** Recompose a blank session's agent from a preset. */
+  select(sessionId: string, agentPreset: string): Promise<{ ok: true } | { ok: false; error: unknown }>
 }
 
 /** The narrow workspaces face the service needs. */
@@ -57,6 +75,12 @@ export interface SessionDriver {
     content: readonly unknown[],
     mode: 'queue',
   ): Promise<{ ok: true } | { ok: false; error: unknown }>
+  /**
+   * Admit one slash-command line against the session's agent (the
+   * `/permission <id>` mechanism). `matched` reports whether a command
+   * claimed the line.
+   */
+  command(line: string): Promise<{ ok: true; matched: boolean } | { ok: false; error: unknown }>
   getSnapshot(): { running: boolean; lastAgentError: string | null; turnEnds: ReadonlyMap<number, number> }
   subscribe(fn: () => void): () => void
 }
@@ -65,6 +89,8 @@ export interface SessionDriver {
 export interface ExecutionEnvironment {
   sessions: SessionsExecutionFace
   workspaces: WorkspacesExecutionFace
+  /** Agent-preset wire face; absent on deployments without preset support. */
+  presets?: PresetsExecutionFace
   /** Raw-history reader for failure detection of never-opened sessions. */
   history?: HistoryExecutionFace
 }
@@ -80,6 +106,19 @@ function messageOf(error: unknown): string {
   return String(error)
 }
 
+/**
+ * Whether a rejected preset switch actually means "the session already runs
+ * this preset" (the host's agent-preset-conflict with a matching
+ * existingPreset). A blank-session reuse race can produce this even though
+ * the requested composition is in place.
+ */
+function presetAlreadyRuns(error: unknown, mode: string): boolean {
+  if (typeof error !== 'object' || error === null) return false
+  const details = (error as { details?: unknown }).details
+  if (typeof details !== 'object' || details === null) return false
+  return (details as { existingPreset?: unknown }).existingPreset === mode
+}
+
 /** Whether a `turn/end` payload closed the turn with an error reason. */
 function isErrorTurnEnd(data: unknown): boolean {
   if (typeof data !== 'object' || data === null) return false
@@ -106,14 +145,24 @@ export class ExecutionService {
     execution: ExecutionRecord,
     onEvent: (event: ExecutionEvent) => void,
   ): Promise<void> {
+    const settleFailed = (error: string): void => {
+      onEvent({ kind: 'settled', taskId: task.id, executionId: execution.id, outcome: 'failed', error })
+    }
     try {
-      const sessionId = await this.connectSession()
+      const sessionId = await this.connectSession(task.workspaceId)
       onEvent({ kind: 'started', taskId: task.id, executionId: execution.id, sessionId })
       const driver = this.driverOf(sessionId)
       if (driver === undefined) {
-        onEvent({ kind: 'settled', taskId: task.id, executionId: execution.id, outcome: 'failed', error: 'execution session is not ready' })
+        settleFailed('execution session is not ready')
         return
       }
+      // Task-pinned execution targets are applied BEFORE any prompt: a preset
+      // can only be recomposed while the session is blank, and the permission
+      // command must run before the task's turn starts. A rejected target
+      // fails the run without sending the prompt — running the task under
+      // different settings than it declared would be worse than not running.
+      if (!await this.applyMode(driver, task, sessionId, settleFailed)) return
+      if (!await this.applyPermission(driver, task, settleFailed)) return
       // Best-effort rename so the execution is recognizable in the session list.
       await driver.rename(task.title).catch(() => { /* rename is cosmetic */ })
       // Baseline the turn counter BEFORE the prompt round-trip: a turn that
@@ -122,21 +171,92 @@ export class ExecutionService {
       const baseline = driver.getSnapshot().turnEnds.size
       const accepted = await this.sendPrompt(driver, task)
       if (!accepted.ok) {
-        onEvent({
-          kind: 'settled', taskId: task.id, executionId: execution.id, outcome: 'failed',
-          error: messageOf(accepted.error),
-        })
+        settleFailed(messageOf(accepted.error))
         return
       }
       this.watchForSettlement(driver, task.id, execution.id, onEvent, baseline)
     } catch (error) {
-      onEvent({
-        kind: 'settled', taskId: task.id, executionId: execution.id, outcome: 'failed',
-        error: messageOf(error),
-      })
+      settleFailed(messageOf(error))
     }
   }
 
+  /**
+   * Recompose the execution session's agent from the task-pinned preset.
+   * No-op when the task pins none or the session already runs it; fails the
+   * run when the session is no longer blank, the preset face is missing, or
+   * the wire refuses.
+   */
+  private async applyMode(
+    driver: SessionDriver,
+    task: TaskRecord,
+    sessionId: string,
+    settleFailed: (error: string) => void,
+  ): Promise<boolean> {
+    const mode = task.mode
+    if (mode === undefined || mode === '') return true
+    const summary = this.env.sessions.list.getSnapshot().byId[sessionId]
+    if (summary?.blank === false) {
+      settleFailed(`cannot switch agent preset to ${mode}: the execution session is not blank`)
+      return false
+    }
+    if (summary?.agentPreset === mode) return true
+    if (this.env.presets === undefined) {
+      settleFailed(`this deployment does not support agent presets (task asks for ${mode})`)
+      return false
+    }
+    try {
+      const result = await this.env.presets.select(sessionId, mode)
+      if (!result.ok) {
+        // A list race can leave the summary without the preset label even
+        // though the blank session already runs it; the wire answers that
+        // case with agent-preset-conflict (existingPreset === requested).
+        // The requested composition is already in place, so count it as
+        // applied instead of failing the run.
+        if (presetAlreadyRuns(result.error, mode)) {
+          this.env.sessions.noteAgentPreset?.(sessionId, mode)
+          return true
+        }
+        settleFailed(`agent preset switch to ${mode} rejected: ${messageOf(result.error)}`)
+        return false
+      }
+    } catch (error) {
+      settleFailed(`agent preset switch to ${mode} failed: ${messageOf(error)}`)
+      return false
+    }
+    this.env.sessions.noteAgentPreset?.(sessionId, mode)
+    return true
+  }
+
+  /**
+   * Apply the task-pinned permission preset through the `/permission <id>`
+   * slash command. No-op when the task pins none; fails the run when the
+   * admission is rejected or no command claimed the line.
+   */
+  private async applyPermission(
+    driver: SessionDriver,
+    task: TaskRecord,
+    settleFailed: (error: string) => void,
+  ): Promise<boolean> {
+    const permission = task.permission
+    if (permission === undefined) return true
+    const line = `/permission ${permission}`
+    try {
+      const result = await driver.command(line)
+      if (!result.ok) {
+        settleFailed(`permission command rejected: ${messageOf(result.error)}`)
+        return false
+      }
+      if (!result.matched) {
+        settleFailed(`permission command not recognized: ${line}`)
+        return false
+      }
+    } catch (error) {
+      settleFailed(`permission command failed: ${messageOf(error)}`)
+      return false
+    }
+    return true
+  }
+
   /**
    * Inspect a reloaded/background task that was left 'running' and emit a
    * settled event when its session already finished.
@@ -198,8 +318,16 @@ export class ExecutionService {
     }
   }
 
-  private async connectSession(): Promise<string> {
+  private async connectSession(taskWorkspaceId: string | undefined): Promise<string> {
     const workspace = this.env.workspaces.list.getSnapshot()
+    if (taskWorkspaceId !== undefined && taskWorkspaceId !== '') {
+      // A task-pinned workspace must exist in the list: connecting an
+      // unknown id would only defer the failure into the wire.
+      if (!workspace.items.some(item => item.workspaceId === taskWorkspaceId)) {
+        throw new Error(`task workspace is not available: ${taskWorkspaceId}`)
+      }
+      return this.env.workspaces.connectWorkspace(taskWorkspaceId)
+    }
     const workspaceId = workspace.recentWorkspaceId ?? workspace.items[0]?.workspaceId
     if (workspaceId === undefined) {
       throw new Error('no workspace available to run the task in')

package/src/core/store.ts

@@ -14,8 +14,7 @@
  * localStorage backend.
  */
 import { isValidCron } from './schedule.ts'
-import type { ScheduleRule, TaskRecord, TaskStatus } from './tasks.ts'
-import { isTaskStatus } from './tasks.ts'
+import { isTaskPermission, isTaskStatus, type ScheduleRule, type TaskRecord, type TaskPermission, type TaskStatus } from './tasks.ts'
 
 /** Persistence seam for the task ledger. */
 export interface TaskStore {
@@ -64,6 +63,9 @@ function isTaskRecordShape(value: unknown): value is Omit<TaskRecord, 'status'>
   if (typeof record.prompt !== 'string') return false
   if (typeof record.createdAt !== 'number') return false
   if (typeof record.updatedAt !== 'number') return false
+  if (record.workspaceId !== undefined && typeof record.workspaceId !== 'string') return false
+  if (record.mode !== undefined && typeof record.mode !== 'string') return false
+  if (record.permission !== undefined && typeof record.permission !== 'string') return false
   if (!Array.isArray(record.executions)) return false
   for (const execution of record.executions) {
     if (typeof execution !== 'object' || execution === null) return false
@@ -78,6 +80,11 @@ function isTaskRecordShape(value: unknown): value is Omit<TaskRecord, 'status'>
   return true
 }
 
+/** Collapse a blank persisted target string to undefined (clears the pin). */
+function normalizeTargetId(value: string | undefined): string | undefined {
+  return value !== undefined && value.trim() === '' ? undefined : value
+}
+
 /** A task record is structurally valid if it round-trips through the UI. */
 export function isTaskRecord(value: unknown): value is TaskRecord {
   return isTaskRecordShape(value) && isTaskStatus(value.status)
@@ -136,6 +143,12 @@ export function parseLedger(raw: string | null): TaskRecord[] {
     // clear a malformed persisted rule rather than leave it in the row.
     const task: TaskRecord = { ...row, status: normalizeStatus(row.status) }
     task.schedule = normalizeSchedule(row.schedule)
+    // Execution targets are normalized like the schedule: blank strings
+    // clear the pin and unknown permission strings from a future version
+    // fall back to the session default instead of dropping the row.
+    task.workspaceId = normalizeTargetId(row.workspaceId)
+    task.mode = normalizeTargetId(row.mode)
+    task.permission = isTaskPermission(row.permission) ? row.permission as TaskPermission : undefined
     tasks.push(task)
   }
   return tasks

package/src/core/tasks.ts

@@ -64,6 +64,32 @@ export interface TaskRecord {
   executions: ExecutionRecord[]
   /** Optional scheduled-run rule (absent on tasks without a schedule). */
   schedule?: ScheduleRule
+  /**
+   * Workspace the execution must run in (a workspace-list id); absent means
+   * the recent-workspace fallback at execution time.
+   */
+  workspaceId?: string
+  /**
+   * Agent preset the execution session must be composed from (an
+   * `agentPreset.list` id); absent means the deployment default.
+   */
+  mode?: string
+  /**
+   * Permission preset applied to the execution session through the
+   * `/permission <id>` slash command; absent leaves the session default.
+   */
+  permission?: TaskPermission
+}
+
+/** Permission presets a task may pin on its execution session (the `/permission <id>` ids). */
+export const TASK_PERMISSIONS = ['read-only', 'workspace-write', 'danger-full-access'] as const
+
+/** One permission preset id. */
+export type TaskPermission = typeof TASK_PERMISSIONS[number]
+
+/** Whether an unknown value is a known permission preset id. */
+export function isTaskPermission(value: unknown): value is TaskPermission {
+  return typeof value === 'string' && (TASK_PERMISSIONS as readonly string[]).includes(value)
 }
 
 /** Input for creating a task. */
@@ -71,6 +97,12 @@ export interface NewTaskInput {
   title: string
   description: string
   prompt: string
+  /** Workspace the execution must run in; empty/absent = the recent workspace. */
+  workspaceId?: string
+  /** Agent preset the execution session must be composed from; empty/absent = deployment default. */
+  mode?: string
+  /** Permission preset applied to the execution session; absent = session default. */
+  permission?: TaskPermission
 }
 
 /** The five kanban columns, in display order. */
@@ -103,6 +135,12 @@ export function canMoveManually(_from: TaskStatus, to: TaskStatus): boolean {
   return (MANUAL_STATUSES as readonly TaskStatus[]).includes(to)
 }
 
+/** Normalize one optional execution-target string: trim; blank collapses to undefined. */
+function normalizeTargetId(value: string | undefined): string | undefined {
+  const trimmed = value?.trim()
+  return trimmed === undefined || trimmed === '' ? undefined : trimmed
+}
+
 /** Create a task from user input. */
 export function createTask(input: NewTaskInput, now: number, id: string): TaskRecord {
   return {
@@ -114,6 +152,9 @@ export function createTask(input: NewTaskInput, now: number, id: string): TaskRe
     createdAt: now,
     updatedAt: now,
     executions: [],
+    workspaceId: normalizeTargetId(input.workspaceId),
+    mode: normalizeTargetId(input.mode),
+    permission: isTaskPermission(input.permission) ? input.permission : undefined,
   }
 }
 

package/src/core/use-cases/task-update.ts

@@ -1,12 +1,31 @@
 /**
  * Update-task use case: apply an editable-field patch (title/description/
- * prompt) with a fresh updatedAt. Pure ledger transition (no persistence or
- * notify — the controller orchestrates those).
+ * prompt plus the execution targets workspaceId/mode/permission) with a
+ * fresh updatedAt. Pure ledger transition (no persistence or notify — the
+ * controller orchestrates those).
+ *
+ * An explicit `undefined` in the patch clears the field (the task falls
+ * back to the runtime default); an unknown permission string is ignored so
+ * stale UI can never persist a value the execution service rejects.
  */
-import type { TaskRecord } from '../tasks.ts'
+import { isTaskPermission, type TaskRecord, type TaskPermission } from '../tasks.ts'
 
 /** Editable fields on a task (the update patch surface). */
-export type TaskUpdatePatch = Partial<Pick<TaskRecord, 'title' | 'description' | 'prompt'>>
+export type TaskUpdatePatch = Partial<Pick<TaskRecord, 'title' | 'description' | 'prompt' | 'workspaceId' | 'mode' | 'permission'>>
+
+/** Collapse a blank target string to undefined (clears the pin). */
+function normalizeTargetId(value: string | undefined): string | undefined {
+  return value !== undefined && value.trim() === '' ? undefined : value
+}
+
+/** Keep an unknown permission string from entering the ledger. */
+function normalizePermission(
+  current: TaskPermission | undefined,
+  value: TaskPermission | undefined,
+): TaskPermission | undefined {
+  if (value === undefined) return undefined
+  return isTaskPermission(value) ? value : current
+}
 
 /**
  * Apply an update across the ledger. Tasks that do not match the id are left
@@ -22,5 +41,15 @@ export function applyUpdateTask(
   patch: TaskUpdatePatch,
   now: number,
 ): readonly TaskRecord[] {
-  return tasks.map(task => task.id === id ? { ...task, ...patch, updatedAt: now } : task)
+  return tasks.map(task => {
+    if (task.id !== id) return task
+    const workspaceId = 'workspaceId' in patch ? normalizeTargetId(patch.workspaceId) : undefined
+    const mode = 'mode' in patch ? normalizeTargetId(patch.mode) : undefined
+    const permission = 'permission' in patch ? normalizePermission(task.permission, patch.permission) : undefined
+    const next: TaskRecord = { ...task, ...patch, updatedAt: now }
+    if (workspaceId !== undefined || 'workspaceId' in patch) next.workspaceId = workspaceId
+    if (mode !== undefined || 'mode' in patch) next.mode = mode
+    if (permission !== undefined || 'permission' in patch) next.permission = permission
+    return next
+  })
 }

package/src/index.ts

@@ -22,7 +22,7 @@ const SECTION_ORDER = 200
 export const inject = ['systemPrompt']
 
 /** Model-facing announcement: plugin presence, capabilities, and limits. */
-export const TASK_BOARD_GUIDANCE = '本机已安装 dsh-task-board 插件（DSH Web GUI 的任务看板）：侧边栏「任务看板」入口；在 dsh-web-ui 插件全家桶仓库（packages/dsh-task-board）统一维护，经聚合包 web-ui-all 一键安装。能力：多列看板管理任务；任务可真实执行（驱动 agent 会话）；任务支持 5 段 cron 定时执行（如 0 23 * * *）；数据存浏览器 localStorage（键 dsh.taskBoard.v1）。限制：定时调度在浏览器端，需 GUI 标签页打开，错过即跳过；执行消耗 API 额度。用户提到「任务看板 / 看板 / 定时任务」时即指本插件，请据此协作。'
+export const TASK_BOARD_GUIDANCE = '本机已安装 dsh-task-board 插件（DSH Web GUI 的任务看板）：侧边栏「任务看板」入口；在 dsh-web-ui 插件全家桶仓库（packages/dsh-task-board）统一维护，经聚合包 web-ui-all 一键安装。能力：多列看板管理任务；任务可真实执行（驱动 agent 会话）；任务可钉住执行目标——工作区 / 模式（agent 预设）/ 权限（read-only / workspace-write / danger-full-access），缺省用运行时默认；任务支持 5 段 cron 定时执行（如 0 23 * * *）；数据存浏览器 localStorage（键 dsh.taskBoard.v1）。限制：定时调度在浏览器端，需 GUI 标签页打开，错过即跳过；执行消耗 API 额度。用户提到「任务看板 / 看板 / 定时任务」时即指本插件，请据此协作。'
 
 /**
  * Settings namespace of the board's announcement capability — the section the