dsh-taskboard 0.5.5 → 0.6.1

package/src/host/session-sync.ts

@@ -50,40 +50,290 @@ export function titleFromText(text: string): string {
   return firstLine.slice(0, 50).trim()
 }
 
+/**
+ * Detect whether a session represents a subagent child conversation.
+ * Subagents are created by agent delegation (e.g. invoke_subagent / subagents service)
+ * and should never be automatically converted into user tasks on the taskboard.
+ */
+export function isSubagentSession(
+  sessionId: string,
+  sessionMeta?: unknown,
+  event?: { type: string; data?: unknown },
+): boolean {
+  if (typeof sessionId === 'string') {
+    if (sessionId.startsWith('subagent-') || sessionId.startsWith('child-') || sessionId.startsWith('delegate-')) {
+      return true
+    }
+  }
+
+  if (typeof sessionMeta === 'object' && sessionMeta !== null) {
+    const s = sessionMeta as {
+      header?: Record<string, unknown>
+      meta?: Record<string, unknown>
+      options?: Record<string, unknown>
+    }
+
+    const header = s.header
+    const meta = s.meta
+    const options = s.options
+
+    // Check origin
+    if (header?.origin === 'subagent' || meta?.origin === 'subagent') return true
+
+    // Check parent session lineage
+    if (
+      header?.parentSession !== undefined
+      || header?.parentSessionId !== undefined
+      || meta?.parentSession !== undefined
+      || meta?.parentSessionId !== undefined
+    ) {
+      return true
+    }
+
+    // Check delegation depth
+    if (typeof header?.delegationDepth === 'number' && header.delegationDepth > 0) return true
+    if (typeof meta?.delegationDepth === 'number' && meta.delegationDepth > 0) return true
+    if (typeof options?.subagentDepth === 'number' && options.subagentDepth > 0) return true
+  }
+
+  if (event !== undefined) {
+    if (event.type === 'subagent/descriptor' || event.type === 'subagent/start' || event.type === 'subagent/end') {
+      return true
+    }
+    if (typeof event.data === 'object' && event.data !== null) {
+      const d = event.data as Record<string, unknown>
+      if (
+        d.origin === 'subagent'
+        || d.subagent === true
+        || typeof d.subagentId === 'string'
+        || typeof d.parentSession === 'string'
+      ) {
+        return true
+      }
+    }
+  }
+
+  return false
+}
+
+/**
+ * Detect whether a session represents an active working conversation.
+ * Inspects state, status, isWorking/isBusy methods, running flags, and active turns.
+ */
+export function isSessionActiveWorking(session: unknown): boolean {
+  if (typeof session !== 'object' || session === null) return false
+  const s = session as Record<string, unknown>
+
+  // 1. Method checks
+  if (typeof s.isWorking === 'function') {
+    try { if (Boolean((s.isWorking as () => boolean)())) return true } catch { /* ignore */ }
+  } else if (s.isWorking === true) {
+    return true
+  }
+
+  if (typeof s.isBusy === 'function') {
+    try { if (Boolean((s.isBusy as () => boolean)())) return true } catch { /* ignore */ }
+  } else if (s.busy === true || s.isBusy === true) {
+    return true
+  }
+
+  // 2. Boolean flags
+  if (s.running === true || s.active === true || s.isGenerating === true || s.generating === true) {
+    return true
+  }
+
+  // 3. State string
+  if (typeof s.state === 'string') {
+    const st = s.state.toLowerCase()
+    if (st === 'running' || st === 'working' || st === 'busy' || st === 'generating' || st === 'executing') {
+      return true
+    }
+  }
+
+  // 4. Status string
+  if (typeof s.status === 'string') {
+    const st = s.status.toLowerCase()
+    if (st === 'running' || st === 'working' || st === 'busy' || st === 'active' || st === 'generating' || st === 'executing') {
+      return true
+    }
+  }
+
+  // 5. Active turn checks
+  if (s.activeTurn !== undefined && s.activeTurn !== null && s.activeTurn !== false) {
+    return true
+  }
+  if (s.currentTurn !== undefined && s.currentTurn !== null) {
+    if (typeof s.currentTurn === 'object') {
+      const ct = s.currentTurn as Record<string, unknown>
+      if (ct.status === 'running' || ct.state === 'running' || ct.outcome === 'running' || ct.endedAt === undefined) {
+        return true
+      }
+    } else {
+      return true
+    }
+  }
+
+  // 6. Turns list
+  if (Array.isArray(s.turns) && s.turns.length > 0) {
+    const lastTurn = s.turns[s.turns.length - 1]
+    if (typeof lastTurn === 'object' && lastTurn !== null) {
+      const lt = lastTurn as Record<string, unknown>
+      if (lt.status === 'running' || lt.state === 'running' || lt.outcome === 'running' || (lt.startedAt !== undefined && lt.endedAt === undefined)) {
+        return true
+      }
+    }
+  }
+
+  return false
+}
+
 /** Dependencies required by the external session sync service. */
 export interface SessionSyncDeps {
   store: TaskStore
   workspaces: WorkspaceFace
   events: EventsFace
+  sessions?: {
+    get?: (id: string) => unknown
+    list?: () => unknown[]
+  }
   now: () => number
+  scanIntervalMs?: number
 }
 
+/** Default scan interval: 4s. */
+export const DEFAULT_SCAN_INTERVAL_MS = 4000
+
 /**
  * Service that synchronizes external workspace sessions into the taskboard.
  */
 export class ExternalSessionSyncService {
   private readonly unsubscribe: () => void
+  private readonly ignoredSessions = new Set<string>()
+  private scanTimer?: NodeJS.Timeout | number
 
   constructor(private readonly deps: SessionSyncDeps) {
     this.unsubscribe = deps.events.onSessionEvent((sessionId, event, sessionMeta) => {
       void this.handleSessionEvent(sessionId, event, sessionMeta)
     })
+
+    const interval = deps.scanIntervalMs ?? DEFAULT_SCAN_INTERVAL_MS
+    if (interval > 0) {
+      this.scanTimer = setInterval(() => {
+        void this.scanActiveSessions()
+      }, interval)
+    }
   }
 
-  /** Detach listener on teardown. */
+  /** Detach listener and clear scanner on teardown. */
   dispose(): void {
     this.unsubscribe()
+    if (this.scanTimer !== undefined) {
+      clearInterval(this.scanTimer as NodeJS.Timeout)
+      this.scanTimer = undefined
+    }
+  }
+
+  /**
+   * Periodic active scan: checks whether external sessions linked to board tasks
+   * are actively working, ensuring tasks in `in_review` / `todo` / `backlog`
+   * automatically pull back to `in_progress`.
+   */
+  async scanActiveSessions(): Promise<void> {
+    const snapshot = this.deps.store.snapshot()
+    if (!defaultSyncExternalSessionsOf(snapshot.settings)) return
+    if (this.deps.sessions === undefined) return
+
+    const now = this.deps.now()
+    const tasks = snapshot.tasks.filter(t => t.trashedAt === undefined)
+
+    for (const task of tasks) {
+      const sessionId = task.claimedBy ?? task.executions[task.executions.length - 1]?.sessionId
+      if (sessionId === undefined || typeof sessionId !== 'string') continue
+      if (this.ignoredSessions.has(sessionId) || sessionId.startsWith('session-taskboard-')) continue
+
+      let session: unknown
+      try {
+        session = this.deps.sessions.get?.(sessionId)
+      } catch { /* ignore */ }
+
+      if (session === undefined && typeof this.deps.sessions.list === 'function') {
+        try {
+          const list = this.deps.sessions.list()
+          session = list?.find(s => (s as { id?: string })?.id === sessionId)
+        } catch { /* ignore */ }
+      }
+
+      if (session === undefined || session === null) continue
+      if (isSubagentSession(sessionId, session)) {
+        this.ignoredSessions.add(sessionId)
+        continue
+      }
+
+      const isWorking = isSessionActiveWorking(session)
+      if (isWorking) {
+        if (task.status !== 'in_progress') {
+          await this.deps.store.mutate('task-updated', (ledger) => {
+            const current = ledger.tasks.find(t => t.id === task.id)
+            if (current === undefined || current.trashedAt !== undefined) return undefined
+            current.status = 'in_progress'
+            current.claimedBy = sessionId
+            current.claimedAt = current.claimedAt ?? now
+            current.updatedAt = now
+            current.updatedBy = { kind: 'agent', sessionId }
+            const hasRunning = current.executions.some(e => e.sessionId === sessionId && e.outcome === 'running')
+            if (!hasRunning) {
+              current.executions.push({
+                id: newExecutionId(),
+                sessionId,
+                trigger: 'manual',
+                startedAt: now,
+                outcome: 'running',
+                isolation: 'none',
+              })
+            }
+            return [current]
+          })
+        }
+      }
+    }
   }
 
   private async handleSessionEvent(
     sessionId: string,
     event: { type: string; data?: unknown },
-    sessionMeta?: { header?: { cwd?: string } },
+    sessionMeta?: {
+      header?: { cwd?: string; origin?: string; parentSession?: string; parentSessionId?: string; delegationDepth?: number }
+      meta?: { origin?: string; parentSession?: string; delegationDepth?: number }
+      options?: { subagentDepth?: number }
+    },
   ): Promise<void> {
-    // 1. Ignore taskboard's internal execution sessions
-    if (sessionId.startsWith('session-taskboard-')) return
+    // 1. Check if already ignored
+    if (this.ignoredSessions.has(sessionId)) return
+
+    // 2. Ignore taskboard's internal execution sessions
+    if (sessionId.startsWith('session-taskboard-')) {
+      this.ignoredSessions.add(sessionId)
+      return
+    }
+
+    // 3. Ignore subagent sessions (delegated children)
+    if (isSubagentSession(sessionId, sessionMeta, event)) {
+      this.ignoredSessions.add(sessionId)
+      // If a task was previously created for this subagent before detection, clean it up
+      await this.deps.store.mutate('task-deleted', (ledger) => {
+        const idx = ledger.tasks.findIndex(
+          t => t.claimedBy === sessionId && t.createdBy.kind === 'agent' && t.createdBy.sessionId === sessionId,
+        )
+        if (idx >= 0) {
+          ledger.tasks.splice(idx, 1)
+          return []
+        }
+        return undefined
+      })
+      return
+    }
 
-    // 2. Check if external session sync is enabled in board settings
+    // 4. Check if external session sync is enabled in board settings
     const snapshot = this.deps.store.snapshot()
     if (!defaultSyncExternalSessionsOf(snapshot.settings)) return
 
@@ -99,6 +349,17 @@ export class ExternalSessionSyncService {
       return
     }
 
+    if (
+      event.type === 'turn/step'
+      || event.type === 'turn/progress'
+      || event.type === 'agent/step'
+      || event.type === 'agent/thought'
+      || event.type === 'agent/turn/start'
+    ) {
+      await this.ensureSessionInProgress(sessionId, now)
+      return
+    }
+
     if (event.type === 'session/title') {
       await this.handleSessionTitle(sessionId, event.data, now)
       return
@@ -110,6 +371,41 @@ export class ExternalSessionSyncService {
     }
   }
 
+  private async ensureSessionInProgress(sessionId: string, now: number): Promise<void> {
+    await this.deps.store.mutate('task-updated', (ledger) => {
+      const task = ledger.tasks.find(
+        t => t.claimedBy === sessionId || t.executions.some(e => e.sessionId === sessionId),
+      )
+      if (task === undefined || task.trashedAt !== undefined) return undefined
+
+      let changed = false
+      if (task.status !== 'in_progress') {
+        task.status = 'in_progress'
+        task.claimedBy = sessionId
+        task.claimedAt = task.claimedAt ?? now
+        changed = true
+      }
+      const hasRunning = task.executions.some(e => e.sessionId === sessionId && e.outcome === 'running')
+      if (!hasRunning) {
+        task.executions.push({
+          id: newExecutionId(),
+          sessionId,
+          trigger: 'manual',
+          startedAt: now,
+          outcome: 'running',
+          isolation: 'none',
+        })
+        changed = true
+      }
+      if (changed) {
+        task.updatedAt = now
+        task.updatedBy = { kind: 'agent', sessionId }
+        return [task]
+      }
+      return undefined
+    })
+  }
+
   private async handleTurnStart(sessionId: string, cwd: string | undefined, now: number): Promise<void> {
     // Resolve workspace
     let wsId: string | undefined
@@ -204,7 +500,6 @@ export class ExternalSessionSyncService {
 
   private async handleUserMessage(sessionId: string, msgData: unknown, now: number): Promise<void> {
     const text = extractUserMessageText(msgData)
-    if (text.trim().length === 0) return
 
     await this.deps.store.mutate('task-updated', (ledger) => {
       const task = ledger.tasks.find(
@@ -213,19 +508,44 @@ export class ExternalSessionSyncService {
       if (task === undefined || task.trashedAt !== undefined) return undefined
 
       let changed = false
-      // If title is default placeholder "会话 ...", replace with prompt summary
-      if (task.title.startsWith('会话 ') && task.title.length <= 16) {
-        const derived = titleFromText(text)
-        if (derived.length > 0) {
-          task.title = normalizeTitle(derived)
+      if (text.trim().length > 0) {
+        // If title is default placeholder "会话 ...", replace with prompt summary
+        if (task.title.startsWith('会话 ') && task.title.length <= 16) {
+          const derived = titleFromText(text)
+          if (derived.length > 0) {
+            task.title = normalizeTitle(derived)
+            changed = true
+          }
+        }
+        // If description is empty, record initial prompt
+        if (task.description.length === 0) {
+          task.description = text.slice(0, 2000)
           changed = true
         }
       }
-      // If description is empty, record initial prompt
-      if (task.description.length === 0) {
-        task.description = text.slice(0, 2000)
+
+      // If task was in in_review, todo, or backlog, user message resumes work -> move to in_progress
+      if (task.status !== 'in_progress') {
+        task.status = 'in_progress'
+        task.claimedBy = sessionId
+        task.claimedAt = now
+        changed = true
+      }
+
+      // Ensure running execution exists
+      const hasRunning = task.executions.some(e => e.sessionId === sessionId && e.outcome === 'running')
+      if (!hasRunning) {
+        task.executions.push({
+          id: newExecutionId(),
+          sessionId,
+          trigger: 'manual',
+          startedAt: now,
+          outcome: 'running',
+          isolation: 'none',
+        })
         changed = true
       }
+
       if (changed) {
         task.updatedAt = now
         task.updatedBy = { kind: 'user' }

package/src/host/store.ts

@@ -10,6 +10,7 @@ import { mkdir, open, readFile, rename } from 'node:fs/promises'
 import { dirname, join } from 'node:path'
 import {
   LEDGER_SCHEMA_VERSION,
+  asBoardSettings,
   emptyLedger,
   isPlausibleTaskRecord,
   pruneExecutions,
@@ -81,7 +82,20 @@ export class TaskStore {
             task.claimedAt = task.updatedAt
           }
         }
-        this.ledger = { schemaVersion: LEDGER_SCHEMA_VERSION, revision: parsed.revision, tasks }
+        let settings = undefined
+        if (parsed.settings !== undefined) {
+          try {
+            settings = asBoardSettings(parsed.settings)
+          } catch {
+            console.warn('[dsh-taskboard] dropping invalid board settings on load')
+          }
+        }
+        this.ledger = {
+          schemaVersion: LEDGER_SCHEMA_VERSION,
+          revision: parsed.revision,
+          tasks,
+          ...(settings !== undefined ? { settings } : {}),
+        }
       }
     } catch (error) {
       const code = (error as NodeJS.ErrnoException).code

package/src/index.ts

@@ -94,15 +94,31 @@ export function apply(ctx: Context): void {
     // Settlement listener over the session event bus.
     const events: EventsFace = {
       onSessionEvent: (listener) => wsCtx.on('session/event', (session, event) => {
-        listener(session.id, event as { type: string; data?: unknown }, session as { header?: { cwd?: string } })
+        listener(session.id, event as { type: string; data?: unknown }, session as never)
       }),
     }
 
+    let agentSessions: { get?: (id: string) => unknown; list?: () => unknown[] } | undefined
+
     // External workspace sessions sync service (0.5.4).
     const sessionSync = new ExternalSessionSyncService({
       store,
       workspaces: workspaceFace(wsCtx.workspaceRegistry),
       events,
+      sessions: {
+        get: id => {
+          try {
+            const registry = (agentSessions ?? wsCtx.get('sessions') ?? wsCtx.get('sessionRegistry') ?? wsCtx.root?.get('sessions')) as { get?: (id: string) => unknown } | undefined
+            return registry?.get?.(id)
+          } catch { return undefined }
+        },
+        list: () => {
+          try {
+            const registry = (agentSessions ?? wsCtx.get('sessions') ?? wsCtx.get('sessionRegistry') ?? wsCtx.root?.get('sessions')) as { list?: () => unknown[] } | undefined
+            return registry?.list?.() ?? []
+          } catch { return [] }
+        },
+      },
       now,
     })
     disposers.push(() => sessionSync.dispose())
@@ -112,6 +128,7 @@ export function apply(ctx: Context): void {
     const git = createGitFace()
 
     wsCtx.inject(['agents'], (agentCtx: Context) => {
+      agentSessions = agentCtx.get('sessions') as { get?: (id: string) => unknown; list?: () => unknown[] } | undefined
       const execution = new ExecutionService({
         store,
         agents: {
@@ -160,6 +177,16 @@ export function apply(ctx: Context): void {
             return read === undefined ? undefined : read.call(selection)
           } catch { return undefined }
         },
+        setPermission: (sessionId, permission) => {
+          try {
+            const permService = agentCtx.get('permissionPresets') as { set(session: unknown, name: string): void } | undefined
+            const sessions = agentCtx.get('sessions') as { get(id: string): unknown } | undefined
+            const session = sessions?.get(sessionId)
+            if (session !== undefined && permService !== undefined) {
+              permService.set(session, permission)
+            }
+          } catch { /* cosmetic */ }
+        },
         maxConcurrent,
       })
 
@@ -175,6 +202,93 @@ export function apply(ctx: Context): void {
           modelProviders,
           git,
           templates,
+          promptCompletions: async () => {
+            try {
+              const skillsService = agentCtx.get('skills') as { list?(options?: unknown): Promise<Array<{ name: string; description?: string }>> } | undefined
+              const commandsService = agentCtx.get('commands') as { list?(): Array<{ name: string; description?: string; input?: { hint?: string } }> } | undefined
+              const rawSkills = skillsService?.list ? await skillsService.list().catch(() => []) : []
+              const rawCommands = commandsService?.list ? commandsService.list() : []
+              return {
+                skills: Array.isArray(rawSkills) ? rawSkills.map(s => ({ name: s.name, description: s.description })) : [],
+                commands: Array.isArray(rawCommands) ? rawCommands.map(c => ({ name: c.name, description: c.description, hint: c.input?.hint })) : [],
+              }
+            } catch {
+              return { skills: [], commands: [] }
+            }
+          },
+          modelCatalog: async () => {
+            try {
+              type ModelItem = {
+                provider: string
+                model: string
+                name?: string
+                description?: string
+                reasoning?: {
+                  efforts: Array<{ id: string; name: string; description?: string }>
+                  defaultEffort?: string
+                }
+              }
+              const models: ModelItem[] = []
+
+              const llm = (agentCtx.get('llm') ?? wsCtx.get('llm')) as {
+                listProviders?(): Array<{ id: string; name?: string }>
+                listModels?(provider: string): Promise<Array<{ id: string; name?: string; description?: string }>>
+                resolveModelInfo?(provider: string, model: string): Promise<{ reasoning?: { efforts: Array<{ id: string; name: string; description?: string }>; defaultEffort?: string } }>
+                resolveModel?(provider: string, model: string): Promise<{ reasoning?: { efforts: Array<{ id: string; name: string; description?: string }>; defaultEffort?: string } }>
+              } | undefined
+
+              if (llm?.listProviders !== undefined && llm.listModels !== undefined) {
+                const providers = llm.listProviders()
+                for (const p of providers) {
+                  try {
+                    const list = await llm.listModels(p.id)
+                    for (const m of list) {
+                      let reasoning: { efforts: Array<{ id: string; name: string; description?: string }>; defaultEffort?: string } | undefined
+                      try {
+                        const meta = llm.resolveModelInfo !== undefined
+                          ? await llm.resolveModelInfo(p.id, m.id)
+                          : llm.resolveModel !== undefined ? await llm.resolveModel(p.id, m.id) : undefined
+                        if (meta?.reasoning !== undefined) {
+                          reasoning = meta.reasoning
+                        }
+                      } catch { /* ignore */ }
+
+                      models.push({
+                        provider: p.id,
+                        model: m.id,
+                        name: m.name,
+                        ...(m.description ? { description: m.description } : {}),
+                        ...(reasoning !== undefined ? { reasoning } : {}),
+                      })
+                    }
+                  } catch { /* continue */ }
+                }
+              }
+
+              const presetsService = agentCtx.get('agentPresets') as {
+                list?(): Promise<{ ok: boolean; value?: { presets: Array<{ id: string; name?: string; isDefault?: boolean }> } } | Array<{ id: string; name?: string; isDefault?: boolean }>>
+              } | undefined
+              const presets: Array<{ id: string; name?: string }> = []
+              let defaultPresetId: string | undefined
+
+              if (presetsService?.list !== undefined) {
+                try {
+                  const raw = await presetsService.list()
+                  const list = (raw as { ok?: boolean; value?: { presets?: unknown[] } }).ok === true
+                    ? (raw as { value: { presets: Array<{ id: string; name?: string; isDefault?: boolean }> } }).value.presets
+                    : Array.isArray(raw) ? raw : []
+                  for (const p of list) {
+                    presets.push({ id: p.id, name: p.name })
+                    if (p.isDefault) defaultPresetId = p.id
+                  }
+                } catch { /* continue */ }
+              }
+
+              return { models, presets, ...(defaultPresetId !== undefined ? { defaultPresetId } : {}) }
+            } catch {
+              return { models: [], presets: [] }
+            }
+          },
         })
         return () => disposeRoutes?.()
       })

package/src/shared/api.ts

@@ -56,6 +56,8 @@ export type CreateTaskBody = {
   isolation?: string
   /** Agent preset for execution sessions; omitted = deployment default. */
   presetId?: string
+  /** Execution permission preset ('workspace-write' | 'read-only' | 'danger-full-access'); omitted = default. */
+  permission?: string
   /** Acceptance checklist item texts (host mints ids, all unchecked). */
   checklist?: string[]
 }
@@ -76,6 +78,8 @@ export type UpdateTaskBody = {
   isolation?: string
   /** Change the execution preset (takes effect on the next run). */
   presetId?: string | null
+  /** Change the execution permission (0.5.5; 'workspace-write' | 'read-only' | 'danger-full-access'). */
+  permission?: string | null
   /** Replace the whole checklist (GUI owner surface); null clears it. */
   checklist?: unknown
 }
@@ -133,6 +137,8 @@ export type TaskTemplateSpec = {
   model?: TaskModel
   isolation?: string
   presetId?: string
+  /** Execution permission preset (0.5.5). */
+  permission?: string
   /** Checklist item texts (host mints ids at create time). */
   checklist?: string[]
 }
@@ -160,6 +166,47 @@ export type UpdateSettingsBody = {
   defaultIsolation?: string
   /** Automatically capture external workspace sessions into the taskboard. */
   syncExternalSessions?: boolean
+  /** Default permission preset for NEW tasks ('workspace-write' | 'read-only' | 'danger-full-access'). */
+  defaultPermission?: string
+}
+
+/** Prompt completion item for skills and slash commands (0.5.5). */
+export type PromptCompletionItem = {
+  name: string
+  kind: 'skill' | 'command'
+  description?: string
+  hint?: string
+}
+
+/** Prompt completions response (0.5.5). */
+export type PromptCompletionsResponse = {
+  commands: PromptCompletionItem[]
+  skills: PromptCompletionItem[]
+}
+
+/** Model item in catalog (0.5.5). */
+export type CatalogModelItem = {
+  provider: string
+  model: string
+  name?: string
+  description?: string
+  reasoning?: {
+    efforts: Array<{ id: string; name: string; description?: string }>
+    defaultEffort?: string
+  }
+}
+
+/** Preset item in catalog (0.5.5). */
+export type CatalogPresetItem = {
+  id: string
+  name?: string
+}
+
+/** Model and preset catalog response (0.5.5). */
+export type ModelCatalogResponse = {
+  models: CatalogModelItem[]
+  presets: CatalogPresetItem[]
+  defaultPresetId?: string
 }
 
 /** Import dry-run response (0.4.0): every task classified, nothing written. */