dsh-taskboard 0.5.4 → 0.6.0

package/src/index.ts

@@ -27,6 +27,7 @@ import { SchedulerService } from './host/scheduler.ts'
 import { dshHomePath } from './host/sdk.ts'
 import { TaskStore } from './host/store.ts'
 import { TemplateStore } from './host/templates.ts'
+import { ExternalSessionSyncService } from './host/session-sync.ts'
 import { registerTaskboardTools, workspaceFace } from './host/tools.ts'
 
 /** Ledger file name under the DSH home. */
@@ -93,15 +94,41 @@ 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 })
+        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())
+
     // The narrow git face shared by execution (worktree isolation) and the
     // routes (merge / remove / workspace detection).
     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: {
@@ -150,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,
       })
 
@@ -165,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[]
 }
@@ -158,6 +164,49 @@ export type SettingsResponse = BoardSettings
 export type UpdateSettingsBody = {
   /** Default code isolation for NEW tasks ('worktree' | 'none'). */
   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. */

package/src/shared/protocol.ts

@@ -134,6 +134,30 @@ export function effectiveIsolation(task: Pick<TaskRecord, 'isolation'>): Isolati
   return task.isolation === undefined ? DEFAULT_ISOLATION : task.isolation
 }
 
+/**
+ * Execution permission preset (0.5.5). Matches DSH permission presets:
+ * - 'workspace-write': 可写入工作区 (factory default)
+ * - 'read-only': 仅可查看
+ * - 'danger-full-access': 完全权限
+ */
+export type PermissionMode = 'workspace-write' | 'read-only' | 'danger-full-access'
+
+/** Factory default permission preset (0.5.5). */
+export const DEFAULT_PERMISSION: PermissionMode = 'workspace-write'
+
+/** Canonical list of supported permission modes. */
+export const ALL_PERMISSIONS: readonly PermissionMode[] = ['workspace-write', 'read-only', 'danger-full-access']
+
+/** Validate and normalize a permission string into a valid {@link PermissionMode}. */
+export function asPermission(raw: unknown): PermissionMode {
+  if (typeof raw !== 'string') return DEFAULT_PERMISSION
+  const normalized = raw.trim()
+  if (normalized === 'workspace-write' || normalized === 'workspaceWrite') return 'workspace-write'
+  if (normalized === 'read-only' || normalized === 'readOnly') return 'read-only'
+  if (normalized === 'danger-full-access' || normalized === 'fullAccess') return 'danger-full-access'
+  throw new Error("permission must be 'workspace-write', 'read-only', or 'danger-full-access'")
+}
+
 /**
  * Board-level settings persisted with the ledger (0.5.0). Only fields the
  * user explicitly set are present; absent fields follow factory defaults.
@@ -141,6 +165,10 @@ export function effectiveIsolation(task: Pick<TaskRecord, 'isolation'>): Isolati
 export type BoardSettings = {
   /** Default code isolation applied when a NEW task is created without an explicit choice. */
   defaultIsolation?: IsolationMode
+  /** Automatically capture external workspace sessions into the taskboard (default: false). */
+  syncExternalSessions?: boolean
+  /** Default permission preset applied when a NEW task is created without an explicit choice (0.5.5, default: 'workspace-write'). */
+  defaultPermission?: PermissionMode
 }
 
 /** Validate raw input into sanitized {@link BoardSettings} (unknown fields dropped). */
@@ -156,6 +184,15 @@ export function asBoardSettings(raw: unknown): BoardSettings {
     }
     out.defaultIsolation = asIsolation(e.defaultIsolation)
   }
+  if (e.syncExternalSessions !== undefined) {
+    if (typeof e.syncExternalSessions !== 'boolean') {
+      throw new Error('syncExternalSessions must be a boolean')
+    }
+    out.syncExternalSessions = e.syncExternalSessions
+  }
+  if (e.defaultPermission !== undefined) {
+    out.defaultPermission = asPermission(e.defaultPermission)
+  }
   return out
 }
 
@@ -164,6 +201,16 @@ export function defaultIsolationOf(settings?: BoardSettings): IsolationMode {
   return settings?.defaultIsolation ?? DEFAULT_ISOLATION
 }
 
+/** The effective external session sync switch (board setting → factory default false). */
+export function defaultSyncExternalSessionsOf(settings?: BoardSettings): boolean {
+  return settings?.syncExternalSessions ?? false
+}
+
+/** The effective default permission preset for NEW tasks (board setting → factory default 'workspace-write'). */
+export function defaultPermissionOf(settings?: BoardSettings): PermissionMode {
+  return settings?.defaultPermission ?? DEFAULT_PERMISSION
+}
+
 /** How a task may run. */
 export type ExecutionMode = 'claim' | 'scheduled'
 
@@ -406,6 +453,10 @@ export type TaskRecord = {
    * tool set. Editable any time (each run composes fresh).
    */
   presetId?: string
+  /**
+   * Execution permission preset (0.5.5; see {@link PermissionMode}).
+   */
+  permission?: PermissionMode
   /**
    * Definition-of-Done acceptance checklist (0.4.0). Agents may append items
    * and check/uncheck them (with evidence); the GUI may edit the whole list.
@@ -906,6 +957,7 @@ export function validateImportedTask(raw: unknown, now: number): { ok: true; tas
       ...(typeof e.model === 'object' && e.model !== null ? { model: normalizeModel(e.model) } : {}),
       ...(typeof e.isolation === 'string' && (e.isolation === 'worktree' || e.isolation === 'none') ? { isolation: e.isolation } : {}),
       ...(typeof e.presetId === 'string' && e.presetId.trim().length > 0 ? { presetId: e.presetId.trim() } : {}),
+      ...(typeof e.permission === 'string' ? { permission: asPermission(e.permission) } : {}),
       ...(Array.isArray(e.checklist) ? { checklist: normalizeChecklist(e.checklist) } : {}),
       ...(typeof e.branch === 'string' ? { branch: e.branch } : {}),
       ...(status === 'in_progress' && typeof e.claimedBy === 'string' ? { claimedBy: e.claimedBy } : {}),
@@ -997,6 +1049,7 @@ export type TaskSummary = {
   executionMode: ExecutionMode
   nextRunAt?: number
   model?: TaskModel
+  permission?: PermissionMode
   version: number
   claimOwner?: string
   commentCount: number
@@ -1023,6 +1076,7 @@ export function summarize(task: TaskRecord): TaskSummary {
     executionMode: task.execution.mode,
     nextRunAt: task.execution.nextRunAt,
     model: task.model,
+    permission: task.permission,
     version: task.version,
     claimOwner: isClaimedBy(task),
     commentCount: task.comments.length,

package/src/shared/version.ts

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