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

package/src/client/index.ts

@@ -9,7 +9,7 @@
  * plugin must not take the GUI down.
  */
 import type { ClientContext, SessionId, SettingsScope, SettingsScopeSpec, WorkspaceId } from '@deepseek-ai/dsh-client-runtime/client'
-import type { ConnectionHandle } from '@deepseek-ai/dsh-client-connection/client'
+import type { ConnectionHandle, PromptContentPart } from '@deepseek-ai/dsh-client-connection/client'
 import type {} from '@deepseek-ai/dsh-client-ui-slots'
 // Type-only: pulls the locale plugin's Context merge (ctx.locale) and its
 // LocaleNamespaceMap merge table.
@@ -116,12 +116,40 @@ export function apply(ctx: ClientContext): void {
     const exec = new ExecutionService({
       sessions: {
         list: sessions.list,
-        binding: id => sessions.binding(id as SessionId),
+        binding: id => {
+          const binding = sessions.binding(id as SessionId)
+          if (binding === undefined) return undefined
+          const { session } = binding
+          return {
+            session: {
+              rename: title => session.rename(title),
+              prompt: (content, mode) =>
+                session.prompt(content as PromptContentPart[], mode).then(result =>
+                  result.ok ? { ok: true as const } : { ok: false as const, error: result.error }),
+              command: line =>
+                session.command(line).then(result =>
+                  result.ok ? { ok: true as const, matched: result.value.matched } : { ok: false as const, error: result.error }),
+              getSnapshot: () => session.getSnapshot(),
+              subscribe: fn => session.subscribe(fn),
+            },
+          }
+        },
+        noteAgentPreset: (sessionId, agentPreset) => sessions.noteAgentPreset(sessionId as SessionId, agentPreset),
       },
       workspaces: {
         list: workspaces.list,
         connectWorkspace: id => workspaces.connectWorkspace(id as WorkspaceId),
       },
+      presets: {
+        select: async (sessionId, agentPreset) => {
+          try {
+            const response = await connection.api.agentPresets.select({ sessionId: sessionId as SessionId, agentPreset })
+            return response.result.ok ? { ok: true as const } : { ok: false as const, error: response.result.error }
+          } catch (error) {
+            return { ok: false as const, error }
+          }
+        },
+      },
       history: {
         loadTail: async sessionId => {
           const response = await connection.api.sessions.history({
@@ -163,6 +191,44 @@ export function apply(ctx: ClientContext): void {
     scheduler.start()
 
     const disposers: Array<() => void> = []
+
+    // Execution-target option feeds: the workspace list drives the workspace
+    // picker, and the agent-preset roster drives the mode picker. Both are
+    // runtime facts (not ledger state), so the wiring pushes them into the
+    // controller on change; the preset roster is re-read after reconnects
+    // because a reconnect may serve a different deployment.
+    const pushWorkspaceOptions = (): void => {
+      const snapshot = workspaces.list.getSnapshot()
+      controller.setExecutionOptions({
+        workspaces: snapshot.items.map(item => ({
+          workspaceId: item.workspaceId,
+          title: item.title !== '' ? item.title : item.path,
+        })),
+      })
+    }
+    pushWorkspaceOptions()
+    disposers.push(workspaces.list.subscribe(pushWorkspaceOptions))
+    const pushPresetOptions = async (): Promise<void> => {
+      try {
+        const response = await connection.api.agentPresets.list({})
+        if (!response.result.ok) return
+        controller.setExecutionOptions({
+          presets: response.result.value.presets.map(preset => ({
+            id: preset.id,
+            name: preset.name,
+            description: preset.description,
+            broken: preset.broken,
+            isDefault: preset.isDefault,
+          })),
+        })
+      } catch (error) {
+        // A failed roster read leaves the previous options in place; the
+        // picker stays usable and the next reconnect retries the read.
+        console.error('[dsh-task-board] agent preset roster read failed', error)
+      }
+    }
+    void pushPresetOptions()
+    disposers.push(ctx.on('connection/reset', () => { void pushPresetOptions() }))
     try {
       disposers.push(mountSidebarEntry(controller))
       disposers.push(mountBoard(controller))

package/src/client/locales.ts

@@ -73,6 +73,20 @@ export const zh = {
   'detail.schedule.notScheduled': '尚未排程',
   'detail.schedule.dueSoon': '即将运行',
   'card.scheduled': '定时',
+  'new.workspace': '工作区',
+  'new.mode': '模式',
+  'new.permission': '权限',
+  'exec.workspace.recent': '最近使用（默认）',
+  'exec.mode.default': '部署默认',
+  'exec.mode.defaultSuffix': '（默认）',
+  'exec.mode.brokenSuffix': '（不可用）',
+  'exec.mode.removed': '（已移除）',
+  'exec.permission.default': '会话默认',
+  'exec.permission.read-only': '只读',
+  'exec.permission.workspace-write': '工作区可写',
+  'exec.permission.danger-full-access': '完全访问',
+  'detail.executionSettings': '执行设置',
+  'exec.hint': '执行时生效：工作区决定执行会话落在哪个工作区；模式决定会话的 agent 预设；权限经 /permission 命令应用到会话。留空则使用运行时默认。',
   // 插件设置卡片（settings.plugin.item 席位）。
   'settings.title': '任务看板',
   'settings.description': '控制看板在 agent 系统提示中的播报行为。',
@@ -165,6 +179,20 @@ export const en: Record<keyof typeof zh, string> = {
   'detail.schedule.notScheduled': 'Not scheduled yet',
   'detail.schedule.dueSoon': 'Due soon',
   'card.scheduled': 'scheduled',
+  'new.workspace': 'Workspace',
+  'new.mode': 'Mode',
+  'new.permission': 'Permission',
+  'exec.workspace.recent': 'Most recent (default)',
+  'exec.mode.default': 'Deployment default',
+  'exec.mode.defaultSuffix': ' (default)',
+  'exec.mode.brokenSuffix': ' (unavailable)',
+  'exec.mode.removed': ' (removed)',
+  'exec.permission.default': 'Session default',
+  'exec.permission.read-only': 'Read-only',
+  'exec.permission.workspace-write': 'Workspace Write',
+  'exec.permission.danger-full-access': 'Full Access',
+  'detail.executionSettings': 'Execution Settings',
+  'exec.hint': 'Applied when the task runs: the workspace decides where the execution session lands; the mode composes the session\'s agent preset; the permission is applied through the /permission command. Blank = runtime default.',
   // Plugin settings card (the `settings.plugin.item` seat).
   'settings.title': 'Task Board',
   'settings.description': 'How the board announces itself in each agent system prompt.',

package/src/client/settings-card.module.css

@@ -121,6 +121,9 @@
   margin: 0;
   font-size: 12px;
   line-height: 1.5;
+  text-overflow: ellipsis;
+  overflow: hidden;
+  white-space: nowrap;
 }
 
 .discard,

package/src/client/settings-form.ts

@@ -20,6 +20,14 @@ export type FieldWrite =
 export interface FieldSpec {
   /** Field name inside the namespace section. */
   field: string
+  /**
+   * Whether the Host treats this field as a secret and redacts its value from
+   * the read-back (role('secret') in the section schema). Redacted secrets are
+   * never compared against the draft on save; the field lands when the scope
+   * reports the write succeeded (its secret-set marker under the bridge), so
+   * a successful secret save is not misreported as failed.
+   */
+  secret?: boolean
   /** Render a stored value as draft text; the empty string when the section carries none. */
   format: (value: unknown) => string
   /**
@@ -61,6 +69,12 @@ export interface CardShell {
   saving: boolean
   /** Whether the last save did not land as staged; cleared by the next edit or save. */
   failed: boolean
+  /**
+   * The rejection code/message the Host returned for the last failed save,
+   * surfaced next to the generic failure text. Undefined while no save has
+   * failed (or the failure carried no server reason).
+   */
+  failedReason?: string
 }
 
 /** The write actions the card's slot entry injects. */
@@ -87,10 +101,52 @@ interface StagedEdit {
 interface PlannedWrite {
   /** Field this entry writes. */
   field: string
+  /** The durable write this entry performs, described for a batched scope. */
+  op: BatchedWrite
   /** Perform the write and report whether the Host holds the staged value afterwards. */
   run: (() => Promise<boolean>) | undefined
 }
 
+/** One durable write a batched settings scope performs. */
+export interface BatchedWrite {
+  /** Field this entry writes. */
+  field: string
+  /** set stores a value; unset drops the leaf. */
+  op: 'set' | 'unset'
+  /** Value for op set (absent for unset). */
+  value?: unknown
+}
+
+/** Per-field outcome of one batched scope write. */
+export interface BatchedFieldResult {
+  /** Field this entry writes. */
+  field: string
+  /** Whether the Host accepted this field's write (per the read-back view). */
+  landed: boolean
+}
+
+/**
+ * Result of a batched scope write. The bridge scope posts every planned write
+ * in one /mutate so the Host validate hook judges baseURL+model together; a
+ * batched refusal fails the whole save rather than per-field.
+ */
+export interface BatchResult {
+  /** Whether the whole mutate was accepted. */
+  ok: boolean
+  /** Per-field success, in the request order (always present when ok). */
+  fields: BatchedFieldResult[]
+  /** Host rejection code (mutate refused). */
+  code?: string
+  /** Host rejection message (mutate refused). */
+  message?: string
+}
+
+/** The optional batch surface the bridge scope adds over the SettingsScope contract. */
+interface BatchedSettingsScope {
+  /** Write every operation in one scope mutation, reporting per-field success. */
+  mutate: (writes: BatchedWrite[]) => Promise<BatchResult>
+}
+
 /** Constraints a numeric field's accepted drafts must satisfy, mirroring the host schema. */
 export interface NumberConstraints {
   /** The accepted value must be a whole number. */
@@ -129,6 +185,16 @@ export function textField(field: string): FieldSpec {
   }
 }
 
+/**
+ * A free-text field the Host treats as a secret and redacts from the read-back
+ * (role('secret') in the section schema). The card still edits it like text,
+ * but a save never compares the redacted value back and relies on the scope
+ * reporting the write landed.
+ */
+export function secretField(field: string): FieldSpec {
+  return { ...textField(field), secret: true }
+}
+
 /** A boolean field, edited through true/false draft text. */
 export function booleanField(field: string): FieldSpec {
   return {
@@ -170,6 +236,7 @@ export class CardForm<T> {
   private readonly listeners = new Set<() => void>()
   private saving = false
   private failed = false
+  private failedReason: string | undefined
 
   /** @param scope - the bound settings scope for this card's namespace. */
   constructor(
@@ -199,6 +266,7 @@ export class CardForm<T> {
       invalid: plan.some(item => item.run === undefined),
       saving: this.saving,
       failed: this.failed,
+      ...this.failedReason === undefined ? {} : { failedReason: this.failedReason },
     }
   }
 
@@ -229,6 +297,7 @@ export class CardForm<T> {
         if (this.staged.size === 0 && !this.failed) return
         this.staged.clear()
         this.failed = false
+        this.failedReason = undefined
         this.publish()
       },
     }
@@ -236,30 +305,57 @@ export class CardForm<T> {
 
   /**
    * Write every staged edit, then re-seed from what the Host accepted.
+   *
+   * When the scope carries the optional batch surface (the dsh-web-ui
+   * bridge scope), every planned write rides one mutation so cross-field
+   * validate hooks (baseURL+model) judge the batch as a unit instead of
+   * deadlocking on per-field writes. Otherwise the per-field loop runs.
+   * A field lands only when the Host reports it held the staged value; a
+   * landed field's draft is dropped, a failed one stays staged for the user.
    * @returns settlement after every write and the read-back.
    */
   async save(): Promise<void> {
     const plan = this.plan()
-    const writes = plan.flatMap(item => item.run === undefined ? [] : [item.run])
-    if (plan.length === 0 || this.saving || writes.length !== plan.length) return
+    const valid = plan.filter(item => item.run !== undefined)
+    if (plan.length === 0 || this.saving || valid.length !== plan.length) return
+    const plannedWrites = valid.map(item => item.op)
     // Snapshot the fields this save writes, so edits staged while it is in
     // flight survive: only the staged keys this save actually wrote are cleared.
     const fields = new Set(plan.map(item => item.field))
     this.saving = true
     this.failed = false
+    this.failedReason = undefined
     this.publish()
-    let landed = true
-    for (const write of writes) {
-      landed = await write() && landed
+    const landed = new Set<string>()
+    const batch = this.batchedScope()
+    if (batch !== undefined) {
+      const result = await batch.mutate(plannedWrites)
+      if (result.ok) {
+        for (const field of result.fields) {
+          if (field.landed) landed.add(field.field)
+        }
+      } else {
+        this.failedReason = result.message
+      }
+    } else {
+      for (const item of valid) {
+        if (await item.run!()) landed.add(item.field)
+      }
     }
-    if (landed) {
-      for (const field of fields) this.staged.delete(field)
+    for (const field of fields) {
+      if (landed.has(field)) this.staged.delete(field)
     }
     this.saving = false
-    this.failed = !landed
+    this.failed = landed.size !== fields.size
     this.publish()
   }
 
+  /** The scope's batch surface when it supports one; undefined conservatively otherwise. */
+  private batchedScope(): BatchedSettingsScope | undefined {
+    const candidate = this.scope as unknown as BatchedSettingsScope | undefined
+    return typeof candidate?.mutate === 'function' ? candidate : undefined
+  }
+
   /**
    * Every staged edit a save would write. An entry whose draft is not a value
    * its field accepts carries no write: the form is still dirty, and the save
@@ -272,14 +368,14 @@ export class CardForm<T> {
     for (const [field, staged] of this.staged) {
       const spec = this.specOf(field)
       if (staged.clear) {
-        if (this.stored(field)) plan.push({ field, run: () => this.clear(field) })
+        if (this.stored(field)) plan.push({ field, op: { field, op: 'unset' }, run: () => this.clear(field) })
         continue
       }
       if (staged.text === spec.format(this.sectionValue(field))) continue
       const write = spec.parse(staged.text)
-      if (write === undefined) plan.push({ field, run: undefined })
-      else if (write.kind === 'clear') plan.push({ field, run: () => this.clear(field) })
-      else plan.push({ field, run: () => this.store(field, write.value) })
+      if (write === undefined) plan.push({ field, op: { field, op: 'unset' }, run: undefined })
+      else if (write.kind === 'clear') plan.push({ field, op: { field, op: 'unset' }, run: () => this.clear(field) })
+      else plan.push({ field, op: { field, op: 'set', value: write.value }, run: () => this.store(field, write.value) })
     }
     return plan
   }
@@ -291,12 +387,18 @@ export class CardForm<T> {
 
   private async store(field: string, value: unknown): Promise<boolean> {
     await this.scope.set(field, value)
+    // A redacted secret never appears in the user layer read-back; judging it
+    // by value would misreport a successful secret save as failed. The bridge
+    // reports secret writes through its secret-set markers (batch path); on
+    // the per-field path the scope resolved, so the write is landed.
+    if (this.specOf(field).secret) return true
     return this.userLayer()?.[field] === value
   }
 
   private stage(field: string, edit: StagedEdit): void {
     this.staged.set(field, edit)
     this.failed = false
+    this.failedReason = undefined
     this.publish()
   }
 

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')