dsh-taskboard 0.2.2 → 0.3.3

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,6 +70,10 @@ 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). */
@@ -84,8 +92,32 @@ 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

package/src/shared/protocol.ts

@@ -102,6 +102,29 @@ export const URGENCY_COLOR: Readonly<Record<Urgency, string>> = {
 // Execution
 // ---------------------------------------------------------------------------
 
+/**
+ * Per-task code isolation mode (0.3.0).
+ * - `worktree`: each execution runs in a fresh `git worktree` on a dedicated
+ *   task branch (`task/<标题>+<taskId>`) under `<workspace>/.dsh-worktrees/`.
+ * - `none`: run in the workspace directory as before, zero git interaction.
+ * Omitted = the default `worktree`; non-git projects auto-degrade at run
+ * time (the execution record carries an `isolationNote` explaining why).
+ */
+export type IsolationMode = 'worktree' | 'none'
+
+/** Validate an isolation value. */
+export function asIsolation(raw: string): IsolationMode {
+  if (raw !== 'worktree' && raw !== 'none') {
+    throw new Error("isolation must be 'worktree' or 'none'")
+  }
+  return raw
+}
+
+/** Resolve a task's effective isolation (omitted → the worktree default). */
+export function effectiveIsolation(task: Pick<TaskRecord, 'isolation'>): IsolationMode {
+  return task.isolation === undefined ? 'worktree' : task.isolation
+}
+
 /** How a task may run. */
 export type ExecutionMode = 'claim' | 'scheduled'
 
@@ -237,6 +260,9 @@ export type CommentRecord = {
   threadId?: string
 }
 
+/** One commit produced by an isolated execution (hash + subject). */
+export type CommitInfo = { hash: string; subject: string }
+
 /** One execution attempt of a task. */
 export type ExecutionRecord = {
   id: string
@@ -248,6 +274,30 @@ export type ExecutionRecord = {
   endedAt?: number
   outcome: 'running' | 'succeeded' | 'failed' | 'cancelled'
   error?: string
+  /** Code isolation actually used (`none` also covers degraded worktree runs). */
+  isolation?: IsolationMode
+  /** Why worktree isolation degraded to running in the original directory. */
+  isolationNote?: string
+  /** The task branch this execution worked on (worktree runs only). */
+  branch?: string
+  /** Absolute path of the dedicated worktree (worktree runs only). */
+  worktreePath?: string
+  /** HEAD of the task branch before the execution started. */
+  baseCommit?: string
+  /** HEAD at settlement. */
+  headCommit?: string
+  /** Commits between baseCommit and headCommit (hash + subject; capped at 50, newest first). */
+  commits?: CommitInfo[]
+  /** Total commits before the evidence cap (equals commits.length when under it). */
+  commitsTotal?: number
+  /** Uncommitted changes present at settlement (`git status --porcelain` lines; capped at 100). */
+  dirtyFiles?: string[]
+  /** Total uncommitted lines before the evidence cap. */
+  dirtyFilesTotal?: number
+  /** Aggregate diff stat between baseCommit and headCommit. */
+  diffStat?: string
+  /** How many files differ between baseCommit and headCommit. */
+  changedFiles?: number
 }
 
 /** The per-model override a task may carry; absent = session default model. */
@@ -271,6 +321,20 @@ export type TaskRecord = {
   blocked: boolean
   execution: ExecutionConfig
   model?: TaskModel
+  /** Code isolation for executions (omitted = the worktree default; see {@link IsolationMode}). */
+  isolation?: IsolationMode
+  /**
+   * The agent preset execution sessions are composed from (omitted = the
+   * deployment default preset). Recorded on the session header and mounted
+   * via the presets service at creation — this is what hands the session its
+   * tool set. Editable any time (each run composes fresh).
+   */
+  presetId?: string
+  /**
+   * The task branch fixed at the FIRST worktree creation (`task/<标题>+<taskId>`).
+   * Renaming the task afterwards never changes it (history preservation).
+   */
+  branch?: string
   /**
    * The session currently holding the in-progress claim (explicit claim or a
    * live execution). Present only while `status === 'in_progress'`: any move

package/src/shared/version.ts

@@ -6,4 +6,4 @@
  */
 
 /** The package version (must equal package.json "version"). */
-export const PLUGIN_VERSION = '0.2.2'
+export const PLUGIN_VERSION = '0.3.3'