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

package/lib/types/client/TaskBoardSettingsCard.d.ts

@@ -15,6 +15,8 @@ export interface TaskBoardSettings {
     announceToAgent?: boolean;
     /** Prevent host idle sleep while sessions run or schedules are armed. */
     preventIdleSleep?: boolean;
+    /** Subtask depth limit (1..3); 1 means a single level of subtasks. */
+    maxSubtaskDepth?: number;
 }
 /** What the task-board card renders. */
 export interface TaskBoardSettingsCardState extends CardShell {
@@ -24,6 +26,8 @@ export interface TaskBoardSettingsCardState extends CardShell {
     announceToAgent: CardFieldState;
     /** Idle-system-sleep protection flag. */
     preventIdleSleep: CardFieldState;
+    /** Subtask depth limit field. */
+    maxSubtaskDepth: CardFieldState;
 }
 /** The registration-side face the card's slot entry injects. */
 export interface TaskBoardSettingsCardFace extends CardActions {

package/lib/types/client/board/LinkSubtaskModal.d.ts

@@ -0,0 +1,11 @@
+import type { BoardController } from '../../core/controller.ts';
+import type { TaskRecord } from '../../core/tasks.ts';
+/** Link-subtask overlay props. */
+export interface LinkSubtaskModalProps {
+    controller: BoardController;
+    /** The task the picked card becomes a subtask of. */
+    parent: TaskRecord;
+    onClose: () => void;
+}
+/** Link-subtask overlay. */
+export declare function LinkSubtaskModal({ controller, parent, onClose }: LinkSubtaskModalProps): import("react").JSX.Element;

package/lib/types/client/board/NewTaskModal.d.ts

@@ -12,6 +12,12 @@ export interface NewTaskModalProps {
     defaultWorkspaceId?: string;
     /** Optional callback after successful duplication (e.g. to archive source). */
     onDuplicateSuccess?: (sourceTaskId: string) => Promise<void>;
+    /**
+     * Task the new card becomes a subtask of ("add subtask" from its detail
+     * view). The execution targets start from the parent's and the create action
+     * carries the parent link; unset targets inherit again at run time.
+     */
+    parentTask?: TaskRecord;
 }
 /** New-task form overlay. */
-export declare function NewTaskModal({ controller, onClose, initialTask, defaultWorkspaceId, onDuplicateSuccess }: NewTaskModalProps): import("react").JSX.Element;
+export declare function NewTaskModal({ controller, onClose, initialTask, defaultWorkspaceId, onDuplicateSuccess, parentTask }: NewTaskModalProps): import("react").JSX.Element;

package/lib/types/client/board/TaskCard.d.ts

@@ -2,11 +2,21 @@ import type { TaskRecord } from '../../core/tasks.ts';
 /** Compact relative/absolute time label. */
 export declare function formatHostTimestamp(ms: number, timeZone?: string): string;
 export declare function formatTime(ms: number, timeZone?: string): string;
-declare function TaskCardInner({ task, pending, timeZone, onClick }: {
+declare function TaskCardInner({ task, pending, timeZone, onClick, subtaskCount, isSubtask, subtasksDone, subtasksRunning, subtasksFailed, }: {
     task: TaskRecord;
     pending: boolean;
     timeZone?: string;
     onClick: () => void;
+    /** Direct subtasks of this card, shown as a badge (0 hides it). */
+    subtaskCount?: number;
+    /** Whether this card is itself a subtask. */
+    isSubtask?: boolean;
+    /** Direct subtasks already settled as done, for the roll-up badge. */
+    subtasksDone?: number;
+    /** Direct subtasks currently running, for the roll-up badge. */
+    subtasksRunning?: number;
+    /** Direct subtasks that failed, for the roll-up badge. */
+    subtasksFailed?: number;
 }): import("react").JSX.Element;
 /** Memoized card: re-renders only when the card's own task record changes. */
 export declare const TaskCard: import("react").MemoExoticComponent<typeof TaskCardInner>;

package/lib/types/client/locales.d.ts

@@ -156,12 +156,16 @@ export declare const zh: {
     'exec.mode.brokenSuffix': string;
     'exec.mode.removed': string;
     'exec.permission.default': string;
+    'exec.permission.inheritParent': string;
     'exec.permission.read-only': string;
     'exec.permission.workspace-write': string;
     'exec.permission.danger-full-access': string;
     'exec.model.default': string;
     'exec.model.unknown': string;
     'exec.reuseSession': string;
+    'exec.teamRun': string;
+    'exec.teamRunHint': string;
+    'exec.teamRunUnavailable': string;
     'exec.reuseSessionHint': string;
     'detail.executionSettings': string;
     'exec.hint': string;
@@ -192,6 +196,35 @@ export declare const zh: {
     'settings.unsaved': string;
     'settings.saveFailed': string;
     'settings.invalidNumber': string;
+    'settings.maxSubtaskDepth': string;
+    'settings.maxSubtaskDepthHint': string;
+    'settings.maxSubtaskDepthOption': string;
+    'detail.parent': string;
+    'detail.parent.open': string;
+    'detail.subtasks': string;
+    'detail.subtasks.empty': string;
+    'detail.subtasks.add': string;
+    'detail.subtasks.link': string;
+    'detail.subtasks.detach': string;
+    'detail.subtasks.runningLock': string;
+    'detail.subtasks.runHint': string;
+    'detail.subtasks.waiting': string;
+    'detail.subtasks.depthLimit': string;
+    'detail.subtasks.hostOnly': string;
+    'new.subtaskTitle': string;
+    'new.subtaskInherit': string;
+    'link.subtask.title': string;
+    'link.subtask.hint': string;
+    'link.subtask.empty': string;
+    'link.subtask.confirm': string;
+    'card.subtask': string;
+    'card.subtasks': string;
+    'card.subtasksFailed': string;
+    'card.subtasksRunning': string;
+    'card.subtasksBreakdown': string;
+    'board.hideSubtasks': string;
+    'board.showSubtasks': string;
+    'board.subtaskFilterHint': string;
 };
 /** en dictionary, complete against the zh key set. */
 export declare const en: Record<keyof typeof zh, string>;

package/lib/types/core/controller.d.ts

@@ -90,6 +90,12 @@ export interface ExecutionOptionsSnapshot {
     presets: readonly ExecutionPresetOption[];
     models?: readonly ExecutionModelOption[];
 }
+/**
+ * Host-owned state the browser mirrors. SSE frames carry the volatile subset
+ * (revision/scheduler/power); a full snapshot also carries the deployment
+ * constants the UI reads (session default permission, subtask depth).
+ */
+export type HostMirror = Pick<TaskBoardSnapshot, 'revision' | 'scheduler' | 'power' | 'sessionDefaultPermission' | 'maxSubtaskDepth' | 'teamRunAvailable'>;
 /** Immutable controller snapshot for UI subscriptions. */
 export interface ControllerSnapshot {
     tasks: readonly TaskRecord[];
@@ -105,7 +111,7 @@ export interface ControllerSnapshot {
     /** Whether this deployment can parse pasted text into task fields (issue #1540). */
     canParseTask?: boolean;
     transportError?: string;
-    host?: Pick<TaskBoardSnapshot, 'revision' | 'scheduler' | 'power' | 'sessionDefaultPermission'>;
+    host?: HostMirror;
 }
 /** The selected task (resolved from the ledger), or undefined. */
 export declare function selectedTaskOf(snapshot: ControllerSnapshot): TaskRecord | undefined;
@@ -195,6 +201,14 @@ export declare class BoardController {
      * @returns true when applied.
      */
     archiveTask(id: string): boolean;
+    /**
+     * Attach an existing task under a parent (or detach it with a null parent)
+     * through the Host. The lineage gate — parent exists and is on-board, no
+     * cycle, depth within the deployment limit — belongs to the Host; a refusal
+     * surfaces through the transport error like every other rejected action.
+     * @returns true when the link was accepted by the authority.
+     */
+    setParent(id: string, parentId: string | null): Promise<boolean>;
     /** Restore an archived task back onto the board (same status column). */
     restoreTask(id: string): boolean;
     /**
@@ -263,6 +277,21 @@ export declare class BoardController {
      * re-serialize the whole ledger per tab even while nothing changes.
      */
     private onRemoteEvent;
+    /**
+     * Deployment subtask depth limit the browser mirrors from the last Host
+     * snapshot; the fallback is the deployment default for the legacy path (no
+     * transport) and for the window before the first snapshot arrives.
+     */
+    private mirrorDepth;
+    /**
+     * Project a Host snapshot onto the browser's mirror. SSE frames and partial
+     * snapshots carry only the volatile subset (revision/scheduler/power), so the
+     * deployment constants the UI reads — the session-default permission the
+     * confirmation banner compares against and the subtask depth limit — are
+     * carried over from the last full snapshot instead of being dropped by a
+     * heartbeat frame.
+     */
+    private mirrorOf;
     private refreshRemote;
     private acceptRemote;
     private notify;

package/lib/types/core/subtask.d.ts

@@ -0,0 +1,122 @@
+/**
+ * Subtask lineage: the depth gate, the ancestry/descendant queries, the
+ * cascade participant set one run request opens, the deferred settlement of a
+ * cascade parent, and the execution-target inheritance a subtask resolves at
+ * run time.
+ *
+ * Framework-free (no cordis, no runtime imports) so every rule is
+ * unit-testable in isolation. The Host ledger is the only authority; the
+ * browser mirrors these predicates to enable or disable controls, never to
+ * decide them.
+ */
+import type { ExecutionOutcome, ExecutionRecord, TaskRecord } from './tasks.ts';
+/** Lowest configurable subtask depth. */
+export declare const SUBTASK_DEPTH_MIN = 1;
+/** Highest configurable subtask depth. */
+export declare const SUBTASK_DEPTH_MAX = 3;
+/** Deployment default: one level of subtasks, and no subtask of a subtask. */
+export declare const DEFAULT_SUBTASK_DEPTH = 1;
+/**
+ * Clamp a configured depth into the supported range. Anything unusable
+ * (absent, non-numeric, not finite) falls back to the default, so a bad
+ * configuration narrows the tree instead of lifting the guard.
+ */
+export declare function normalizeSubtaskDepth(value: unknown): number;
+/** Whether an unknown value is a settled execution outcome. */
+export declare function isExecutionOutcome(value: unknown): value is ExecutionOutcome;
+/**
+ * Nearest-first ancestor chain of a task. The walk is cycle-safe and bounded
+ * by the ledger size rather than by the deployment maximum: a chain stored
+ * under a larger limit survives that limit being lowered, and restore and
+ * inheritance must still see all of it.
+ */
+export declare function ancestorChain(tasks: readonly TaskRecord[], task: TaskRecord): TaskRecord[];
+/** Root-to-task depth: a root task is 0, its subtask 1, and so on. */
+export declare function taskDepth(tasks: readonly TaskRecord[], id: string): number;
+/** Direct subtasks of a task, in ledger order. */
+export declare function directSubtasks(tasks: readonly TaskRecord[], id: string): TaskRecord[];
+/**
+ * Descendants of a task in breadth-first order, bounded by maxSubtaskDepth
+ * total depth. The visited set keeps a malformed ledger from looping.
+ */
+export declare function descendantTasks(tasks: readonly TaskRecord[], id: string, maxSubtaskDepth: number): TaskRecord[];
+/**
+ * Height of a task's own subtree (0 for a leaf), bounded by the hard maximum.
+ * The visited set makes the walk terminate on a cyclic hand-edited ledger
+ * instead of recursing until the stack overflows.
+ */
+export declare function subtreeHeight(tasks: readonly TaskRecord[], id: string, visited?: ReadonlySet<string>): number;
+/** Why a parent link was refused; also the source of the Host error text. */
+export type ParentLinkRejection = 'unknown-task' | 'unknown-parent' | 'archived-parent' | 'self-parent' | 'cycle' | 'depth-exceeded';
+export interface ParentLinkCheck {
+    /** True when the link (or the detachment) may be stored. */
+    ok: boolean;
+    /** Why it was refused; absent when ok. */
+    reason?: ParentLinkRejection;
+}
+/**
+ * Whether childId may be attached under parentId. A null parent detaches and
+ * is always allowed for a known task. Otherwise the link must name an
+ * on-board task that is neither the child itself nor one of its descendants,
+ * and the resulting depth (parent depth + 1 + the child own subtree height)
+ * must stay within maxSubtaskDepth.
+ */
+export declare function checkParentLink(tasks: readonly TaskRecord[], childId: string, parentId: string | null, maxSubtaskDepth: number): ParentLinkCheck;
+/**
+ * The tasks one run request opens executions for: the requested task first,
+ * then its on-board descendants within the configured depth. Archived tasks
+ * never run; a participant that already has an open execution is skipped by
+ * the caller, which cannot start it twice.
+ */
+export declare function cascadeTargets(tasks: readonly TaskRecord[], rootId: string, maxSubtaskDepth: number): TaskRecord[];
+/** One still-open execution belonging to a cascade run group. */
+export interface OpenCascadeChild {
+    taskId: string;
+    execution: ExecutionRecord;
+}
+/** The open execution of a task inside a run group, if it still exists. */
+export declare function openGroupExecution(task: TaskRecord, runGroupId: string): ExecutionRecord | undefined;
+/**
+ * The direct subtasks of parentTaskId whose execution in this run group is
+ * still open: the parent remaining waiters. The parent may settle once this
+ * list is empty and its own outcome is known.
+ */
+export declare function pendingCascadeChildren(tasks: readonly TaskRecord[], parentTaskId: string, runGroupId: string): OpenCascadeChild[];
+/**
+ * Fold a cascade parent own outcome and its children outcomes into one
+ * verdict: failure dominates, then cancellation, then success. The error text
+ * is the first failure, falling back to the first cancellation.
+ */
+export declare function combineCascadeOutcome(entries: readonly {
+    result: ExecutionOutcome;
+    error?: string;
+}[]): {
+    result: ExecutionOutcome;
+    error: string | undefined;
+};
+/**
+ * The permission a task would actually run under: its handover bundle's pin
+ * wins over the plain pin field, exactly as the runner resolves it.
+ */
+export declare function effectiveTaskPermission(task: TaskRecord): TaskRecord['permission'];
+/**
+ * Resolve the execution targets a (sub)task actually runs with: its own value
+ * wins, and an unset target inherits the nearest ancestor up to the root.
+ * Workspace, agent preset and model inherit the ancestor's PIN only — a
+ * handover bundle is a per-card continuation artefact and is never inherited.
+ * The permission inherits the ancestor's EFFECTIVE binding, and its human
+ * confirmation travels with it, so a subtask of an already-confirmed elevated
+ * card is runnable while a subtask's own unconfirmed binding stays gated.
+ */
+/**
+ * The immutable teammate name for one team-mode member. Teammate names are
+ * lower-kebab-case and must stay unique for the lifetime of the Team, so the
+ * run-group token is appended: two runs of the same tree never collide. A title
+ * with no ASCII word characters (a CJK title, for example) keeps a stable
+ * generic prefix and is still distinguished by the token.
+ * @param title - the member task's title.
+ * @param token - the run group id (the task id when no group is recorded).
+ * @returns the teammate name handed to the Agent Teams service.
+ */
+export declare function teammateName(title: string, token: string): string;
+export declare function resolveExecutionTargets(task: TaskRecord, tasks: readonly TaskRecord[], maxSubtaskDepth?: number): TaskRecord;

package/lib/types/core/tasks.d.ts

@@ -8,6 +8,8 @@ import type { FreezeSnapshot } from './freeze-snapshot.ts';
 import type { TaskHandover, TaskHandoverInput } from './handover.ts';
 /** Task lifecycle status, one per kanban column. */
 export type TaskStatus = 'backlog' | 'todo' | 'running' | 'done' | 'failed';
+/** Settled outcome of one execution attempt. */
+export type ExecutionOutcome = 'succeeded' | 'failed' | 'cancelled';
 /**
  * One real execution attempt: the run's own id, the dsh session that ran it
  * (filled once the session is created), and the settled outcome once the
@@ -23,7 +25,7 @@ export interface ExecutionRecord {
     /** When the run settled; absent while still running. */
     endedAt: number | undefined;
     /** Outcome once settled. */
-    result: 'succeeded' | 'failed' | 'cancelled' | undefined;
+    result: ExecutionOutcome | undefined;
     /** Human failure text when the run failed (prompt rejection or agent error). */
     error: string | undefined;
     /**
@@ -36,6 +38,20 @@ export interface ExecutionRecord {
     frozenAt?: number;
     /** Freeze source session captured from the card snapshot when the run opened. */
     frozenBy?: string;
+    /**
+     * Cascade run group shared by the parent execution and every descendant
+     * execution one run request opened. Absent on a plain single-task run.
+     */
+    runGroupId?: string;
+    /**
+     * A cascade parent's own session outcome, recorded as soon as its own turn
+     * settles and held while its subtask executions finish. The execution stays
+     * open (no `endedAt`) until the last child settles; the Host monitor skips
+     * an execution whose own outcome is already recorded.
+     */
+    ownResult?: ExecutionOutcome;
+    /** Human failure text that arrived with {@link ownResult}. */
+    ownError?: string;
 }
 /**
  * Maximum number of execution records retained per task. Older settled runs
@@ -140,6 +156,14 @@ export interface TaskRecord {
     description: string;
     /** The prompt sent to dsh when this task is executed. */
     prompt: string;
+    /**
+     * Parent task id: present only on a subtask. The Host owns the lineage gate
+     * (see `core/subtask.ts`), which refuses a cycle, an archived parent, and
+     * any link that would exceed `maxSubtaskDepth` — so every chain the Host
+     * wrote under the current setting is at most that many links long. Lowering
+     * the limit later neither rewrites nor deletes an already stored link.
+     */
+    parentId?: string;
     /** Current column. */
     status: TaskStatus;
     /** Creation instant (ms epoch). */
@@ -181,6 +205,15 @@ export interface TaskRecord {
      * {@link reusableSessionId}).
      */
     reuseSession?: boolean;
+    /**
+     * Run this task's subtree as an Agent Team instead of one Host-launched
+     * session per participant: the root becomes the Team Lead session and the
+     * Host spawns one teammate for each direct subtask inside it. Absent or false
+     * keeps the plain concurrent cascade. A deployment that does not serve the
+     * Agent Teams service refuses a team run instead of silently falling back,
+     * and a subtask's own permission pin cannot be honored in this mode.
+     */
+    teamRun?: boolean;
     /**
      * Frozen context snapshot for a continuation card; absent on plain tasks.
      * Sanitized before it enters the ledger (redaction, slash-command taint,
@@ -231,6 +264,12 @@ export interface NewTaskInput {
     title: string;
     description: string;
     prompt: string;
+    /**
+     * Parent task id, turning this creation into a subtask. Absent keeps a root
+     * task; the create use case validates the link (existence, depth) and
+     * inherits the parent's unset execution targets.
+     */
+    parentId?: string;
     /** Workspace the execution must run in; empty/absent = the recent workspace. */
     workspaceId?: string;
     /** Agent preset the execution session must be composed from; empty/absent = deployment default. */
@@ -241,6 +280,8 @@ export interface NewTaskInput {
     model?: string;
     /** Reuse the previous execution's session for later runs (issue #1419). */
     reuseSession?: boolean;
+    /** Run the subtree as an Agent Team (Team Lead session plus one teammate per direct subtask). */
+    teamRun?: boolean;
     /**
      * Optional scheduled-run rule requested at creation time (the new-task
      * dialog): an enable flag plus a 5-field cron expression. The create use
@@ -308,8 +349,10 @@ export declare function withSchedule(task: TaskRecord, patch: Partial<ScheduleRu
 /**
  * Open a fresh execution on a task: move it to 'running' and append a
  * running execution record. Returns the new task and the new execution.
+ * @param runGroupId - cascade run group, when this run also opened executions
+ *   for the task's subtasks (see `core/subtask.ts`).
  */
-export declare function startExecution(task: TaskRecord, now: number, executionId: string, initiatedBy?: string): {
+export declare function startExecution(task: TaskRecord, now: number, executionId: string, initiatedBy?: string, runGroupId?: string): {
     task: TaskRecord;
     execution: ExecutionRecord;
 };
@@ -318,6 +361,6 @@ export declare function startExecution(task: TaskRecord, now: number, executionI
  * matching column. No-op (returns the input task) when the execution is not
  * the task's latest or is already settled.
  */
-export declare function settleExecution(task: TaskRecord, executionId: string, outcome: 'succeeded' | 'failed' | 'cancelled', now: number, error: string | undefined): TaskRecord;
+export declare function settleExecution(task: TaskRecord, executionId: string, outcome: ExecutionOutcome, now: number, error: string | undefined): TaskRecord;
 /** A settled-execution summary string for the detail view. */
 export declare function executionLabel(execution: ExecutionRecord): string;

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

@@ -1,9 +1,3 @@
-/**
- * Archive/restore task use case: move a task off the main board and back,
- * whatever its status but `running`. The task keeps its status, execution history, and
- * transcript references, while archiving disarms any schedule so it cannot
- * create more execution records until the user restores and re-enables it.
- */
 import type { TaskRecord } from '../tasks.ts';
 /** Result of an archive transition. */
 export interface ArchiveTaskResult {
@@ -13,11 +7,14 @@ export interface ArchiveTaskResult {
     archived: boolean;
 }
 /**
- * Archive one task: only a `running` task stays on the board (its runner
- * still owns its lifecycle until the execution settles); every other status
- * can be archived. Archiving disarms a schedule; already-archived tasks are
- * a no-op.
+ * Archive one task and its subtasks: only a running member keeps the group on
+ * the board (its runner still owns its lifecycle until the execution settles);
+ * any other status can be archived. Archiving disarms schedules; an
+ * already-archived task is a no-op.
+ */
+export declare function applyArchiveTask(tasks: readonly TaskRecord[], id: string, now: number, maxSubtaskDepth?: number): ArchiveTaskResult;
+/**
+ * Restore one task back onto the main board, together with its ancestors (an
+ * on-board subtask must not point at an archived parent) and its subtasks.
  */
-export declare function applyArchiveTask(tasks: readonly TaskRecord[], id: string, now: number): ArchiveTaskResult;
-/** Restore one task back onto the main board (clears the archive marker). */
-export declare function applyRestoreTask(tasks: readonly TaskRecord[], id: string, now: number): ArchiveTaskResult;
+export declare function applyRestoreTask(tasks: readonly TaskRecord[], id: string, now: number, maxSubtaskDepth?: number): ArchiveTaskResult;

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[];