dsh-taskboard 0.1.2 → 0.2.0

package/src/host/tools.ts

@@ -26,13 +26,16 @@ import {
   canTransition,
   effectivePrompt,
   isClaim,
+  isClaimedBy,
   newCommentId,
   newTaskId,
   normalizeBody,
   normalizeExecution,
+  normalizeModel,
   normalizePrompt,
   normalizeTitle,
   summarize,
+  syncClaim,
   type Actor,
   type TaskModel,
   type TaskRecord,
@@ -72,6 +75,8 @@ function taskDetail(t: TaskRecord & { effectivePrompt?: string }): string {
     `状态: ${t.status} (v${t.version}) · 紧急度: ${t.urgency} · 项目: ${t.workspaceId}${t.blocked ? ' · 受阻' : ''}`,
     `执行方式: ${t.execution.mode}${t.execution.cron !== undefined ? ` cron=${t.execution.cron}` : ''}`,
   ]
+  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}`)
   lines.push(`描述: ${t.description.length > 0 ? t.description : '（无）'}`)
@@ -151,6 +156,22 @@ export interface ToolDeps {
   workspaces: WorkspaceFace
   /** Current epoch ms (injectable for tests). */
   now: () => number
+  /**
+   * Registered model provider routes (from the host llm runtime), for
+   * advisory validation of pinned models; undefined = runtime unavailable,
+   * in which case only the structural check applies.
+   */
+  modelProviders?: () => string[] | undefined
+}
+
+/** Validate a pinned model: structural check always, provider route when known. */
+function checkModel(deps: ToolDeps, raw: unknown): TaskModel {
+  const model = normalizeModel(raw)
+  const providers = deps.modelProviders?.()
+  if (providers !== undefined && !providers.includes(model.provider)) {
+    throw new ToolError(ERR.invalidInput, `model provider "${model.provider}" has no registered route (available: ${providers.join(', ')})`)
+  }
+  return model
 }
 
 /** Resolve the calling agent's actor and session id. */
@@ -358,9 +379,7 @@ export function registerTaskboardTools(ctx: ToolContextFace, deps: ToolDeps): Ar
           throw new ToolError(ERR.invalidTransition, 'a new task cannot start as done/archived')
         }
         const execution = normalizeExecution(args.execution ?? {}, deps.now())
-        if (args.model !== undefined && (typeof args.model.provider !== 'string' || typeof args.model.model !== 'string')) {
-          throw new ToolError(ERR.invalidInput, 'model must be { provider: string, model: string }')
-        }
+        const model = args.model !== undefined ? checkModel(deps, args.model) : undefined
         const now = deps.now()
         const task: TaskRecord = {
           id: newTaskId(),
@@ -372,7 +391,7 @@ export function registerTaskboardTools(ctx: ToolContextFace, deps: ToolDeps): Ar
           status,
           blocked: false,
           execution,
-          model: args.model as TaskModel | undefined,
+          model,
           version: 1,
           createdAt: now,
           updatedAt: now,
@@ -483,10 +502,11 @@ export function registerTaskboardTools(ctx: ToolContextFace, deps: ToolDeps): Ar
         if (!canTransition(task.status, to)) {
           throw new ToolError(ERR.invalidTransition, `illegal transition ${task.status} → ${to}`)
         }
-        // Exclusive hold: while a task is in_progress under an agent, no other
-        // session may move it at all (that would be a takeover).
-        if (task.status === 'in_progress' && task.updatedBy.kind === 'agent' && task.updatedBy.sessionId !== actor.sessionId) {
-          throw new ToolError(ERR.forbidden, `task is held by session ${task.updatedBy.sessionId}; never take over another session's claim`)
+        // Exclusive hold: while a task is in_progress under a session
+        // (explicit claimedBy — an agent claim or a live execution), no other
+        // session may move it (that would be a takeover).
+        if (task.status === 'in_progress' && task.claimedBy !== undefined && task.claimedBy !== actor.sessionId) {
+          throw new ToolError(ERR.forbidden, `task is held by session ${task.claimedBy}; never take over another session's claim`)
         }
         // Claim boundary: the calling session must belong to the task's project.
         if (isClaim(task.status, to)) {
@@ -501,6 +521,8 @@ export function registerTaskboardTools(ctx: ToolContextFace, deps: ToolDeps): Ar
         next.updatedAt = deps.now()
         next.updatedBy = actor
         if (isClaim(task.status, to)) next.blocked = false
+        // Record the holder on a claim; every move out of in_progress releases it.
+        syncClaim(next, to, deps.now(), isClaim(task.status, to) ? actor.sessionId : undefined)
         await store.mutate('task-moved', ledger => {
           const i = ledger.tasks.findIndex(t => t.id === args.id)
           ledger.tasks[i] = next

package/src/index.ts

@@ -20,7 +20,7 @@ import type {} from '@deepseek-ai/dsh-tools'
 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 { ExecutionService, type EventsFace } from './host/execution.ts'
+import { DEFAULT_MAX_CONCURRENT, ExecutionService, type EventsFace } from './host/execution.ts'
 import { registerTaskboardRoutes } from './host/routes.ts'
 import { SchedulerService } from './host/scheduler.ts'
 import { dshHomePath } from './host/sdk.ts'
@@ -43,6 +43,8 @@ export const inject = ['tools', 'systemPrompt']
 export function apply(ctx: Context): void {
   const store = new TaskStore({ file: dshHomePath(LEDGER_FILE) })
   const now = () => Date.now()
+  // Global execution concurrency cap (DSH_TASKBOARD_MAX_CONCURRENT overrides).
+  const maxConcurrent = Math.max(1, Number.parseInt(process.env.DSH_TASKBOARD_MAX_CONCURRENT ?? '', 10) || DEFAULT_MAX_CONCURRENT)
 
   // Agent workflow protocol (claim discipline, retry rules, done-gate).
   const disposeSection = ctx.systemPrompt.section({
@@ -56,10 +58,24 @@ export function apply(ctx: Context): void {
   // workspace registry (claim boundary + project execution need it).
   ctx.inject(['workspaceRegistry'], (wsCtx: Context) => {
     const disposers: Array<() => void> = []
+
+    // Registered model provider routes (from the host llm runtime), read
+    // lazily at call time so late availability still applies; undefined when
+    // the runtime is absent → only structural model validation runs.
+    const modelProviders = (): string[] | undefined => {
+      try {
+        const llm = wsCtx.get('llm') as { listProviders?: () => Array<{ id: string }> } | undefined
+        return llm === undefined || typeof llm.listProviders !== 'function'
+          ? undefined
+          : llm.listProviders().map(p => p.id)
+      } catch { return undefined }
+    }
+
     disposers.push(...registerTaskboardTools(wsCtx, {
       store,
       workspaces: workspaceFace(wsCtx.workspaceRegistry),
       now,
+      modelProviders,
     }))
 
     // Settlement listener over the session event bus.
@@ -101,6 +117,7 @@ export function apply(ctx: Context): void {
             return read === undefined ? undefined : read.call(selection)
           } catch { return undefined }
         },
+        maxConcurrent,
       })
 
       // /dsh-taskboard routes (the run action reaches the execution service).
@@ -111,13 +128,20 @@ export function apply(ctx: Context): void {
           workspaces: workspaceFace(wsCtx.workspaceRegistry),
           now,
           run: (taskId: string) => execution.run(taskId, 'manual'),
+          cancel: (taskId: string) => execution.cancel(taskId),
+          modelProviders,
         })
         return () => disposeRoutes?.()
       })
 
+      // Startup reconciliation: executions left 'running' by a previous host
+      // process are marked failed and their tasks handed back to todo (their
+      // settlement watchers died with that process).
+      void execution.reconcile()
+
       // Host-side cron scheduler: due scheduled tasks execute even with no
-      // browser open.
-      const scheduler = new SchedulerService({ store, execution, now })
+      // browser open. Shares the execution concurrency cap.
+      const scheduler = new SchedulerService({ store, execution, now, maxConcurrent })
       scheduler.start()
       disposers.push(() => scheduler.dispose())
 

package/src/shared/protocol.ts

@@ -271,6 +271,15 @@ export type TaskRecord = {
   blocked: boolean
   execution: ExecutionConfig
   model?: TaskModel
+  /**
+   * The session currently holding the in-progress claim (explicit claim or a
+   * live execution). Present only while `status === 'in_progress'`: any move
+   * out of in_progress releases it. `updatedBy` is audit-only — user edits no
+   * longer erase the holder.
+   */
+  claimedBy?: string
+  /** When the current holder claimed the task (epoch ms). */
+  claimedAt?: number
   version: number
   createdAt: number
   updatedAt: number
@@ -278,10 +287,28 @@ export type TaskRecord = {
   updatedBy: Actor
   comments: CommentRecord[]
   executions: ExecutionRecord[]
+  /** How many older execution records were pruned by the retention cap. */
+  executionsPruned?: number
   /** Soft-delete marker set by agent `taskboard_delete`; user confirms the purge. */
   trashedAt?: number
 }
 
+/** Retention cap: how many execution records each task keeps (oldest pruned). */
+export const MAX_EXECUTIONS = 20
+
+/**
+ * Enforce the execution-record retention cap on one task (in place): keep the
+ * newest {@link MAX_EXECUTIONS} records, count the dropped ones in
+ * `executionsPruned`. Running records are always the newest, never dropped.
+ * @param task - the task to prune.
+ */
+export function pruneExecutions(task: TaskRecord): void {
+  if (task.executions.length <= MAX_EXECUTIONS) return
+  const dropped = task.executions.length - MAX_EXECUTIONS
+  task.executions = task.executions.slice(-MAX_EXECUTIONS)
+  task.executionsPruned = (task.executionsPruned ?? 0) + dropped
+}
+
 /** The whole durable ledger. */
 export type TaskLedger = {
   schemaVersion: number
@@ -424,9 +451,51 @@ export function effectivePrompt(task: TaskRecord): string {
  * @param task - the task.
  */
 export function isClaimedBy(task: TaskRecord): string | undefined {
-  return task.status === 'in_progress' && task.updatedBy.kind === 'agent'
-    ? task.updatedBy.sessionId
-    : undefined
+  return task.status === 'in_progress' && task.claimedBy !== undefined ? task.claimedBy : undefined
+}
+
+/**
+ * Maintain the explicit claim fields around a status change: entering
+ * in_progress under a session records the holder (an execution-start or an
+ * agent claim); every move out of in_progress releases the claim (handoff,
+ * give-back, cancel). A user-driven move into in_progress records no holder —
+ * no session works on it yet.
+ * @param task - the task being written (mutated in place).
+ * @param to - the target status.
+ * @param now - current epoch ms.
+ * @param holder - the session id claiming the task, when applicable.
+ */
+export function syncClaim(task: TaskRecord, to: TaskStatus, now: number, holder?: string): void {
+  if (to !== 'in_progress') {
+    delete task.claimedBy
+    delete task.claimedAt
+  } else if (holder !== undefined) {
+    task.claimedBy = holder
+    task.claimedAt = now
+  }
+}
+
+/**
+ * Validate and normalize a pinned model: `{ provider, model }`, both
+ * non-empty trimmed strings.
+ * @param raw - the raw input.
+ * @returns the normalized model.
+ * @throws when the shape or the fields are invalid.
+ */
+export function normalizeModel(raw: unknown): TaskModel {
+  if (typeof raw !== 'object' || raw === null) {
+    throw new Error('model must be { provider: string, model: string }')
+  }
+  const { provider, model } = raw as { provider?: unknown; model?: unknown }
+  if (typeof provider !== 'string' || typeof model !== 'string') {
+    throw new Error('model must be { provider: string, model: string }')
+  }
+  const p = provider.trim()
+  const m = model.trim()
+  if (p.length === 0 || m.length === 0) {
+    throw new Error('model.provider and model.model must be non-empty strings')
+  }
+  return { provider: p, model: m }
 }
 
 /**

package/src/shared/version.ts

@@ -0,0 +1,9 @@
+/**
+ * The plugin package version shown in the board UI. Kept in sync with
+ * package.json by a regression test (tests lock drift).
+ *
+ * @module dsh-taskboard/shared/version
+ */
+
+/** The package version (must equal package.json "version"). */
+export const PLUGIN_VERSION = '0.2.0'