dsh-taskboard 0.2.1 → 0.3.3

package/src/host/routes.ts

@@ -10,10 +10,13 @@
  * @module dsh-taskboard/host/routes
  */
 import type { IncomingMessage, ServerResponse } from 'node:http'
+import { readdir, rm } from 'node:fs/promises'
+import { join } from 'node:path'
 import type { Context } from '@deepseek-ai/cordis'
 // Type-only: pulls the webServer Context merge (ctx.webServer).
 import type {} from '@deepseek-ai/dsh-host-webserver'
 import {
+  asIsolation,
   asStatus,
   asUrgency,
   canTransition,
@@ -29,6 +32,7 @@ import {
   type TaskModel,
   type TaskRecord,
 } from '../shared/protocol.ts'
+import { WORKTREE_DIR, worktreePathOf, type GitFace } from './git.ts'
 import { ROUTE_PREFIX, SSE_PATH, type ApiFail, type ApiResult } from '../shared/api.ts'
 import type { TaskStore } from './store.ts'
 import type { WorkspaceFace } from './tools.ts'
@@ -36,6 +40,9 @@ import type { WorkspaceFace } from './tools.ts'
 /** Heartbeat cadence for the SSE stream. */
 const HEARTBEAT_MS = 20_000
 
+/** How long a workspace git-detection result stays cached (fail-soft). */
+const GIT_DETECT_TTL_MS = 60_000
+
 /** The workspaces face routes need (same narrow shape as tools). */
 export type RoutesWorkspaceFace = WorkspaceFace
 
@@ -44,8 +51,8 @@ export interface TaskboardRoutesOptions {
   store: TaskStore
   workspaces: RoutesWorkspaceFace
   now: () => number
-  /** Manual-run hook (the execution service); absent → 501. */
-  run?: (taskId: string) => Promise<{ ok: true; executionId: string; sessionId: string } | { ok: false; error: string }>
+  /** Manual-run hook (the execution service); absent → 501. Options carry `reuseWorktree` (续跑). */
+  run?: (taskId: string, options?: { reuseWorktree?: boolean }) => Promise<{ ok: true; executionId: string; sessionId: string } | { ok: false; error: string }>
   /** Cancel hook (the execution service); absent → 501. */
   cancel?: (taskId: string) => Promise<{ ok: true; executionId: string } | { ok: false; error: string }>
   /**
@@ -53,6 +60,8 @@ export interface TaskboardRoutesOptions {
    * advisory validation of pinned models; undefined = runtime unavailable.
    */
   modelProviders?: () => string[] | undefined
+  /** Git face for worktree actions + workspace git detection; absent → 501 on git actions. */
+  git?: GitFace
 }
 
 /** Validate a pinned model: structural check always, provider route when known. */
@@ -74,7 +83,7 @@ function json(res: ServerResponse, payload: ApiResult<unknown>, status = 200): v
 
 /** Domain failure → envelope + HTTP status. */
 function fail(code: ApiFail['error']['code'], message: string): { res: ApiFail; status: number } {
-  const status = code === 'invalid_input' ? 400
+  const status = code === 'invalid_input' || code === 'invalid_transition' ? 400
     : code === 'not_found' ? 404
       : code === 'version_conflict' ? 409
         : code === 'forbidden' ? 403
@@ -108,6 +117,12 @@ function num(body: Record<string, unknown>, key: string): number | undefined | n
   return typeof v === 'number' && Number.isFinite(v) ? v : null
 }
 
+/** Normalize an agent preset id: trimmed, non-empty; empty string → undefined. */
+function normalizePresetId(raw: string | null): string | undefined {
+  const t = (raw ?? '').trim()
+  return t.length === 0 ? undefined : t
+}
+
 /** Map a thrown domain error to the envelope. */
 function toFail(error: unknown): { res: ApiFail; status: number } {
   const message = error instanceof Error ? error.message : String(error)
@@ -137,6 +152,72 @@ export function registerTaskboardRoutes(ctx: Context, options: TaskboardRoutesOp
   }
   store.subscribe(broadcast)
 
+  // Workspace git detection, TTL-cached and fail-soft (false on any error):
+  // feeds the create-form isolation toggle and the diagnostics panel.
+  const gitCache = new Map<string, { value: boolean; at: number }>()
+  const gitHinted = new Set<string>()
+
+  /** Whether <root>/.gitignore (missing file counts as missing) ignores our worktree dir. */
+  const gitignoreMissing = async (path: string): Promise<boolean> => {
+    try {
+      const { readFile } = await import('node:fs/promises')
+      const ignore = await readFile(join(path, '.gitignore'), 'utf8')
+      return !ignore.split('\n').some(l => {
+        const t = l.trim().replace(/\/+$/, '')
+        return t === WORKTREE_DIR || t === `/${WORKTREE_DIR}`
+      })
+    } catch {
+      return true // no .gitignore at all (or unreadable) → suggest creating one
+    }
+  }
+
+  const gitAvailable = async (path: string): Promise<boolean> => {
+    if (options.git === undefined) return false
+    const hit = gitCache.get(path)
+    if (hit !== undefined && options.now() - hit.at < GIT_DETECT_TTL_MS) return hit.value
+    let value = false
+    try {
+      value = await options.git.detect(path)
+    } catch { /* fail-soft → false */ }
+    gitCache.set(path, { value, at: options.now() })
+    // gitignore 建议 (plan §3.2): suggest (never write) ignoring our
+    // worktree directory, once per workspace per host run.
+    if (value && !gitHinted.has(path)) {
+      gitHinted.add(path)
+      if (await gitignoreMissing(path)) {
+        console.info(`[dsh-taskboard] 建议在 ${path}/.gitignore 加入一行 ${WORKTREE_DIR}/ 以隐藏任务 worktree 目录（不会自动修改）`)
+      }
+    }
+    return value
+  }
+
+  /** List orphan worktree dirs: entries under <ws>/.dsh-worktrees owned by no ledger task. */
+  const listOrphanWorktrees = async (): Promise<Array<{ workspaceId: string; workspacePath: string; taskId: string; path: string }>> => {
+    const orphans: Array<{ workspaceId: string; workspacePath: string; taskId: string; path: string }> = []
+    const known = new Set(store.snapshot().tasks.map(t => t.id))
+    for (const ws of workspaces.list()) {
+      let entries: string[] = []
+      try {
+        const dirents = await readdir(join(ws.path, WORKTREE_DIR), { withFileTypes: true })
+        entries = dirents.filter(e => e.isDirectory()).map(e => e.name)
+      } catch { /* no worktrees dir → nothing to do */ }
+      for (const taskId of entries) {
+        if (!known.has(taskId)) orphans.push({ workspaceId: ws.id, workspacePath: ws.path, taskId, path: worktreePathOf(ws.path, taskId) })
+      }
+    }
+    return orphans
+  }
+
+  /** Git-enabled workspaces whose .gitignore does not cover the worktree dir. */
+  const listGitignoreSuggestions = async (): Promise<Array<{ workspaceId: string; workspacePath: string }>> => {
+    const suggestions: Array<{ workspaceId: string; workspacePath: string }> = []
+    for (const ws of workspaces.list()) {
+      if (!(await gitAvailable(ws.path))) continue
+      if (await gitignoreMissing(ws.path)) suggestions.push({ workspaceId: ws.id, workspacePath: ws.path })
+    }
+    return suggestions
+  }
+
   const handler = async (req: IncomingMessage, res: ServerResponse): Promise<void> => {
     try {
       const url = new URL(req.url ?? '/', 'http://x')
@@ -150,7 +231,30 @@ export function registerTaskboardRoutes(ctx: Context, options: TaskboardRoutesOp
           return
         }
         if (pathname === `${ROUTE_PREFIX}/workspaces`) {
-          json(res, { ok: true, value: workspaces.list() })
+          const list = workspaces.list()
+          const flags = await Promise.all(list.map(ws => gitAvailable(ws.path)))
+          json(res, {
+            ok: true,
+            value: list.map((ws, i) => ({ ...ws, sessionCount: 0, gitAvailable: flags[i] })),
+          })
+          return
+        }
+        if (pathname === `${ROUTE_PREFIX}/diagnostics`) {
+          const ledger = store.snapshot()
+          let staleRunning = 0
+          for (const t of ledger.tasks) {
+            for (const e of t.executions) if (e.outcome === 'running') staleRunning += 1
+          }
+          json(res, {
+            ok: true,
+            value: {
+              revision: ledger.revision,
+              tasks: ledger.tasks.length,
+              staleRunning,
+              orphanWorktrees: await listOrphanWorktrees(),
+              gitIgnoreSuggestions: await listGitignoreSuggestions(),
+            },
+          })
           return
         }
         const taskMatch = pathname.match(new RegExp(`^${ROUTE_PREFIX}/tasks/([^/]+)$`))
@@ -194,6 +298,9 @@ export function registerTaskboardRoutes(ctx: Context, options: TaskboardRoutesOp
           const status = str(body, 'status') === null ? 'todo' as const : asStatus(str(body, 'status')!)
           const execution = normalizeExecution((body.execution as { mode?: string; cron?: string } | undefined) ?? {}, options.now())
           const model = body.model === undefined ? undefined : checkModel(body.model, options.modelProviders)
+          const isolationRaw = str(body, 'isolation')
+          const isolation = isolationRaw === null ? undefined : asIsolation(isolationRaw)
+          const presetId = normalizePresetId(str(body, 'presetId'))
           const now = options.now()
           const task: TaskRecord = {
             id: newTaskId(),
@@ -206,6 +313,8 @@ export function registerTaskboardRoutes(ctx: Context, options: TaskboardRoutesOp
             blocked: false,
             execution,
             model,
+            ...(isolation !== undefined ? { isolation } : {}),
+            ...(presetId !== undefined ? { presetId } : {}),
             version: 1,
             createdAt: now,
             updatedAt: now,
@@ -227,7 +336,9 @@ export function registerTaskboardRoutes(ctx: Context, options: TaskboardRoutesOp
       }
 
       // ------------------------------------------- POST /tasks/:id/{action}
-      const actionMatch = pathname.match(new RegExp(`^${ROUTE_PREFIX}/tasks/([^/]+)/(\\w+)$`))
+      // (\w+ after the id would not match hyphenated actions like
+      // worktree-remove, hence the explicit class.)
+      const actionMatch = pathname.match(new RegExp(`^${ROUTE_PREFIX}/tasks/([^/]+)/([\\w-]+)$`))
       if (actionMatch !== null) {
         const id = actionMatch[1]!
         const action = actionMatch[2]!
@@ -258,6 +369,18 @@ export function registerTaskboardRoutes(ctx: Context, options: TaskboardRoutesOp
             if (body.execution !== undefined) next.execution = normalizeExecution(body.execution as { mode?: string; cron?: string }, options.now())
             if (body.model === null) next.model = undefined
             else if (body.model !== undefined) next.model = checkModel(body.model, options.modelProviders)
+            // Isolation may change only before the first execution (分支与基线
+            // 取决于该选择 — plan §3.1: 执行开始后锁定).
+            const isolationRaw = str(body, 'isolation')
+            if (isolationRaw !== null) {
+              if (task.executions.length > 0 || task.status === 'in_progress') {
+                throw new Error('Error: invalid_input: isolation 已锁定（任务已有执行记录），不可修改')
+              }
+              next.isolation = asIsolation(isolationRaw)
+            }
+            // Preset may change any time: each run composes fresh.
+            if (body.presetId === null) delete next.presetId
+            else if (body.presetId !== undefined) next.presetId = normalizePresetId(str(body, 'presetId'))!
             next.version = task.version + 1
             next.updatedAt = options.now()
             next.updatedBy = { kind: 'user' }
@@ -292,6 +415,31 @@ export function registerTaskboardRoutes(ctx: Context, options: TaskboardRoutesOp
             json(res, { ok: true, value: summarize(next) })
             return
           }
+          if (action === 'reject') {
+            // Card quick-reject: back to todo + optional user comment in one
+            // atomic mutation (a failed move never strands an orphan comment).
+            const ifVersion = num(body, 'ifVersion')
+            if (ifVersion === undefined || ifVersion === null) throw new Error('Error: version_conflict: ifVersion required')
+            if (ifVersion !== task.version) throw new Error(`Error: version_conflict: stale version ${ifVersion} (current ${task.version})`)
+            if (!canTransition(task.status, 'todo')) throw new Error(`Error: invalid_transition: illegal transition ${task.status} → todo`)
+            const next = structuredClone(task)
+            next.status = 'todo'
+            next.version = task.version + 1
+            next.updatedAt = options.now()
+            next.updatedBy = { kind: 'user' }
+            syncClaim(next, 'todo', options.now())
+            const commentText = str(body, 'body') ?? ''
+            if (commentText.trim().length > 0) {
+              next.comments.push({ id: newCommentId(), body: normalizeBody(commentText), version: 1, createdAt: options.now() })
+            }
+            await store.mutate('task-moved', ledger => {
+              const i = ledger.tasks.findIndex(t => t.id === id)
+              ledger.tasks[i] = next
+              return [next]
+            })
+            json(res, { ok: true, value: summarize(next) })
+            return
+          }
           if (action === 'comment') {
             const bodyText = str(body, 'body') ?? ''
             const comment = { id: newCommentId(), body: normalizeBody(bodyText), version: 1, createdAt: options.now() }
@@ -311,6 +459,34 @@ export function registerTaskboardRoutes(ctx: Context, options: TaskboardRoutesOp
             const purge = body.purge === true
             if (purge) {
               if (task.trashedAt === undefined) throw new Error('Error: invalid_input: purge requires a trashed task (soft-delete first)')
+              // Worktree safety before purge (plan §3.3, 0.3.1): refuse while
+              // uncommitted work remains; otherwise clean the worktree and
+              // the task branch along with the ledger entry.
+              if (options.git !== undefined) {
+                const ws = workspaces.get(task.workspaceId)
+                if (ws !== undefined) {
+                  const path = worktreePathOf(ws.path, id)
+                  try {
+                    await options.git.removeWorktree(ws.path, path)
+                  } catch (error) {
+                    const message = error instanceof Error ? error.message : String(error)
+                    if (message.includes('未提交修改')) {
+                      throw new Error(`Error: invalid_input: ${message}；请先处理这些改动（提交、续跑或手动保存）再物理清除任务`)
+                    }
+                    if (/not a working tree|not a working-tree/i.test(message)) {
+                      // An unregistered leftover dir: plain fs removal.
+                      await rm(path, { recursive: true, force: true })
+                    } else {
+                      throw new Error(`Error: invalid_input: ${message}`)
+                    }
+                  }
+                  if (task.branch !== undefined) {
+                    try {
+                      await options.git.deleteBranch(ws.path, task.branch)
+                    } catch { /* best effort: the branch may outlive the task */ }
+                  }
+                }
+              }
               await store.mutate('task-deleted', ledger => {
                 ledger.tasks = ledger.tasks.filter(t => t.id !== id)
                 return []
@@ -338,7 +514,10 @@ export function registerTaskboardRoutes(ctx: Context, options: TaskboardRoutesOp
               json(res, f.res, 501)
               return
             }
-            const result = await options.run(id)
+            // `reuse: true` = 续跑: keep a live worktree/branch as-is instead
+            // of resetting to a fresh baseline (0.3.1).
+            const runOptions = body.reuse === true ? { reuseWorktree: true } : undefined
+            const result = await options.run(id, runOptions)
             if (result.ok) json(res, { ok: true, value: result }, 202)
             else {
               const f = fail('invalid_input', result.error)
@@ -360,6 +539,78 @@ export function registerTaskboardRoutes(ctx: Context, options: TaskboardRoutesOp
             }
             return
           }
+          if (action === 'merge') {
+            // ⇥ 合并 (detail page, user-only): merge the task branch into the
+            // main worktree with --no-ff; conflicts are reported verbatim.
+            if (options.git === undefined) {
+              const f = fail('invalid_input', 'git integration unavailable')
+              json(res, f.res, 501)
+              return
+            }
+            if (task.branch === undefined) throw new Error('Error: invalid_input: 该任务还没有 worktree 分支（未隔离执行过）')
+            if (task.status === 'in_progress') throw new Error('Error: invalid_input: 任务执行中，不能合并')
+            if (task.executions.some(e => e.outcome === 'running')) throw new Error('Error: invalid_input: 任务执行中，不能合并')
+            const ws = workspaces.get(task.workspaceId)
+            if (ws === undefined) throw new Error('Error: not_found: unknown workspace')
+            // No-op detection (0.3.1): a branch with no commits over HEAD
+            // merges as "already up to date" — report that instead of landing
+            // a bogus 已合并 comment.
+            let noop = false
+            try {
+              noop = await options.git.isAncestor(ws.path, task.branch)
+            } catch { /* fail-soft: proceed to the real merge */ }
+            if (noop) {
+              json(res, { ok: true, value: { merged: false, noop: true, branch: task.branch } })
+              return
+            }
+            try {
+              await options.git.merge(ws.path, task.branch)
+            } catch (error) {
+              throw new Error(`Error: invalid_input: ${error instanceof Error ? error.message : String(error)}`)
+            }
+            const mergedComment = { id: newCommentId(), body: normalizeBody(`[系统] 分支 ${task.branch} 已合并到主工作区（--no-ff）。`), version: 1, createdAt: options.now() }
+            const next = structuredClone(task)
+            next.comments.push(mergedComment)
+            next.version = task.version + 1
+            next.updatedAt = options.now()
+            await store.mutate('comment-added', ledger => {
+              const i = ledger.tasks.findIndex(t => t.id === id)
+              ledger.tasks[i] = next
+              return [next]
+            })
+            json(res, { ok: true, value: { merged: true, branch: task.branch } })
+            return
+          }
+          if (action === 'worktree-remove') {
+            // 🗑 删除 worktree (detail page): refuses uncommitted changes;
+            // optionally deletes the task branch after the worktree is gone.
+            if (options.git === undefined) {
+              const f = fail('invalid_input', 'git integration unavailable')
+              json(res, f.res, 501)
+              return
+            }
+            if (task.executions.some(e => e.outcome === 'running')) throw new Error('Error: invalid_input: 任务执行中，不能删除 worktree')
+            const ws = workspaces.get(task.workspaceId)
+            if (ws === undefined) throw new Error('Error: not_found: unknown workspace')
+            const path = worktreePathOf(ws.path, id)
+            try {
+              await options.git.removeWorktree(ws.path, path)
+            } catch (error) {
+              throw new Error(`Error: invalid_input: ${error instanceof Error ? error.message : String(error)}`)
+            }
+            let branchDeleted = false
+            let branchError: string | undefined
+            if (body.deleteBranch === true && task.branch !== undefined) {
+              try {
+                await options.git.deleteBranch(ws.path, task.branch)
+                branchDeleted = true
+              } catch (error) {
+                branchError = error instanceof Error ? error.message : String(error)
+              }
+            }
+            json(res, { ok: true, value: { removed: true, branchDeleted, ...(branchError !== undefined ? { branchError } : {}) } })
+            return
+          }
           const f = fail('not_found', `unknown action ${action}`)
           json(res, f.res, f.status)
         } catch (error) {
@@ -369,6 +620,43 @@ export function registerTaskboardRoutes(ctx: Context, options: TaskboardRoutesOp
         return
       }
 
+      // -------------------------------------- POST /worktree-cleanup (⚙ 诊断)
+      if (pathname === `${ROUTE_PREFIX}/worktree-cleanup`) {
+        try {
+          if (options.git === undefined) {
+            const f = fail('invalid_input', 'git integration unavailable')
+            json(res, f.res, 501)
+            return
+          }
+          const workspaceId = str(body, 'workspaceId') ?? ''
+          const taskId = str(body, 'taskId') ?? ''
+          const ws = workspaces.get(workspaceId)
+          if (ws === undefined) throw new Error('Error: not_found: unknown workspace')
+          // Only dirs owned by NO ledger task may be cleaned here; live tasks
+          // remove their worktree from the detail page.
+          if (store.get(taskId) !== undefined) throw new Error('Error: invalid_input: 任务仍在看板中，请从任务详情页删除其 worktree')
+          const path = worktreePathOf(ws.path, taskId)
+          try {
+            await options.git.removeWorktree(ws.path, path)
+          } catch (error) {
+            const message = error instanceof Error ? error.message : String(error)
+            // An unregistered leftover (git no longer knows this worktree):
+            // fall back to direct fs removal — the dir lives inside the
+            // plugin's own .dsh-worktrees scope.
+            if (/not a working tree|not a working-tree/i.test(message)) {
+              await rm(path, { recursive: true, force: true })
+            } else {
+              throw new Error(`Error: invalid_input: ${message}`)
+            }
+          }
+          json(res, { ok: true, value: { cleaned: true, path } })
+        } catch (error) {
+          const f = toFail(error)
+          json(res, f.res, f.status)
+        }
+        return
+      }
+
       res.writeHead(404)
       res.end()
     } catch (error) {

package/src/host/tools.ts

@@ -21,6 +21,7 @@
 import type { WorkspaceRegistry } from '@deepseek-ai/dsh-workspace'
 import { defineTool } from './sdk.ts'
 import {
+  asIsolation,
   asStatus,
   asUrgency,
   canTransition,
@@ -74,11 +75,13 @@ function taskDetail(t: TaskRecord & { effectivePrompt?: string }): string {
     `任务 ${t.id} 「${t.title}」`,
     `状态: ${t.status} (v${t.version}) · 紧急度: ${t.urgency} · 项目: ${t.workspaceId}${t.blocked ? ' · 受阻' : ''}`,
     `执行方式: ${t.execution.mode}${t.execution.cron !== undefined ? ` cron=${t.execution.cron}` : ''}`,
+    `隔离: ${t.isolation === 'none' ? '关闭（原目录执行）' : 'Git Worktree'}${t.branch !== undefined ? `（分支 ${t.branch}）` : ''}`,
   ]
   const holder = isClaimedBy(t)
   if (holder !== undefined) lines.push(`认领: agent ${String(holder).slice(0, 24)}（持有期间其他会话不可移动）`)
   if (t.execution.nextRunAt !== undefined) lines.push(`下次触发: ${new Date(t.execution.nextRunAt).toISOString()}`)
   if (t.model !== undefined) lines.push(`固定模型: ${t.model.provider}/${t.model.model}`)
+  if (t.presetId !== undefined) lines.push(`执行模式: ${t.presetId}（未指定时为部署默认 preset）`)
   lines.push(`描述: ${t.description.length > 0 ? t.description : '（无）'}`)
   lines.push(`执行 Prompt: ${t.effectivePrompt ?? effectivePrompt(t)}`)
   if (t.comments.length > 0) {
@@ -348,6 +351,14 @@ export function registerTaskboardTools(ctx: ToolContextFace, deps: ToolDeps): Ar
           model: { type: 'string', description: 'Provider-owned model id.' },
         },
       },
+      isolation: {
+        type: 'string',
+        description: 'Code isolation for executions: "worktree" (default — each run gets a fresh git worktree on branch task/<标题>+<taskId>) or "none" (run in the project directory, zero git interaction).',
+      },
+      presetId: {
+        type: 'string',
+        description: 'Agent preset the execution session is composed from (its tool set / persona); default = the deployment default preset. Optional.',
+      },
     },
     output: {
       schema: JSON_OUT,
@@ -366,6 +377,8 @@ export function registerTaskboardTools(ctx: ToolContextFace, deps: ToolDeps): Ar
       prompt?: string
       execution?: { mode?: string; cron?: string }
       model?: { provider?: string; model?: string }
+      isolation?: string
+      presetId?: string
     }, exec: unknown) {
       try {
         const { actor } = caller(exec as ToolRunContext)
@@ -380,6 +393,8 @@ export function registerTaskboardTools(ctx: ToolContextFace, deps: ToolDeps): Ar
         }
         const execution = normalizeExecution(args.execution ?? {}, deps.now())
         const model = args.model !== undefined ? checkModel(deps, args.model) : undefined
+        const isolation = args.isolation === undefined ? undefined : asIsolation(args.isolation)
+        const presetId = args.presetId?.trim() || undefined
         const now = deps.now()
         const task: TaskRecord = {
           id: newTaskId(),
@@ -392,6 +407,8 @@ export function registerTaskboardTools(ctx: ToolContextFace, deps: ToolDeps): Ar
           blocked: false,
           execution,
           model,
+          ...(isolation !== undefined ? { isolation } : {}),
+          ...(presetId !== undefined ? { presetId } : {}),
           version: 1,
           createdAt: now,
           updatedAt: now,

package/src/index.ts

@@ -21,6 +21,7 @@ import type {} from '@deepseek-ai/dsh-system-prompt'
 import type {} from '@deepseek-ai/dsh-agent'
 import { PROTOCOL_SECTION_NAME, PROTOCOL_SECTION_ORDER, TASKBOARD_PROTOCOL } from './host/protocol-text.ts'
 import { DEFAULT_MAX_CONCURRENT, ExecutionService, type EventsFace } from './host/execution.ts'
+import { createGitFace } from './host/git.ts'
 import { registerTaskboardRoutes } from './host/routes.ts'
 import { SchedulerService } from './host/scheduler.ts'
 import { dshHomePath } from './host/sdk.ts'
@@ -85,6 +86,10 @@ export function apply(ctx: Context): void {
       }),
     }
 
+    // The narrow git face shared by execution (worktree isolation) and the
+    // routes (merge / remove / workspace detection).
+    const git = createGitFace()
+
     wsCtx.inject(['agents'], (agentCtx: Context) => {
       const execution = new ExecutionService({
         store,
@@ -100,6 +105,23 @@ export function apply(ctx: Context): void {
         },
         events,
         now,
+        git,
+        // Preset composition (0.3.3): mirror apiproxy's composeAgent — resolve
+        // the id BEFORE creation (the session header snapshots meta), mount
+        // inside the factory's setup callback. No roster service → undefined
+        // (bare host composition, the pre-preset behavior).
+        composeAgent: async (presetId) => {
+          const presets = agentCtx.get('agentPresets') as {
+            resolve(id?: string): Promise<{ id: string }>
+            mount(agentCtx: unknown, id?: string): Promise<unknown>
+          } | undefined
+          if (presets === undefined) return undefined
+          const resolved = await presets.resolve(presetId)
+          return {
+            agentPreset: resolved.id,
+            setup: async (ctx: unknown) => { await presets.mount(ctx, resolved.id) },
+          }
+        },
         renameSession: (sessionId, title) => {
           // Best-effort: pin the execution session's title to the task title
           // through the log-backed session-title service (user-sourced rename).
@@ -127,9 +149,10 @@ export function apply(ctx: Context): void {
           store,
           workspaces: workspaceFace(wsCtx.workspaceRegistry),
           now,
-          run: (taskId: string) => execution.run(taskId, 'manual'),
+          run: (taskId: string, runOptions?: { reuseWorktree?: boolean }) => execution.run(taskId, 'manual', runOptions),
           cancel: (taskId: string) => execution.cancel(taskId),
           modelProviders,
+          git,
         })
         return () => disposeRoutes?.()
       })

package/src/shared/api.ts

@@ -41,7 +41,7 @@ export type ApiResult<T> = ApiOk<T> | ApiFail
 export type StateResponse = TaskLedger
 
 /** Workspace listing for the UI pickers. */
-export type WorkspaceView = { id: string; path: string; title: string; sessionCount: number }
+export type WorkspaceView = { id: string; path: string; title: string; sessionCount: number; gitAvailable?: boolean }
 
 /** Create-task request body (actor is always the GUI user). */
 export type CreateTaskBody = {
@@ -52,6 +52,10 @@ export type CreateTaskBody = {
   prompt?: string
   execution?: { mode?: string; cron?: string }
   model?: { provider: string; model: string }
+  /** Code isolation for executions ('worktree' | 'none'); omitted = default. */
+  isolation?: string
+  /** Agent preset for execution sessions; omitted = deployment default. */
+  presetId?: string
 }
 
 /** Update-task request body (ifVersion mandatory). */
@@ -66,19 +70,54 @@ export type UpdateTaskBody = {
   workspaceId?: string
   execution?: { mode?: string; cron?: string }
   model?: { provider: string; model: string } | null
+  /** Change isolation; locked once the task has execution history. */
+  isolation?: string
+  /** Change the execution preset (takes effect on the next run). */
+  presetId?: string | null
 }
 
 /** Move-task request body (ifVersion mandatory; the user MAY move to done). */
 export type MoveTaskBody = { ifVersion: number; status: string }
 
+/**
+ * Quick-reject request body (card ✗ button): move back to todo plus an
+ * optional user comment, committed as ONE ledger mutation so a failed move
+ * can never strand an orphan comment.
+ */
+export type RejectTaskBody = { ifVersion: number; body?: string }
+
 /** Comment request body. */
 export type CommentBody = { body: string }
 
 /** Delete request body (purge=true physically removes a trashed task). */
 export type DeleteTaskBody = { ifVersion?: number; purge?: boolean }
 
-/** Run request body (P3). */
-export type RunTaskBody = Record<string, never>
+/** Run request body; `reuse: true` = 续跑 (keep a live worktree as-is). */
+export type RunTaskBody = { reuse?: boolean }
+
+/** Merge outcome: `noop: true` = the branch had no commits over HEAD (nothing merged). */
+export type MergeBranchResponse = { merged: boolean; noop?: boolean; branch: string }
+
+/** Remove a task's worktree; optionally delete its branch too. */
+export type WorktreeRemoveBody = { deleteBranch?: boolean }
+
+/** One orphan worktree directory (exists on disk, owned by no live task). */
+export type OrphanWorktree = { workspaceId: string; workspacePath: string; taskId: string; path: string }
+
+/** A git-enabled workspace whose .gitignore does not cover the worktree dir. */
+export type GitignoreSuggestion = { workspaceId: string; workspacePath: string }
+
+/** Health-diagnostics response (⚙ panel). */
+export type DiagnosticsResponse = {
+  revision: number
+  tasks: number
+  /** Executions currently marked `running`. */
+  staleRunning: number
+  /** Worktree directories whose task no longer exists in the ledger. */
+  orphanWorktrees: OrphanWorktree[]
+  /** Git workspaces whose .gitignore does not ignore the worktree dir. */
+  gitIgnoreSuggestions: GitignoreSuggestion[]
+}
 
 /** One task (full record) response. */
 export type TaskResponse = TaskRecord