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

package/lib/types/core/use-cases/task-create.d.ts

@@ -1,17 +1,26 @@
 import { type NewTaskInput, type TaskRecord } from '../tasks.ts';
 /** Result of a create transition: the new task (when accepted) + the next ledger. */
 export interface CreateTaskResult {
-    /** The minted task, or undefined when the input was rejected (blank title). */
+    /** The minted task, or undefined when the input was rejected. */
     task: TaskRecord | undefined;
     /** The next ledger; identical reference when rejected. */
     tasks: readonly TaskRecord[];
+    /** Why the input was rejected; absent when a task was minted. */
+    error?: string;
 }
 /**
  * Apply a create against the current ledger. Returns the new task and the
- * appended ledger, or the unchanged ledger when the title is blank.
+ * appended ledger, or the unchanged ledger when the title is blank or the
+ * requested parent link is refused.
+ *
+ * A subtask inherits the execution targets its parent already pins (workspace,
+ * agent preset, permission, model) unless the form supplied its own; the
+ * parent human permission confirmation travels with an inherited permission,
+ * so a subtask of an already-confirmed elevated card is runnable at once.
  * @param tasks - current ledger.
- * @param input - raw user input (title/description/prompt + optional schedule).
+ * @param input - raw user input (title/description/prompt + optional schedule/parent).
  * @param now - clock instant (ms epoch).
  * @param id - minted task id.
+ * @param maxSubtaskDepth - deployment subtask depth limit.
  */
-export declare function applyCreateTask(tasks: readonly TaskRecord[], input: NewTaskInput, now: number, id: string): CreateTaskResult;
+export declare function applyCreateTask(tasks: readonly TaskRecord[], input: NewTaskInput, now: number, id: string, maxSubtaskDepth?: number): CreateTaskResult;

package/lib/types/core/use-cases/task-delete.d.ts

@@ -1,7 +1,11 @@
 /**
  * Delete-task use case: drop a task from the ledger and clear the selection
  * when it pointed at the removed task. Pure ledger transition (no persistence
- * or notify — the controller orchestrates those).
+ * or notify - the controller orchestrates those).
+ *
+ * A task that still has subtasks is refused: deleting the parent would leave
+ * dangling child links, and silently detaching (or cascading) the children is
+ * a data-loss decision the user must make explicitly.
  */
 import type { TaskRecord } from '../tasks.ts';
 /** Result of a delete transition. */
@@ -10,6 +14,8 @@ export interface DeleteTaskResult {
     tasks: readonly TaskRecord[];
     /** Whether the previous selection referenced the removed task. */
     selectionCleared: boolean;
+    /** True when the task still carries subtasks, so nothing was removed. */
+    blocked: boolean;
 }
 /**
  * Apply a delete across the ledger. The selection (a task id) is cleared when

package/lib/types/core/use-cases/task-parent.d.ts

@@ -0,0 +1,21 @@
+import type { TaskRecord } from '../tasks.ts';
+/** Result of a parent-link transition. */
+export interface SetParentResult {
+    /** The next ledger; the input reference when refused. */
+    tasks: readonly TaskRecord[];
+    /** Whether the link (or the detachment) was stored. */
+    applied: boolean;
+    /** User-facing refusal reason; absent when applied. */
+    error?: string;
+}
+/**
+ * Attach or detach one task. A null (or blank) parent detaches, which is always
+ * allowed for a known on-board task; attaching validates the whole chain so a
+ * cyclic or too-deep ledger can never be stored.
+ * @param tasks - current ledger.
+ * @param id - the task being moved.
+ * @param parentId - the new parent, or null to detach.
+ * @param now - clock instant (ms epoch).
+ * @param maxSubtaskDepth - deployment subtask depth limit.
+ */
+export declare function applySetParent(tasks: readonly TaskRecord[], id: string, parentId: string | null, now: number, maxSubtaskDepth?: number): SetParentResult;

package/lib/types/core/use-cases/task-update.d.ts

@@ -15,7 +15,7 @@ import type { TaskHandoverInput } from '../handover.ts';
  * Editable fields on a task (the update patch surface). `freeze` replaces the
  * continuation-card snapshot (restamping frozenAt); an explicit null clears it.
  */
-export type TaskUpdatePatch = Partial<Pick<TaskRecord, 'title' | 'description' | 'prompt' | 'workspaceId' | 'mode' | 'permission' | 'model' | 'reuseSession'>> & {
+export type TaskUpdatePatch = Partial<Pick<TaskRecord, 'title' | 'description' | 'prompt' | 'workspaceId' | 'mode' | 'permission' | 'model' | 'reuseSession' | 'teamRun'>> & {
     freeze?: FreezeSnapshot & {
         redacted?: boolean;
     } | null;

package/lib/types/host/agent-tools.d.ts

@@ -0,0 +1,27 @@
+import { type ToolDefinition } from '@deepseek-ai/dsh-tools';
+import type { TaskBoardAction, TaskBoardSnapshot } from '../protocol.ts';
+/**
+ * The narrow Host face the tools need. TaskBoardHostService satisfies it
+ * structurally, so tests and a future host can drive the same surface.
+ */
+export interface TaskBoardToolHost {
+    /** Current board snapshot (tasks + scheduler + power + deployment constants). */
+    snapshot(): TaskBoardSnapshot;
+    /** Submit one confirmed Host action; returns the resulting snapshot. */
+    apply(requestId: string, action: TaskBoardAction, initiator?: string): TaskBoardSnapshot;
+}
+/** Registered tool names, in registration order. */
+export declare const TASK_BOARD_TOOL_NAMES: readonly ["task_board_list", "task_board_get", "task_board_create", "task_board_update", "task_board_set_parent", "task_board_run", "task_board_manage", "task_board_schedule"];
+/**
+ * The calling session id, for the execution audit trail (the same stamp the
+ * browser asserts). Absent when a call has no agent behind it.
+ */
+export declare function callingSessionId(exec: {
+    agent?: unknown;
+}): string | undefined;
+/**
+ * Build every task-board tool bound to one Host service.
+ * @param host - the Host ledger/service face (TaskBoardHostService).
+ * @returns the tool definitions, in TASK_BOARD_TOOL_NAMES order.
+ */
+export declare function buildTaskBoardTools(host: TaskBoardToolHost): ToolDefinition[];

package/lib/types/host-ledger.d.ts

@@ -1,4 +1,4 @@
-import { type ExecutionRecord, type TaskRecord } from './core/tasks.ts';
+import { type ExecutionOutcome, type ExecutionRecord, type TaskRecord } from './core/tasks.ts';
 import { type TaskBoardAction, type TaskBoardSchedulerSnapshot } from './protocol.ts';
 import { type TaskPermission } from './core/handover.ts';
 export interface LedgerState {
@@ -9,6 +9,13 @@ export interface LedgerState {
 export interface OpenedRun {
     task: TaskRecord;
     execution: ExecutionRecord;
+    /**
+     * How the Host obtains this run's session. Absent or `session` launches a
+     * fresh (or reused) execution session; `teammate` means the run belongs to a
+     * team-mode cascade, where the Host asks the root's Lead session to spawn a
+     * teammate instead of launching a session of its own.
+     */
+    dispatch?: 'session' | 'teammate';
 }
 /** Minimal value copy used by the Host session monitor. */
 export interface OpenExecutionReference {
@@ -52,6 +59,16 @@ export type PowerShellProbe = (script: string, timeoutMs: number) => string | un
  * probe is injectable so the fallback chain is testable off Windows.
  */
 export declare function win32StartTimeMs(pid: number, probe?: PowerShellProbe): number | undefined;
+/**
+ * Repair parent links after a load or an import: a link whose parent row is
+ * missing, cyclic, or names an archived parent while the child is on board is
+ * dropped (the task becomes a root) instead of dropping the task. A chain
+ * deeper than the current `maxSubtaskDepth` is deliberately KEPT: the limit
+ * gates new links, it never deletes a stored one, and every cascade walk is
+ * bounded by the limit anyway. The Host is the only writer of these links, so
+ * this is a last-resort guard against a hand-edited or imported document.
+ */
+export declare function repairParentLinks(tasks: readonly TaskRecord[]): TaskRecord[];
 export declare class HostTaskLedger {
     private readonly now;
     private document;
@@ -65,9 +82,24 @@ export declare class HostTaskLedger {
     readonly schedulerFile: string;
     /** Session-default permission the confirmation gate compares against. */
     readonly sessionDefaultPermission: TaskPermission;
+    /**
+     * Deployment subtask depth limit (1..3): the lineage gate every write obeys.
+     * The settings card edits it live, so {@link setMaxSubtaskDepth} mutates it
+     * instead of remounting the row.
+     */
+    private depthLimit;
     constructor(dir?: string, now?: () => number, options?: {
         sessionDefaultPermission?: TaskPermission;
+        maxSubtaskDepth?: number;
     });
+    /** Current subtask depth limit (1..3). */
+    get maxSubtaskDepth(): number;
+    /**
+     * Apply a live settings edit of the subtask depth limit. A no-op when the
+     * normalized limit is unchanged, so a coarse volatile invalidation that
+     * changed nothing emits nothing.
+     */
+    setMaxSubtaskDepth(depth: number): void;
     /** Remove leftover *.tmp-* files from previous crashes or interrupted writes. */
     private cleanStaleTemporaryFiles;
     /** Revision + scheduler without any task cloning; feeds the SSE event frame. */
@@ -84,20 +116,81 @@ export declare class HostTaskLedger {
     runtimeView(): LedgerRuntimeView;
     /** Count armed, non-archived schedules without cloning task histories. */
     armedScheduleCount(): number;
+    /**
+     * The earliest armed `nextRunAt` strictly after the supplied Host time, or
+     * undefined when no schedule is armed in the future. This is the instant the
+     * Host arms its native timer at, so the board wakes exactly when work is due
+     * instead of polling a fixed heartbeat.
+     * @param now - current Host time in ms epoch.
+     * @returns the nearest future trigger, or undefined when none is armed.
+     */
+    nextArmedRunAt(now: number): number | undefined;
     /** Return value-only references for schedules due at the supplied Host time. */
     dueSchedules(now: number): DueScheduleReference[];
     subscribe(listener: () => void): () => void;
     dispose(): void;
     applyRequest(requestId: string, action: TaskBoardAction, initiator?: string): {
         state: LedgerState;
-        run?: OpenedRun;
+        runs?: OpenedRun[];
     };
-    openScheduled(taskId: string, nextRunAt: number | undefined, triggeredAt: number): OpenedRun | undefined;
+    /**
+     * Open the cascade one due schedule triggers: an empty array means nothing
+     * ran (already running, or a participant whose elevated permission is still
+     * unconfirmed), and the rule rolls to its next occurrence either way.
+     */
+    openScheduled(taskId: string, nextRunAt: number | undefined, triggeredAt: number): OpenedRun[];
     skipMissed(now: number): void;
     setScheduler(patch: Partial<TaskBoardSchedulerSnapshot>): void;
+    /**
+     * Settle one execution. A cascade participant first records its OWN outcome
+     * and only finalizes once every child execution in its run group has
+     * settled, so a parent card leaves 'running' with the whole tree's verdict
+     * rather than its own turn alone.
+     */
+    settle(taskId: string, executionId: string, outcome: ExecutionOutcome, error?: string): void;
     attachSession(taskId: string, executionId: string, sessionId: string): void;
-    settle(taskId: string, executionId: string, outcome: 'succeeded' | 'failed' | 'cancelled', error?: string): void;
     private apply;
+    /**
+     * The binding that makes a run illegal, if any.
+     *
+     * A plain cascade launches one session per participant, so every participant
+     * carries its own resolved binding and each one gates the run. A team run
+     * launches only the Lead session: the Lead's binding gates it, while a
+     * subtask's OWN above-default pin cannot be applied to a teammate and is
+     * refused instead of being silently dropped (an inherited binding is the
+     * Lead's own and stays allowed once the Lead is confirmed).
+     * @param root - the task being run.
+     * @returns the first refusal, or undefined when the run may start.
+     */
+    private bindingRefusal;
+    /**
+     * The tasks a cascade from `rootId` would actually open executions for, with
+     * their effective execution targets resolved. Archived members never run, and
+     * a member that already has an open execution is skipped (a task cannot run
+     * twice), so the result is the participant set the launch will use.
+     */
+    private cascadeParticipants;
+    /** Whether a task or any of its subtasks still has an open execution. */
+    private subtreeHasOpenExecution;
+    /**
+     * Open one execution per cascade participant (the requested task and its
+     * on-board descendants, within the depth limit) under a single run group, and
+     * commit the ledger once. The returned runs are ordered root-first, so the
+     * Host launches the parent before its subtasks.
+     * @param root - the task the user ran.
+     * @param now - clock instant (ms epoch).
+     * @param initiator - the DSH session that asked for the run (audit only).
+     * @param rerun - true to reset the root to 'todo' before starting it.
+     * @param nextRunAt - when set, the root's schedule also rolls forward.
+     */
+    private startCascade;
+    /**
+     * Finalize every cascade parent that is ready, walking from `taskId` up the
+     * lineage: a member settles once its own outcome is recorded and none of its
+     * group children is still open, and its verdict folds those children in
+     * (failure dominates, then cancellation).
+     */
+    private settleCascade;
     private repairSchedules;
     private reconcileInterruptedStarts;
     /**

package/lib/types/host-runner.d.ts

@@ -49,7 +49,29 @@ export declare class SessionLaunchError extends Error {
  * first, the provenance wrap then encloses the instruction. Plain tasks (no
  * freeze) keep the bare handover preamble + prompt.
  */
-export declare function promptText(task: TaskRecord): string;
+/** One other execution member of a run, as named in the launched task's prompt. */
+export interface PromptPeer {
+    /** Task id of the member. */
+    id: string;
+    /** Member title. */
+    title: string;
+    /** Teammate name when this member runs as a teammate. */
+    name?: string;
+}
+/** Execution-shape context appended to the launched task's prompt. */
+export interface PromptContext {
+    /** The other members this run opens, excluding the launched task itself. */
+    peers?: readonly PromptPeer[];
+    /** True when those members run as teammates inside this session (Team Lead). */
+    team?: boolean;
+}
+/**
+ * Build the execution prompt for one task.
+ * @param task - the task being launched.
+ * @param context - the run's other members, for the execution-shape section.
+ * @returns the prompt text.
+ */
+export declare function promptText(task: TaskRecord, context?: PromptContext): string;
 export declare class HostExecutionRunner {
     private readonly gateway;
     private readonly commands?;
@@ -77,7 +99,23 @@ export declare class HostExecutionRunner {
      */
     launch(task: TaskRecord, options?: {
         reuseSessionId?: string;
+        promptContext?: PromptContext;
     }): Promise<string>;
+    /**
+     * Fail closed when a reused session records a different Agent preset than
+     * the one this task pins.
+     *
+     * The fresh branch asserts the pin by passing `agentPreset` to
+     * `session/create`; the reuse branch must not call that method (it would
+     * create or re-adopt the very session the board only meant to continue), so
+     * the recorded value is read through `session/projections` — the documented
+     * read that resolves no Agent — and compared here (issue #1708). A session
+     * whose preset cannot be read is not treated as a match: silently continuing
+     * under an unknown composition is the failure this guards.
+     * @param sessionId - the session this execution continues in.
+     * @param pinned - the preset id the task pins, when it pins one.
+     */
+    private assertReusedPreset;
     /**
      * Re-assert the pinned execution contract on a session and queue the task
      * prompt. Shared by the fresh-session and reuse paths so both apply exactly

package/lib/types/host-service.d.ts

@@ -4,16 +4,57 @@ import { HostExecutionRunner, type SessionCommandDispatcher, type TaskBoardWorks
 import { PowerInhibitor } from './power-inhibitor.ts';
 import { type TaskBoardAction, type TaskBoardEventPayload, type TaskBoardSnapshot } from './protocol.ts';
 import type { TaskPermission } from './core/handover.ts';
+/** One teammate the Host asks the Agent Teams service to spawn for a team run. */
+export interface TeamSpawnInput {
+    /** Session id of the run's Team Lead (the root task's execution session). */
+    leadSessionId: string;
+    /** Immutable lower-kebab-case teammate name, unique inside the Team. */
+    name: string;
+    /** Short description of the delegated responsibility. */
+    description: string;
+    /** The subtask's execution prompt. */
+    prompt: string;
+}
+/** Result of one teammate spawn attempt. */
+export interface TeamSpawnResult {
+    /** The teammate's session id when it reached the active edge. */
+    sessionId?: string;
+    /** Why the spawn failed: a thrown call, or a member that settled as failed. */
+    error?: string;
+}
+/**
+ * The Agent Teams capability the Host needs for team-mode runs. The plugin
+ * builds it from the optional `agentTeams` service; it is absent when this
+ * deployment does not serve that service, in which case a team run is refused
+ * instead of silently degrading into a plain cascade.
+ */
+export interface TaskBoardTeamDispatcher {
+    spawn(input: TeamSpawnInput): Promise<TeamSpawnResult>;
+}
+/**
+ * The native timer face the Host arms through. The cordis `timer` service
+ * (dsh-base's own `cordis-plugin-timer` row) provides it: its handles are
+ * registered on the owning fiber, so unloading the board clears every armed
+ * timer without this service tracking handles by hand. A composition that
+ * serves no timer service falls back to the process globals.
+ */
+export interface HostTimerFace {
+    timeout(callback: () => void, delay: number): () => void;
+    interval(callback: () => void, delay: number): () => void;
+}
 export declare class TaskBoardHostService {
     readonly ledger: HostTaskLedger;
     readonly runner: HostExecutionRunner;
     readonly power: PowerInhibitor;
     private readonly listeners;
-    private timers;
-    private lastScheduleTick;
+    /** The one recurring timer: the session-roster poll. */
+    private pollTimer;
+    /** The armed schedule timer, if a trigger is pending. */
+    private scheduleTimer;
+    /** The instant the armed schedule timer targets (ms epoch), for resume detection. */
+    private scheduleTarget;
     private disposed;
     private pollInFlight;
-    private tickInFlight;
     private active;
     /**
      * Ids the last roster poll saw as present and idle; undefined while the
@@ -23,6 +64,8 @@ export declare class TaskBoardHostService {
      */
     private idleSessionIds;
     private preventIdleSleep;
+    private readonly team;
+    private readonly timers;
     private lastPowerJson;
     private readonly now;
     constructor(gateway: TypertGateway, options?: {
@@ -32,6 +75,9 @@ export declare class TaskBoardHostService {
         commandDispatcher?: SessionCommandDispatcher;
         workspaceRegistry?: TaskBoardWorkspaceRegistry;
         sessionDefaultPermission?: TaskPermission;
+        maxSubtaskDepth?: number;
+        team?: TaskBoardTeamDispatcher;
+        timers?: HostTimerFace;
     });
     start(): void;
     setConfiguration(active: boolean, preventIdleSleep: boolean): void;
@@ -42,14 +88,61 @@ export declare class TaskBoardHostService {
     apply(requestId: string, action: TaskBoardAction, initiator?: string): TaskBoardSnapshot;
     dispose(): void;
     private launch;
+    private scheduleTeammate;
+    /**
+     * Spawn one teammate inside the Lead session and attach the teammate's
+     * session to the subtask execution, so the existing session monitor settles
+     * it from the teammate's own turn like any other execution. A spawn that
+     * fails settles the subtask as failed immediately, which then folds into the
+     * Lead's cascade verdict.
+     */
+    private spawnTeammate;
     private pollSessions;
     /** Reuse the session list this poll already fetched: one list RPC per tick, not 1 + E. */
     private reconcileExecutions;
-    private tickSchedule;
+    /** Drop the armed schedule timer and forget its target. */
+    private clearScheduleTimer;
+    /**
+     * Boot / resume recovery: skip every occurrence that came due while the
+     * board was not running and roll each schedule to its next future target,
+     * then arm the timer for the nearest one. Rendering the occurrence is
+     * deliberately not attempted: the ACL of a card that fired hours ago is
+     * stale, and the board's own recovery contract is "missed triggers are
+     * skipped, never replayed".
+     */
+    private recoverSchedule;
+    /**
+     * Arm the native timer at the nearest armed future trigger. One timer serves
+     * every schedule: the ledger's next target is the only instant the Host has
+     * to wake for. A target beyond the platform's timer ceiling re-arms in
+     * segments, and a target already past (the wall clock jumped, or the process
+     * was suspended) is handled immediately as a recovery.
+     */
+    private armSchedule;
+    /**
+     * One armed target became due. A fire landing well past its target is a
+     * resume (suspend, throttle, forward clock jump) rather than a normal
+     * occurrence, so it takes the recovery path instead of launching a run for a
+     * long-stale instant.
+     */
+    private onScheduleFire;
     private armedSchedules;
+    /**
+     * Launch one run set. The root goes first and receives the run shape in its
+     * prompt (which members this run opens, and how they run); every plain-cascade
+     * member then launches on its own so one refused participant cannot hold the
+     * others back. A team run's members are spawned inside the root's Lead
+     * session instead, once that session exists.
+     */
+    private dispatchRuns;
     private scheduleLaunch;
     private schedulePoll;
-    private scheduleTick;
+    /**
+     * Re-arm from the ledger's current targets. Callers that just changed a
+     * schedule (the host routes, the agent tools) invoke this after the write
+     * commits, so a new or edited trigger arms without waiting for the next fire.
+     */
+    refreshSchedule(): void;
     private syncPowerReasons;
     private emit;
 }

package/lib/types/index.d.ts

@@ -7,21 +7,25 @@
  */
 import type { Context, Volatile } from '@deepseek-ai/cordis';
 import z from '@deepseek-ai/schemastery';
+import type { ToolDefinition } from '@deepseek-ai/dsh-tools';
 import type { LlmRuntime } from '@deepseek-ai/dsh-llm';
+import { type HostTimerFace, type TaskBoardTeamDispatcher } from './host-service.ts';
 import { type TaskPermission } from './core/tasks.ts';
 /** Default environment variable holding the authenticated proxy token. */
 export declare const DEFAULT_PROXY_TOKEN_ENV = "DSH_TASK_BOARD_PROXY_TOKEN";
 export declare const inject: string[];
 /** Model-facing announcement: plugin presence, capabilities, and limits. */
-export declare const TASK_BOARD_GUIDANCE = "\u672C\u673A\u5DF2\u5B89\u88C5 dsh-task-board \u63D2\u4EF6\uFF08DSH Web GUI \u7684\u4EFB\u52A1\u770B\u677F\uFF09\uFF1A\u4FA7\u8FB9\u680F\u300C\u4EFB\u52A1\u770B\u677F\u300D\u5165\u53E3\uFF1B\u5728 dsh-web \u63D2\u4EF6\u5168\u5BB6\u6876\u4ED3\u5E93\uFF08packages/dsh-task-board\uFF09\u7EDF\u4E00\u7EF4\u62A4\uFF0C\u7ECF\u805A\u5408\u5305 web-ui-all \u4E00\u952E\u5B89\u88C5\u3002\u80FD\u529B\uFF1A\u591A\u5217\u770B\u677F\u7BA1\u7406\u4EFB\u52A1\uFF1BHost \u6743\u5A01\u8D26\u672C\uFF1B\u5173\u95ED\u6D4F\u89C8\u5668\u540E\u4ECD\u7531 Host \u6267\u884C\u548C\u7ED3\u7B97\uFF1B\u4EFB\u52A1\u53EF\u9489\u4F4F\u5DE5\u4F5C\u533A\u3001agent \u9884\u8BBE\u548C\u6743\u9650\uFF1B\u652F\u6301 Host \u672C\u5730\u65F6\u533A\u7684 5 \u6BB5 cron\uFF0C\u9519\u8FC7\u7684\u89E6\u53D1\u70B9\u4E0D\u8865\u8DD1\uFF1B\u53EF\u9009\u4E14\u9ED8\u8BA4\u5173\u95ED\u7684\u7A7A\u95F2\u7CFB\u7EDF\u7761\u7720\u4FDD\u62A4\u5141\u8BB8\u5C4F\u5E55\u7184\u706D\uFF0C\u4F46\u4E0D\u627F\u8BFA\u62E6\u622A\u5408\u76D6\u3001\u624B\u52A8\u7761\u7720\u3001\u4F11\u7720\u3001\u5173\u673A\u6216\u5524\u9192\u5DF2\u7761\u7720\u673A\u5668\u3002\u6267\u884C\u6D88\u8017 API \u989D\u5EA6\u3002\u7528\u6237\u63D0\u5230\u300C\u4EFB\u52A1\u770B\u677F / \u770B\u677F / \u5B9A\u65F6\u4EFB\u52A1\u300D\u65F6\u5373\u6307\u672C\u63D2\u4EF6\uFF0C\u8BF7\u636E\u6B64\u534F\u4F5C\u3002\u82E5\u4F60\u540C\u65F6\u7528 todo_write \u7EF4\u62A4\u4F1A\u8BDD\u9876\u90E8\u7684\u53EF\u89C1\u8BA1\u5212\u5217\u8868\uFF0C\u6700\u7EC8\u56DE\u590D\u524D\u5FC5\u987B\u518D\u6B21\u8C03\u7528 todo_write \u6536\u5C3E\uFF1A\u6CA1\u6709\u5269\u4F59\u5DE5\u4F5C\u65F6\u4E0D\u8981\u4FDD\u7559 in_progress\uFF0C\u5DF2\u5B8C\u6210\u7684\u6700\u540E\u4E00\u6B65\u8981\u6807\u4E3A completed\u3002";
+export declare const TASK_BOARD_GUIDANCE = "\u672C\u673A\u5DF2\u5B89\u88C5 dsh-task-board \u63D2\u4EF6\uFF08DSH Web GUI \u7684\u4EFB\u52A1\u770B\u677F\uFF09\uFF1A\u4FA7\u8FB9\u680F\u300C\u4EFB\u52A1\u770B\u677F\u300D\u5165\u53E3\uFF1B\u5728 dsh-web \u63D2\u4EF6\u5168\u5BB6\u6876\u4ED3\u5E93\uFF08packages/dsh-task-board\uFF09\u7EDF\u4E00\u7EF4\u62A4\uFF0C\u7ECF\u805A\u5408\u5305 web-ui-all \u4E00\u952E\u5B89\u88C5\u3002\u80FD\u529B\uFF1A\u591A\u5217\u770B\u677F\u7BA1\u7406\u4EFB\u52A1\uFF1BHost \u6743\u5A01\u8D26\u672C\uFF1B\u5173\u95ED\u6D4F\u89C8\u5668\u540E\u4ECD\u7531 Host \u6267\u884C\u548C\u7ED3\u7B97\uFF1B\u4EFB\u52A1\u53EF\u9489\u4F4F\u5DE5\u4F5C\u533A\u3001agent \u9884\u8BBE\u548C\u6743\u9650\uFF1B\u4EFB\u52A1\u53EF\u5EFA\u5B50\u4EFB\u52A1\uFF08\u6DF1\u5EA6\u4E0A\u9650\u53EF\u914D 1..3\uFF0C\u9ED8\u8BA4 1 \u5C42\uFF0C\u5B50\u4EFB\u52A1\u4E0D\u80FD\u518D\u5E26\u5B50\u4EFB\u52A1\uFF09\uFF0C\u6267\u884C\u7236\u4EFB\u52A1\u4F1A\u5E76\u53D1\u6267\u884C\u5176\u5B50\u4EFB\u52A1\u6811\uFF0C\u5B50\u4EFB\u52A1\u53EF\u5355\u72EC\u8986\u76D6\u6743\u9650\u4E0E\u6A21\u578B\uFF1B\u53E6\u6CE8\u518C task_board_* agent \u5DE5\u5177\uFF08list/get/create/update/set_parent/run/manage/schedule\uFF09\uFF0C\u4EFB\u4F55\u4F1A\u8BDD\u90FD\u53EF\u76F4\u63A5\u8BFB\u5199\u770B\u677F\u3001\u5B50\u4EFB\u52A1\u4E0E\u5B9A\u65F6\u8BA1\u5212\uFF0C\u4F46\u8FD0\u884C\u4EFB\u52A1\u4F1A\u771F\u5B9E\u6267\u884C\u5E76\u6D88\u8017\u989D\u5EA6\uFF0C\u9AD8\u4E8E\u4F1A\u8BDD\u9ED8\u8BA4\u6743\u9650\u7684\u7ED1\u5B9A\u4ECD\u5FC5\u987B\u7531\u7528\u6237\u5728 GUI \u4EBA\u5DE5\u786E\u8BA4\uFF08\u5DE5\u5177\u523B\u610F\u4E0D\u63D0\u4F9B\u786E\u8BA4\u80FD\u529B\uFF09\uFF1B\u652F\u6301 Host \u672C\u5730\u65F6\u533A\u7684 5 \u6BB5 cron\uFF0C\u9519\u8FC7\u7684\u89E6\u53D1\u70B9\u4E0D\u8865\u8DD1\uFF1B\u53EF\u9009\u4E14\u9ED8\u8BA4\u5173\u95ED\u7684\u7A7A\u95F2\u7CFB\u7EDF\u7761\u7720\u4FDD\u62A4\u5141\u8BB8\u5C4F\u5E55\u7184\u706D\uFF0C\u4F46\u4E0D\u627F\u8BFA\u62E6\u622A\u5408\u76D6\u3001\u624B\u52A8\u7761\u7720\u3001\u4F11\u7720\u3001\u5173\u673A\u6216\u5524\u9192\u5DF2\u7761\u7720\u673A\u5668\u3002\u6267\u884C\u6D88\u8017 API \u989D\u5EA6\u3002\u7528\u6237\u63D0\u5230\u300C\u4EFB\u52A1\u770B\u677F / \u770B\u677F / \u5B9A\u65F6\u4EFB\u52A1\u300D\u65F6\u5373\u6307\u672C\u63D2\u4EF6\uFF0C\u8BF7\u636E\u6B64\u534F\u4F5C\u3002\u82E5\u4F60\u540C\u65F6\u7528 todo_write \u7EF4\u62A4\u4F1A\u8BDD\u9876\u90E8\u7684\u53EF\u89C1\u8BA1\u5212\u5217\u8868\uFF0C\u6700\u7EC8\u56DE\u590D\u524D\u5FC5\u987B\u518D\u6B21\u8C03\u7528 todo_write \u6536\u5C3E\uFF1A\u6CA1\u6709\u5269\u4F59\u5DE5\u4F5C\u65F6\u4E0D\u8981\u4FDD\u7559 in_progress\uFF0C\u5DF2\u5B8C\u6210\u7684\u6700\u540E\u4E00\u6B65\u8981\u6807\u4E3A completed\u3002";
 /**
  * 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 {
     /**
@@ -48,7 +52,25 @@ 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 declare 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
@@ -62,6 +84,8 @@ export declare const Config: z<Schemastery.ObjectS<NoInfer<{
     trustedProxyHosts: z<string[], string[], "defined">;
     proxyTokenEnv: z<string, string, "defined">;
     sessionDefaultPermission: z<"read-only" | "workspace-write" | "danger-full-access", "read-only" | "workspace-write" | "danger-full-access", "defined">;
+    maxSubtaskDepth: z<number, number, "volatile-defined">;
+    teamProvider: z<string, string, "defined">;
 }>>, Schemastery.ObjectT<NoInfer<{
     announceToAgent: z<boolean, boolean, "volatile-defined">;
     enabled: z<boolean, boolean, "volatile-defined">;
@@ -69,6 +93,8 @@ export declare const Config: z<Schemastery.ObjectS<NoInfer<{
     trustedProxyHosts: z<string[], string[], "defined">;
     proxyTokenEnv: z<string, string, "defined">;
     sessionDefaultPermission: z<"read-only" | "workspace-write" | "danger-full-access", "read-only" | "workspace-write" | "danger-full-access", "defined">;
+    maxSubtaskDepth: z<number, number, "volatile-defined">;
+    teamProvider: z<string, string, "defined">;
 }>>, "plain">;
 declare module '@deepseek-ai/cordis' {
     interface Events {
@@ -100,6 +126,68 @@ export declare function resolveProxyAccess(config: Config | undefined, env?: Nod
     trustedProxyHosts: string[];
     proxyToken?: string;
 };
+/** 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 declare function resolveToolRegistry(ctx: Context): AgentToolRegistry | 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 declare function resolveHostTimers(ctx: Context): HostTimerFace | undefined;
+/** 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 declare function resolveAgentTeams(ctx: Context): AgentTeamsFace | 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 declare function buildTeamDispatcher(ctx: Context, provider: string): TaskBoardTeamDispatcher | undefined;
 /**
  * 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
@@ -112,8 +200,8 @@ export declare 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