@linxin666/dsh-client-ui-task-board 0.4.1 → 0.4.3

package/src/index.ts

@@ -14,11 +14,15 @@ import type {} from '@deepseek-ai/dsh-system-prompt'
 import type {} from '@deepseek-ai/dsh-api-gateway'
 import type {} from '@deepseek-ai/dsh-workspace'
 import type {} from '@deepseek-ai/dsh-host-webserver'
+import type {} from '@deepseek-ai/dsh-tools'
+import type { ToolDefinition } from '@deepseek-ai/dsh-tools'
 import type { LlmRuntime } from '@deepseek-ai/dsh-llm'
-import { TaskBoardHostService } from './host-service.ts'
+import { TaskBoardHostService, type HostTimerFace, type TaskBoardTeamDispatcher } from './host-service.ts'
 import { parseTaskDraft, TaskParseError } from './host-ai.ts'
 import { TASK_PERMISSIONS, type TaskPermission } from './core/tasks.ts'
+import { DEFAULT_SUBTASK_DEPTH, SUBTASK_DEPTH_MAX, SUBTASK_DEPTH_MIN } from './core/subtask.ts'
 import { DEFAULT_SESSION_PERMISSION } from './core/handover.ts'
+import { buildTaskBoardTools } from './host/agent-tools.ts'
 import { makeTaskBoardRoutes } from './host-routes.ts'
 import { mountOnce } from './mount-once.ts'
 
@@ -31,16 +35,18 @@ export const DEFAULT_PROXY_TOKEN_ENV = 'DSH_TASK_BOARD_PROXY_TOKEN'
 export const inject = ['systemPrompt', 'typertGateway', 'workspaceRegistry', 'webServer', 'agents', 'commands']
 
 /** Model-facing announcement: plugin presence, capabilities, and limits. */
-export const TASK_BOARD_GUIDANCE = '本机已安装 dsh-task-board 插件（DSH Web GUI 的任务看板）：侧边栏「任务看板」入口；在 dsh-web 插件全家桶仓库（packages/dsh-task-board）统一维护，经聚合包 web-ui-all 一键安装。能力：多列看板管理任务；Host 权威账本；关闭浏览器后仍由 Host 执行和结算；任务可钉住工作区、agent 预设和权限；支持 Host 本地时区的 5 段 cron，错过的触发点不补跑；可选且默认关闭的空闲系统睡眠保护允许屏幕熄灭，但不承诺拦截合盖、手动睡眠、休眠、关机或唤醒已睡眠机器。执行消耗 API 额度。用户提到「任务看板 / 看板 / 定时任务」时即指本插件，请据此协作。若你同时用 todo_write 维护会话顶部的可见计划列表，最终回复前必须再次调用 todo_write 收尾：没有剩余工作时不要保留 in_progress，已完成的最后一步要标为 completed。'
+export const TASK_BOARD_GUIDANCE = '本机已安装 dsh-task-board 插件（DSH Web GUI 的任务看板）：侧边栏「任务看板」入口；在 dsh-web 插件全家桶仓库（packages/dsh-task-board）统一维护，经聚合包 web-ui-all 一键安装。能力：多列看板管理任务；Host 权威账本；关闭浏览器后仍由 Host 执行和结算；任务可钉住工作区、agent 预设和权限；任务可建子任务（深度上限可配 1..3，默认 1 层，子任务不能再带子任务），执行父任务会并发执行其子任务树，子任务可单独覆盖权限与模型；另注册 task_board_* agent 工具（list/get/create/update/set_parent/run/manage/schedule），任何会话都可直接读写看板、子任务与定时计划，但运行任务会真实执行并消耗额度，高于会话默认权限的绑定仍必须由用户在 GUI 人工确认（工具刻意不提供确认能力）；支持 Host 本地时区的 5 段 cron，错过的触发点不补跑；可选且默认关闭的空闲系统睡眠保护允许屏幕熄灭，但不承诺拦截合盖、手动睡眠、休眠、关机或唤醒已睡眠机器。执行消耗 API 额度。用户提到「任务看板 / 看板 / 定时任务」时即指本插件，请据此协作。若你同时用 todo_write 维护会话顶部的可见计划列表，最终回复前必须再次调用 todo_write 收尾：没有剩余工作时不要保留 in_progress，已完成的最后一步要标为 completed。'
 
 /**
  * Plugin config, validated by the same-named schemastery schema.
  *
  * This schema IS the board's settings page: the 0.1.7 Host serves one
  * configuration form per profile entry from the entry's own Config, so the
- * three fields the browser card edits are marked volatile — the Loader commits
+ * fields the browser card edits are marked volatile — the Loader commits
  * an edit into the running fiber's references without remounting the row (no
- * settings document of the plugin's own exists any more).
+ * settings document of the plugin's own exists any more). A field without the
+ * marker is refused by the settings write path, which fences writes on
+ * volatility.
  */
 export interface Config {
   /**
@@ -67,8 +73,27 @@ export interface Config {
    * confirmation before it may run; cron refuses unconfirmed cards.
    */
   sessionDefaultPermission?: TaskPermission
+  /**
+   * Subtask depth limit, 1..3 (default 1). At 1 a task may carry one level of
+   * subtasks and a subtask cannot be given subtasks of its own; raising it
+   * allows deeper trees. Every extra level multiplies the sessions one run
+   * of the root task opens, so the ceiling is deliberately small.
+   */
+  maxSubtaskDepth?: Volatile<number>
+  /**
+   * Continuable-subagent provider the Agent Teams service uses to compose a
+   * teammate. Matches the Agent Teams tool plugin's `freshProvider` default;
+   * only team-mode runs use it.
+   */
+  teamProvider?: string
 }
 
+/**
+ * Continuable-subagent provider for fresh teammates, matching the Agent Teams
+ * tool plugin's own `freshProvider` default.
+ */
+export const DEFAULT_TEAM_PROVIDER = 'spawn'
+
 /**
  * The schema is left to inference rather than annotated with `z<Config>`: a
  * volatile field's parsed output is a `Volatile` reference while its accepted
@@ -82,6 +107,8 @@ export const Config = z.object({
   trustedProxyHosts: z.array(z.string()).default([]),
   proxyTokenEnv: z.string().min(1).default(DEFAULT_PROXY_TOKEN_ENV),
   sessionDefaultPermission: z.union(TASK_PERMISSIONS).default(DEFAULT_SESSION_PERMISSION),
+  maxSubtaskDepth: z.number().min(SUBTASK_DEPTH_MIN).max(SUBTASK_DEPTH_MAX).default(DEFAULT_SUBTASK_DEPTH).volatile(),
+  teamProvider: z.string().min(1).default(DEFAULT_TEAM_PROVIDER),
 })
 
 declare module '@deepseek-ai/cordis' {
@@ -130,9 +157,126 @@ export function resolveProxyAccess(config: Config | undefined, env: NodeJS.Proce
   return { trustedProxyHosts, proxyToken }
 }
 
+/** The registry face the agent tools register into. */
+interface AgentToolRegistry {
+  register(definition: ToolDefinition): () => void
+}
+
+/**
+ * Resolve the optional agent-tool registry. The board deliberately does not
+ * inject it: a deployment whose runtime serves no registry must still mount the
+ * whole board and lose only the agent-tool surface, the same tolerance the
+ * optional llm service gets.
+ * @param ctx - the plugin context.
+ * @returns the registry, or undefined when this deployment serves none.
+ */
+export function resolveToolRegistry(ctx: Context): AgentToolRegistry | undefined {
+  try {
+    const tools = ctx.get('tools') as AgentToolRegistry | undefined
+    return tools !== undefined && typeof tools.register === 'function' ? tools : undefined
+  } catch {
+    return undefined
+  }
+}
+
+/**
+ * Resolve the native cordis timer service (dsh-base's own `cordis-plugin-timer`
+ * row). The board arms its schedule through it so unloading the row clears
+ * every pending timer with the owning fiber, instead of the row tracking raw
+ * process handles by hand. A composition that serves no timer service keeps
+ * working on the process globals.
+ * @param ctx - the plugin context.
+ * @returns the timer face, or undefined when this deployment serves none.
+ */
+export function resolveHostTimers(ctx: Context): HostTimerFace | undefined {
+  try {
+    const timer = ctx.get('timer') as Partial<HostTimerFace> | undefined
+    if (timer === undefined) return undefined
+    return typeof timer.timeout === 'function' && typeof timer.interval === 'function'
+      ? { timeout: timer.timeout.bind(timer), interval: timer.interval.bind(timer) }
+      : undefined
+  } catch {
+    return undefined
+  }
+}
+
 /** Schema default, re-read for hand-built test contexts (the loader applies them normally). */
 const DEFAULT_ANNOUNCE = false
 
+/**
+ * How long one teammate may take to reach its durable active or failed edge.
+ * Agent Teams provisioning normally resolves in seconds; the bound exists so a
+ * hung spawn settles the subtask instead of holding the cascade open forever.
+ */
+const TEAMMATE_PROVISION_TIMEOUT_MS = 600_000
+
+/** The subset of the Agent Teams service this plugin drives. */
+interface AgentTeamsFace {
+  spawnTeammate(caller: unknown, request: {
+    name: string
+    description: string
+    prompt: Array<{ type: 'text'; text: string }>
+    context: 'fresh' | 'fork'
+    provider: string
+    signal: AbortSignal
+  }): Promise<{ member?: { id?: string; phase?: string; error?: string } }>
+}
+
+/**
+ * Resolve the optional Agent Teams service. Like the tool registry and the llm
+ * runtime, it is deliberately not injected: a deployment without Agent Teams
+ * must still mount the whole board and only lose team-mode runs.
+ * @param ctx - the plugin context.
+ * @returns the service, or undefined when this deployment serves none.
+ */
+export function resolveAgentTeams(ctx: Context): AgentTeamsFace | undefined {
+  try {
+    const teams = ctx.get('agentTeams') as AgentTeamsFace | undefined
+    return teams !== undefined && typeof teams.spawnTeammate === 'function' ? teams : undefined
+  } catch {
+    return undefined
+  }
+}
+
+/**
+ * Build the team dispatcher: the run's Lead session spawns one teammate per
+ * subtask through the Agent Teams service, and the teammate's session id is
+ * attached to that subtask's execution so the ordinary session monitor settles
+ * it. Returns undefined when the deployment serves no Agent Teams service or
+ * no live-agent registry, which makes a team run fail closed.
+ * @param ctx - the plugin context.
+ * @param provider - the continuable-subagent provider for fresh teammates.
+ * @returns the dispatcher, or undefined when team runs cannot be served.
+ */
+export function buildTeamDispatcher(ctx: Context, provider: string): TaskBoardTeamDispatcher | undefined {
+  const teams = resolveAgentTeams(ctx)
+  if (teams === undefined) return undefined
+  if (typeof (ctx.agents as { get?: unknown } | undefined)?.get !== 'function') return undefined
+  return {
+    async spawn(input) {
+      const lead = ctx.agents.get(input.leadSessionId as Parameters<typeof ctx.agents.get>[0])
+      if (lead === undefined) return { error: `lead session ${input.leadSessionId} is not live` }
+      try {
+        const result = await teams.spawnTeammate(lead, {
+          name: input.name,
+          description: input.description,
+          prompt: [{ type: 'text', text: input.prompt }],
+          context: 'fresh',
+          provider,
+          signal: AbortSignal.timeout(TEAMMATE_PROVISION_TIMEOUT_MS),
+        })
+        const member = result?.member
+        if (member === undefined) return { error: 'Agent Teams returned no teammate' }
+        if (member.phase === 'failed') return { error: member.error ?? 'teammate provisioning failed' }
+        if (typeof member.id !== 'string' || member.id === '') return { error: 'Agent Teams returned no teammate session' }
+        return { sessionId: member.id }
+      } catch (error) {
+        return { error: `teammate provisioning failed: ${error instanceof Error ? error.message : String(error)}` }
+      }
+    },
+  }
+}
+
 /**
  * Read the optional `llm` service. The board deliberately does not inject it:
  * a deployment without a model must still mount the board, and the parse route
@@ -153,8 +297,8 @@ export function resolveLlmRuntime(ctx: Context): LlmRuntime | undefined {
  * Activate the board's host half: ledger, routes, cron scheduler, power
  * inhibitor, and the model-facing announcement.
  *
- * The effective settings are the config the Host hands this row. The three
- * fields the browser card edits are schema-volatile, so the Loader commits an
+ * The effective settings are the config the Host hands this row. The fields
+ * the browser card edits are schema-volatile, so the Loader commits an
  * edit into the running fiber's references instead of remounting the row —
  * `sync` therefore reads them at use time and follows
  * `loader/volatile-update`, the event the Loader emits once it has committed
@@ -171,10 +315,15 @@ function applyImpl(ctx: Context, config?: Config): void {
   const announceToAgent = (): boolean => readConfigField(config?.announceToAgent, DEFAULT_ANNOUNCE)
   /** Current idle-sleep protection flag. */
   const preventIdleSleep = (): boolean => readConfigField(config?.preventIdleSleep, false)
+  /** Current subtask depth limit (read live: the settings card edits it in place). */
+  const maxSubtaskDepth = (): number => readConfigField(config?.maxSubtaskDepth, DEFAULT_SUBTASK_DEPTH)
 
   const host = new TaskBoardHostService(ctx.typertGateway, {
     workspaceRegistry: ctx.workspaceRegistry,
     sessionDefaultPermission: config?.sessionDefaultPermission ?? DEFAULT_SESSION_PERMISSION,
+    maxSubtaskDepth: maxSubtaskDepth(),
+    timers: resolveHostTimers(ctx),
+    team: buildTeamDispatcher(ctx, config?.teamProvider ?? DEFAULT_TEAM_PROVIDER),
     commandDispatcher: {
       async execute(sessionId, line, signal) {
         const agent = ctx.agents.get(sessionId)
@@ -187,6 +336,45 @@ function applyImpl(ctx: Context, config?: Config): void {
   // scheduler tick, which would roll schedules the board is not running.
   host.setConfiguration(enabled(), preventIdleSleep())
   host.start()
+
+  // Agent tools: the same Host ledger the browser drives, so any session can
+  // list, create, link, run and settle board work. Registration follows the
+  // master switch (a disabled board answers no tool call), and the mount
+  // effect below owns the disposers.
+  let disposeTools: (() => void) | undefined
+  const setToolsEnabled = (active: boolean): void => {
+    if (!active) {
+      disposeTools?.()
+      disposeTools = undefined
+      return
+    }
+    if (disposeTools !== undefined) return
+    const registry = resolveToolRegistry(ctx)
+    if (registry === undefined) return
+    const disposers = buildTaskBoardTools(host).map(tool => registry.register(tool))
+    disposeTools = () => {
+      for (const dispose of disposers.splice(0)) dispose()
+    }
+  }
+  setToolsEnabled(enabled())
+  // A registry that activates after this row (or a row activated before it) is
+  // followed through scoped injection where the runtime serves one; capture-only
+  // contexts without it register through the direct resolution above.
+  const scopedInject = (ctx as { inject?: (names: readonly string[], callback: (scoped: Context) => unknown) => unknown }).inject
+  if (typeof scopedInject === 'function') {
+    scopedInject.call(ctx, ['tools'], () => {
+      setToolsEnabled(enabled())
+      // Cordis unloads and re-runs this callback when the injected service's
+      // provider fiber changes, and the old registry dies with its provider.
+      // Releasing the guard here is what lets the callback register into the
+      // NEW registry instead of short-circuiting on the stale disposer.
+      return () => {
+        disposeTools?.()
+        disposeTools = undefined
+      }
+    })
+  }
+
   ctx.effect(() => {
     const disposers: Array<() => void> = []
     try {
@@ -199,18 +387,22 @@ function applyImpl(ctx: Context, config?: Config): void {
       })
       for (const route of routes) disposers.push(ctx.webServer.register(route))
     } catch (error) {
+      // A failed mount must not leave the agent tools bound to a disposed
+      // host: the effect cleanup never runs when this body throws.
+      setToolsEnabled(false)
       for (const dispose of disposers) dispose()
       host.dispose()
       throw error
     }
     return () => {
+      setToolsEnabled(false)
       for (const dispose of disposers) dispose()
       host.dispose()
     }
   }, 'task-board: host ledger, scheduler, and routes')
 
   let disposeSection: (() => void) | undefined
-  let applied: { enabled: boolean; announceToAgent: boolean; preventIdleSleep: boolean } | undefined
+  let applied: { enabled: boolean; announceToAgent: boolean; preventIdleSleep: boolean; maxSubtaskDepth: number } | undefined
 
   // Apply the current values to the host service and the announcement. A
   // commit that changes nothing visible is a no-op, so following a coarse
@@ -218,12 +410,14 @@ function applyImpl(ctx: Context, config?: Config): void {
   // under one disposer: re-registering first tears the old one down so a
   // duplicate-name registration never throws.
   const sync = (): void => {
-    const next = { enabled: enabled(), announceToAgent: announceToAgent(), preventIdleSleep: preventIdleSleep() }
-    if (applied !== undefined && applied.enabled === next.enabled && applied.announceToAgent === next.announceToAgent && applied.preventIdleSleep === next.preventIdleSleep) {
+    const next = { enabled: enabled(), announceToAgent: announceToAgent(), preventIdleSleep: preventIdleSleep(), maxSubtaskDepth: maxSubtaskDepth() }
+    if (applied !== undefined && applied.enabled === next.enabled && applied.announceToAgent === next.announceToAgent && applied.preventIdleSleep === next.preventIdleSleep && applied.maxSubtaskDepth === next.maxSubtaskDepth) {
       return
     }
     applied = next
+    host.ledger.setMaxSubtaskDepth(next.maxSubtaskDepth)
     host.setConfiguration(next.enabled, next.preventIdleSleep)
+    setToolsEnabled(next.enabled)
     if (disposeSection !== undefined) {
       disposeSection()
       disposeSection = undefined

package/src/mount-once.ts

@@ -5,44 +5,138 @@
  * the loader accepts a standalone install of the same package side by side;
  * without this guard the second instance would still re-register the same
  * webserver routes, tools, settings namespaces, and system-prompt sections
- * and fail the boot. mountOnce makes the second host apply a no-op for the
- * lifetime of the first instance (the browser half is already deduped by
- * package name in the client module host).
+ * and fail the boot. mountOnce makes a mount of an already-mounted package a
+ * no-op for as long as the first instance lives (the browser half is already
+ * deduped by package name in the client module host).
+ *
+ * A no-op is only safe while the holder is ALIVE. The holder can be disposed
+ * long after the refused mount ran its course: the Host reloads a profile by
+ * creating the new loader entries before the old ones are torn down (a
+ * plugin-manager enable/disable/install write, a settings-driven row reload,
+ * HMR), so the new aggregate shell entry mounts its family plugin while the
+ * previous entry still owns the name. Dropping that refused mount lost the
+ * plugin for good - the previous entry then disposed its own mount, releasing
+ * the name with nobody left to take it, and the family row stayed listed as
+ * active while its host routes 404ed (the task-board panel showed
+ * "board.hostError.notMounted", no degraded record appeared, and only a Host
+ * restart recovered it).
+ *
+ * The refused mount is therefore QUEUED, not dropped, and replayed the moment
+ * the holder releases the name - if the waiting fiber is still alive then. The
+ * single-instance guarantee is unchanged: exactly one mount is live per
+ * package name, and the replay re-enters the guard so a later mount still
+ * dedupes against it.
  *
  * The registry rides a global symbol so two module instances of the same
- * package (npm copy vs repository link) still share one verdict. cordis
- * `ctx.effect` runs its callback immediately and treats the callback's
+ * package (npm copy vs repository link) still share one verdict. That symbol
+ * is a CROSS-REPOSITORY contract, not this file's private state: the four
+ * satellite packages (dsh-skins / dsh-pet / dsh-presets /
+ * dsh-community-plugins) are separate repositories carrying their own copy of
+ * this guard, rebuilt on their own schedule, so the value under `MOUNTED`
+ * must keep the shape every published copy reads (a `Set` of package names
+ * with `has`/`add`/`delete`). The wait queues this guard added therefore live
+ * under their own additive key, and the registry reads back a `Set` even when
+ * some other build left a different value there. Changing `MOUNTED`'s shape
+ * in place broke that contract once: a satellite's legacy copy created a
+ * `Set`, the family's new copy read it as a `Map`, and every family row
+ * mounted after it failed with "claims.get is not a function".
+ *
+ * cordis `ctx.effect` runs its callback immediately and treats the callback's
  * return value as the fiber disposer, so the unmarker is returned, not run.
  */
 
+/** Published cross-repository contract: package names currently mounted. */
 const MOUNTED = Symbol.for('dsh-web.mounted-plugins')
 
+/** Additive key this guard owns: refused mounts waiting for the name. */
+const WAITERS = Symbol.for('dsh-web.mounted-plugins.waiters')
+
+/** The slice of a cordis context this guard touches. */
+interface MountContext {
+  effect?: (effect: () => unknown) => unknown
+}
+
+/** One mount that was refused while another fiber owned the package name. */
+interface PendingMount {
+  /** Replay the refused mount; a no-op once its own fiber has been disposed. */
+  run(): void
+}
+
 interface MountRegistry {
-  [MOUNTED]?: Set<string>
+  [MOUNTED]?: unknown
+  [WAITERS]?: Map<string, PendingMount[]>
 }
 
+/**
+ * The shared name registry, always a `Set` whatever another build stored here:
+ * a foreign value (an interim shape, a hand-written global) must not take every
+ * family plugin down with it.
+ * @returns the process-wide set of mounted package names.
+ */
 function mountedSet(): Set<string> {
   const registry = globalThis as MountRegistry
-  return (registry[MOUNTED] ??= new Set())
+  const existing = registry[MOUNTED]
+  if (existing instanceof Set) return existing as Set<string>
+  const created = new Set<string>()
+  registry[MOUNTED] = created
+  return created
+}
+
+/** Queue per package name for mounts refused while a holder was alive. */
+function mountWaiters(): Map<string, PendingMount[]> {
+  const registry = globalThis as MountRegistry
+  return (registry[WAITERS] ??= new Map())
 }
 
 /**
  * Wrap a cordis plugin apply so the package runs at most once per process.
- * The first mount registers normally and unmarks when its fiber disposes;
- * any later mount of the same package name is a no-op.
+ * The first mount registers normally and releases the name when its fiber
+ * disposes; a mount refused while that name is held waits for the release and
+ * then runs, unless its own fiber disposes first.
  * @param packageName - npm package identity shared by every install source.
  * @param fn - the original plugin apply.
  * @returns an apply of the same shape.
  */
 export function mountOnce<T extends (...args: any[]) => unknown>(packageName: string, fn: T): T {
-  return ((...args: unknown[]) => {
+  const mount = (...args: unknown[]): unknown => {
     const mounted = mountedSet()
-    if (mounted.has(packageName)) return
+    const ctx = args[0] as MountContext | undefined
+    if (mounted.has(packageName)) {
+      // Another fiber (the aggregate row, a standalone install, or a copy built
+      // from an older revision of this guard) owns the name. Queue instead of
+      // dropping: dropping lost the plugin for the rest of the process when the
+      // holder was disposed by a reload.
+      const waiters = mountWaiters()
+      const queue = waiters.get(packageName) ?? []
+      let alive = true
+      const pending: PendingMount = {
+        run: () => {
+          if (alive) mount(...args)
+        },
+      }
+      // A fiber that dies while it waits must not be replayed afterwards: its
+      // context is disposed and registering effects on it would throw.
+      ctx?.effect?.(() => () => {
+        alive = false
+        const index = queue.indexOf(pending)
+        if (index >= 0) queue.splice(index, 1)
+      })
+      queue.push(pending)
+      waiters.set(packageName, queue)
+      return
+    }
     mounted.add(packageName)
-    const ctx = args[0] as { effect?: (effect: () => unknown) => unknown } | undefined
     ctx?.effect?.(() => () => {
       mounted.delete(packageName)
+      const waiters = mountWaiters()
+      const queue = waiters.get(packageName)
+      if (queue === undefined) return
+      waiters.delete(packageName)
+      // Defer the handover one microtask so the disposing mount's own effects
+      // (routes, ledger, timers) are torn down before the next one registers.
+      for (const waiter of queue.splice(0)) queueMicrotask(() => { waiter.run() })
     })
     return fn(...args)
-  }) as T
+  }
+  return mount as T
 }

package/src/protocol.ts

@@ -40,6 +40,16 @@ export interface TaskBoardSnapshot {
   power: TaskBoardPowerSnapshot
   /** Session-default permission the confirmation gate compares against. */
   sessionDefaultPermission?: TaskPermission
+  /**
+   * Deployment subtask depth limit (1..3). The browser mirrors it to enable or
+   * disable the subtask controls; the Host ledger is the authority.
+   */
+  maxSubtaskDepth?: number
+  /**
+   * Whether this deployment serves the Agent Teams service, so a task may opt
+   * into team execution (Team Lead session plus one teammate per subtask).
+   */
+  teamRunAvailable?: boolean
 }
 
 /** SSE event frame: revision/scheduler/power only, never the task list. */
@@ -95,6 +105,7 @@ export type TaskBoardAction =
   | { kind: 'run'; taskId: string }
   | { kind: 'rerun'; taskId: string }
   | { kind: 'confirm-permission'; taskId: string }
+  | { kind: 'set-parent'; taskId: string; parentId: string | null }
 
 export interface TaskBoardActionEnvelope {
   requestId: string
@@ -192,6 +203,9 @@ function importedTask(value: unknown): TaskRecord | undefined {
         lastTriggeredAt: task.schedule.lastTriggeredAt,
       },
     }),
+    // The lineage link rides the import; the Host repairs a link whose parent
+    // is missing from the merged ledger instead of trusting the export.
+    ...(task.parentId === undefined ? {} : { parentId: task.parentId }),
     ...(task.workspaceId === undefined ? {} : { workspaceId: task.workspaceId }),
     ...(task.mode === undefined ? {} : { mode: task.mode }),
     ...(task.permission === undefined ? {} : { permission: task.permission }),
@@ -233,10 +247,12 @@ function handoverPayload(value: unknown): TaskHandoverInput | undefined {
 
 function createInput(value: unknown): value is NewTaskInput {
   const input = record(value)
-  if (input === undefined || !exactKeys(input, ['title', 'description', 'prompt', 'workspaceId', 'mode', 'permission', 'schedule', 'freeze', 'handover', 'model', 'reuseSession', 'tags'])) return false
+  if (input === undefined || !exactKeys(input, ['title', 'description', 'prompt', 'parentId', 'workspaceId', 'mode', 'permission', 'schedule', 'freeze', 'handover', 'model', 'reuseSession', 'teamRun', 'tags'])) return false
+  if (input.parentId !== undefined && (typeof input.parentId !== 'string' || input.parentId.trim() === '')) return false
   if (typeof input.title !== 'string' || typeof input.description !== 'string' || typeof input.prompt !== 'string') return false
   if (!optionalString(input.workspaceId) || !optionalString(input.mode) || !optionalString(input.model)) return false
   if (input.reuseSession !== undefined && typeof input.reuseSession !== 'boolean') return false
+  if (input.teamRun !== undefined && typeof input.teamRun !== 'boolean') return false
   if (input.permission !== undefined && !isTaskPermission(input.permission)) return false
   if (input.tags !== undefined && !isTaskTagList(input.tags)) return false
   if (input.freeze !== undefined && freezePayload(input.freeze) === undefined) return false
@@ -251,9 +267,10 @@ function createInput(value: unknown): value is NewTaskInput {
 
 function updatePatch(value: unknown): boolean {
   const patch = record(value)
-  if (patch === undefined || !exactKeys(patch, ['title', 'description', 'prompt', 'workspaceId', 'mode', 'permission', 'freeze', 'handover', 'model', 'reuseSession', 'tags'])) return false
+  if (patch === undefined || !exactKeys(patch, ['title', 'description', 'prompt', 'workspaceId', 'mode', 'permission', 'freeze', 'handover', 'model', 'reuseSession', 'teamRun', 'tags'])) return false
   // null (or false) clears the reuse opt-in; only a real boolean is accepted.
   if (patch.reuseSession !== undefined && patch.reuseSession !== null && typeof patch.reuseSession !== 'boolean') return false
+  if (patch.teamRun !== undefined && patch.teamRun !== null && typeof patch.teamRun !== 'boolean') return false
   for (const key of ['title', 'description', 'prompt', 'workspaceId', 'mode', 'model'] as const) {
     if (!optionalString(patch[key])) return false
   }
@@ -326,6 +343,13 @@ function parseEnvelopeAction(value: unknown): TaskBoardActionEnvelope | undefine
         : patch
       return { requestId: envelope.requestId, action: { kind: 'update', taskId, patch: sanitized } }
     }
+    case 'set-parent': {
+      if (!exactKeys(action, ['kind', 'taskId', 'parentId'])) return undefined
+      if (taskId === undefined) return undefined
+      const parentId = action.parentId
+      if (parentId !== null && (typeof parentId !== 'string' || parentId.trim() === '')) return undefined
+      return { requestId: envelope.requestId, action: { kind: 'set-parent', taskId, parentId } }
+    }
     case 'set-schedule':
       if (!exactKeys(action, ['kind', 'taskId', 'patch'])) return undefined
       return taskId !== undefined && schedulePatch(action.patch)

package/lib/types/client/board-mount.d.ts

@@ -1,23 +0,0 @@
-/**
- * Board view mounting (dsh-task-board wrapper).
- *
- * The single-occupant takeover lifecycle — container injection into the
- * center column, sibling eviction, remount resilience, sidebar click-out —
- * lives exactly once in shared/client/panel-mount-core.ts (synced copy); this
- * wrapper supplies the board tree, view dataset key, CSS module, and the html
- * attribute names. Those names are pinned by board.module.css, skins, and the
- * semantic attributes contract.
- */
-import type { BoardController } from '../core/controller.ts';
-import type { LocaleRefreshSource } from './sidebar-entry.ts';
-/** The injected board container (kept in the DOM, hidden when inactive). */
-export declare const BOARD_VIEW_SELECTOR = "[data-dsh-taskboard-view]";
-/**
- * Mount the board React tree into the center column and bind its visibility
- * to the controller's boardOpen state.
- * @param controller - the board controller driving the view.
- * @param locale - locale-change source; when given, re-renders a mounted board
- *   on a Language switch.
- * @returns disposer unmounting the tree and restoring the column.
- */
-export declare function mountBoard(controller: BoardController, locale?: LocaleRefreshSource): () => void;

package/lib/types/client/body-mutations.d.ts

@@ -1,45 +0,0 @@
-/**
- * One `document.body` MutationObserver per page, shared by every family
- * plugin bundle.
- *
- * Family plugins that inject at the DOM level must notice when the shell
- * re-renders around their injected node: the sidebar entry rows
- * (sidebar-entry-core), the center-column panel containers
- * (panel-mount-core), and the aggregate shell's column shims. Each consumer
- * used to install its OWN `MutationObserver` on `document.body` with
- * `{ childList: true, subtree: true }`, so a page carrying N family plugins
- * paid N native observers and N callback invocations for EVERY mutation batch
- * the app produced — chat token streaming alone produces many per second, and
- * the count grows with the number of installed plugins.
- *
- * This module keeps exactly ONE body observer per page. The registry lives on
- * `globalThis` under a `Symbol.for` key, so the per-package generated copies
- * of this file (scripts/sync-shared.mjs) and separately bundled plugins all
- * reach the same hub at runtime instead of one hub per module instance.
- * Record subscribers receive the mutations accumulated since the last flush.
- * Consumers that only re-check their DOM use subscribeBodyInvalidations:
- * when all subscribers use that path, the hub retains no mutation records
- * (or detached subtrees) while a background page's animation frames pause.
- * Both paths run at most once per frame. The last subscriber disconnects the
- * observer, cancels the pending frame and releases its records.
- *
- * Failure policy: without a DOM or `MutationObserver` the subscription is a
- * no-op disposer (the same silence the per-consumer observers had), and when
- * `requestAnimationFrame` is unavailable the flush runs synchronously so a
- * subscriber is never silently dropped. A throwing subscriber cannot stop the
- * others.
- */
-/**
- * Subscribe to a coalesced DOM re-check without retaining mutation records.
- * The marked wrapper also works with an older hub, which delivers records
- * that it simply ignores until a page reload picks up the updated hub.
- */
-export declare function subscribeBodyInvalidations(subscriber: () => void): () => void;
-/**
- * Subscribe to body-level childList mutations.
- * @param subscriber - called at most once per animation frame with the records
- *   collected since the previous flush; must be safe to run repeatedly.
- * @returns the disposer removing this subscriber (and the observer when it was
- *   the last one).
- */
-export declare function subscribeBodyMutations(subscriber: (records: MutationRecord[]) => void): () => void;