@linxin666/dsh-client-ui-task-board 0.4.4 → 0.4.6

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

@@ -24,6 +24,13 @@ export interface PluginSettingsCardProps<TKey extends string = string> {
     descriptionKey: TKey;
     /** Optional rich header description rendered instead of the plain t(descriptionKey) text (the plain text stays as the tooltip). */
     descriptionNode?: ReactNode;
+    /**
+     * Optional leading mark identifying the plugin. A card without one keeps the
+     * plain official header shape, so the chrome stays a readable sibling of the
+     * built-in PluginCard wherever a family plugin lands in the official bundle
+     * seat.
+     */
+    icon?: ReactNode;
     /** The card's form state: availability, writability, and what a save would do. */
     state: CardShell;
     /** Write every staged edit. */

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

@@ -3,9 +3,10 @@
  * idle-sleep protection. Registers into the `web-ui.plugin.item` child slot
  * the Web UI plugin group renders, bound to the `task-board` namespace.
  */
-import type { InjectFace, PropsLocale, PropsRuntime } from '@deepseek-ai/dsh-client-ui-slots';
+import type { InjectFace, PropsLocale, PropsRenderSlots, PropsRuntime } from '@deepseek-ai/dsh-client-ui-slots';
 import type { SnapshotStore } from '@deepseek-ai/dsh-client-store';
 import type { ConfigForm } from '@deepseek-ai/dsh-client-ui-settings/client';
+import type { TaskBoardExtensionDispatch } from '../core/extension.ts';
 import { type CardActions, type CardShell, type FieldState as CardFieldState } from './settings-form.ts';
 /** The task-board fields this card edits (the namespace's full schema). */
 export interface TaskBoardSettings {
@@ -17,6 +18,20 @@ export interface TaskBoardSettings {
     preventIdleSleep?: boolean;
     /** Subtask depth limit (1..3); 1 means a single level of subtasks. */
     maxSubtaskDepth?: number;
+    /** Roster-poll cadence in seconds while the board has work to reconcile. */
+    sessionPollSeconds?: number;
+    /**
+     * GLOBAL native /goal switch (default off): the master control over whether
+     * this board starts a run with dsh's built-in /goal at all. Frozen per
+     * execution.
+     */
+    goalRunEnabled?: boolean;
+    /** Goal acceptance for this board's executions (default on). */
+    goalVerification?: boolean;
+    /** Judge model route for goal acceptance; blank inherits the host default. */
+    goalVerificationModel?: string;
+    /** Judge reasoning effort; blank inherits the host default level. */
+    goalVerificationReasoningEffort?: string;
 }
 /** What the task-board card renders. */
 export interface TaskBoardSettingsCardState extends CardShell {
@@ -28,6 +43,16 @@ export interface TaskBoardSettingsCardState extends CardShell {
     preventIdleSleep: CardFieldState;
     /** Subtask depth limit field. */
     maxSubtaskDepth: CardFieldState;
+    /** Roster-poll cadence field. */
+    sessionPollSeconds: CardFieldState;
+    /** GLOBAL native /goal switch. */
+    goalRunEnabled: CardFieldState;
+    /** Goal-acceptance switch. */
+    goalVerification: CardFieldState;
+    /** Judge model route field. */
+    goalVerificationModel: CardFieldState;
+    /** Judge reasoning-effort field. */
+    goalVerificationReasoningEffort: CardFieldState;
 }
 /** The registration-side face the card's slot entry injects. */
 export interface TaskBoardSettingsCardFace extends CardActions {
@@ -35,13 +60,16 @@ export interface TaskBoardSettingsCardFace extends CardActions {
         /** Card snapshot bound by the renderer as useTaskBoardSettingsCard. */
         taskBoardSettingsCard: SnapshotStore<TaskBoardSettingsCardState>;
     };
+    /** Deliver one provider action over the board's same-origin channel. */
+    dispatch: TaskBoardExtensionDispatch;
 }
 /** Bridges the `task-board` settings form onto the card's staged form. */
 export declare class TaskBoardSettingsCardController {
+    private readonly dispatch;
     private readonly form;
     private readonly store;
     /** @param scope - the bound configuration form for the `task-board` namespace. */
-    constructor(scope: ConfigForm<TaskBoardSettings>);
+    constructor(scope: ConfigForm<TaskBoardSettings>, dispatch: TaskBoardExtensionDispatch);
     private projection;
     /**
      * Build the face the card's slot registration injects.
@@ -55,7 +83,7 @@ export declare class TaskBoardSettingsCardController {
     dispose(): void;
 }
 /** Props the renderer binds for the task-board card. */
-export type TaskBoardSettingsCardProps = PropsRuntime<'web-ui.plugin.item'> & PropsLocale<'task-board'> & InjectFace<TaskBoardSettingsCardFace>;
+export type TaskBoardSettingsCardProps = PropsRuntime<'web-ui.plugin.item'> & PropsLocale<'task-board'> & InjectFace<TaskBoardSettingsCardFace> & PropsRenderSlots<'task-board.settings.section'>;
 /**
  * Render the task-board card.
  * @param props - locale copy, the card snapshot, and its form actions.

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

@@ -0,0 +1,3 @@
+export declare function ClampedMarkdown({ source }: {
+    source: string;
+}): import("react").JSX.Element;

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

@@ -1,3 +1,4 @@
+import { type OverlayPhase } from './overlay.tsx';
 /** Confirm overlay props. */
 export interface ConfirmDialogProps {
     title: string;
@@ -5,8 +6,10 @@ export interface ConfirmDialogProps {
     confirmLabel: string;
     /** Render the confirm button in the danger style. */
     danger?: boolean;
+    /** Which leg of the enter/exit motion pair the surface is on. */
+    phase?: OverlayPhase;
     onCancel: () => void;
     onConfirm: () => void;
 }
 /** Small confirm overlay. */
-export declare function ConfirmDialog({ title, message, confirmLabel, danger, onCancel, onConfirm }: ConfirmDialogProps): import("react").JSX.Element;
+export declare function ConfirmDialog({ title, message, confirmLabel, danger, phase, onCancel, onConfirm }: ConfirmDialogProps): import("react").JSX.Element;

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

@@ -1,14 +1,17 @@
 import type { BoardController } from '../../core/controller.ts';
 import { type TaskRecord } from '../../core/tasks.ts';
+import type { OverlayPhase } from './overlay.tsx';
 /** Edit-task form overlay. */
-export declare function EditTaskModal({ controller, task, onClose }: {
+export declare function EditTaskModal({ controller, task, onClose, phase }: {
     controller: BoardController;
     task: TaskRecord;
     onClose: () => void;
+    phase?: OverlayPhase;
 }): import("react").JSX.Element;
 /** Edit-tags modal: edit labels only, shown for tasks after first execution. */
-export declare function EditTagsModal({ controller, task, onClose }: {
+export declare function EditTagsModal({ controller, task, onClose, phase }: {
     controller: BoardController;
     task: TaskRecord;
     onClose: () => void;
+    phase?: OverlayPhase;
 }): import("react").JSX.Element;

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

@@ -1,11 +1,14 @@
 import type { BoardController } from '../../core/controller.ts';
-import type { TaskRecord } from '../../core/tasks.ts';
+import { type TaskRecord } from '../../core/tasks.ts';
+import { type OverlayPhase } from './overlay.tsx';
 /** Link-subtask overlay props. */
 export interface LinkSubtaskModalProps {
     controller: BoardController;
     /** The task the picked card becomes a subtask of. */
     parent: TaskRecord;
     onClose: () => void;
+    /** Which leg of the enter/exit motion pair the surface is on. */
+    phase?: OverlayPhase;
 }
 /** Link-subtask overlay. */
-export declare function LinkSubtaskModal({ controller, parent, onClose }: LinkSubtaskModalProps): import("react").JSX.Element;
+export declare function LinkSubtaskModal({ controller, parent, onClose, phase }: LinkSubtaskModalProps): import("react").JSX.Element;

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

@@ -1,5 +1,6 @@
 import type { BoardController } from '../../core/controller.ts';
 import { type TaskRecord } from '../../core/tasks.ts';
+import type { OverlayPhase } from './overlay.tsx';
 export interface NewTaskModalProps {
     controller: BoardController;
     onClose: () => void;
@@ -18,6 +19,8 @@ export interface NewTaskModalProps {
      * carries the parent link; unset targets inherit again at run time.
      */
     parentTask?: TaskRecord;
+    /** Which leg of the enter/exit motion pair the surface is on. */
+    phase?: OverlayPhase;
 }
 /** New-task form overlay. */
-export declare function NewTaskModal({ controller, onClose, initialTask, defaultWorkspaceId, onDuplicateSuccess, parentTask }: NewTaskModalProps): import("react").JSX.Element;
+export declare function NewTaskModal({ controller, onClose, initialTask, defaultWorkspaceId, onDuplicateSuccess, parentTask, phase }: NewTaskModalProps): import("react").JSX.Element;

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

@@ -0,0 +1,26 @@
+import type { BoardController } from '../../core/controller.ts';
+import { type TaskRecord } from '../../core/tasks.ts';
+import { type OverlayPhase } from './overlay.tsx';
+/** One label as the manager lists it: its definition plus how many tasks carry it. */
+export interface TagUsage {
+    name: string;
+    promptPrefix?: string;
+    /** Tasks carrying the label right now. */
+    count: number;
+}
+/**
+ * Labels in use, in board order (first occurrence wins, exactly like the
+ * filter row), each with its usage count.
+ * @param tasks - the whole ledger (board and archive).
+ * @returns one row per label.
+ */
+export declare function tagUsage(tasks: readonly TaskRecord[]): TagUsage[];
+/** Label-manager overlay props. */
+export interface TagManagerModalProps {
+    controller: BoardController;
+    onClose: () => void;
+    /** Which leg of the enter/exit motion pair the surface is on. */
+    phase?: OverlayPhase;
+}
+/** Label-manager overlay. */
+export declare function TagManagerModal({ controller, onClose, phase }: TagManagerModalProps): import("react").JSX.Element;

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

@@ -2,7 +2,14 @@ import { type BoardController } from '../../core/controller.ts';
 import { type TaskRecord } from '../../core/tasks.ts';
 /** Sentinel option value of the project row's "register a new project" entry. */
 export declare const NEW_PROJECT_VALUE = "__dsh_new_project__";
-/** Case-insensitive title/description/tag/freeze-snapshot match. */
+/**
+ * Case-insensitive title/description/tag/freeze-snapshot/provider-payload match.
+ *
+ * A leading `#` is dropped from the needle. Providers render their own
+ * identifiers with that prefix (`#1758`) and the board attaches no meaning to
+ * it: stripping it keeps the identifier searchable exactly as it is written on
+ * screen, without the board learning any provider's vocabulary.
+ */
 export declare function matchesFilter(task: TaskRecord, filter: string): boolean;
 /**
  * Whether a task carries every selected label (issue #1521). Multi-select is
@@ -11,6 +18,8 @@ export declare function matchesFilter(task: TaskRecord, filter: string): boolean
  * back in when a second label is added.
  */
 export declare function matchesTagFilter(task: TaskRecord, selected: readonly string[]): boolean;
+/** Cards a grouped column renders before the oldest group folds. */
+export declare const COLUMN_FOLD_THRESHOLD = 30;
 /** Board component; subscribes to the controller snapshot. */
 export declare function TaskBoard({ controller }: {
     controller: BoardController;

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

@@ -2,11 +2,24 @@ 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, subtaskCount, isSubtask, subtasksDone, subtasksRunning, subtasksFailed, }: {
+/**
+ * Card time label: relative within a day, otherwise the calendar date read in
+ * the Host time zone (the same zone the tooltip and the detail view use), so a
+ * card never shows a browser-local date beside a Host-zone tooltip.
+ * @param ms - the instant.
+ * @param timeZone - Host IANA zone; absent uses the browser zone.
+ * @param now - the current instant.
+ */
+export declare function formatCardTime(ms: number, timeZone?: string, now?: number): string;
+declare function TaskCardInner({ task, pending, timeZone, onClick, onOpenSession, compact, subtaskCount, isSubtask, subtasksDone, subtasksRunning, subtasksFailed, }: {
     task: TaskRecord;
     pending: boolean;
     timeZone?: string;
     onClick: () => void;
+    /** Open an execution session; absent renders the session mark inert. */
+    onOpenSession?: (sessionId: string) => void;
+    /** Single-line density used by long settled columns. */
+    compact?: boolean;
     /** Direct subtasks of this card, shown as a badge (0 hides it). */
     subtaskCount?: number;
     /** Whether this card is itself a subtask. */

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

@@ -1,7 +1,9 @@
 import type { BoardController } from '../../core/controller.ts';
 import { type TaskRecord } from '../../core/tasks.ts';
+import { type OverlayPhase } from './overlay.tsx';
 /** Task detail overlay. */
-export declare function TaskDetail({ controller, task }: {
+export declare function TaskDetail({ controller, task, phase }: {
     controller: BoardController;
     task: TaskRecord;
+    phase?: OverlayPhase;
 }): import("react").JSX.Element;

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

@@ -6,8 +6,9 @@
  */
 import { type ReactNode } from 'react';
 import { type TaskTag } from '../../core/tasks.ts';
+import { type OverlayPhase } from './overlay.tsx';
 /** Modal overlay: closes on backdrop press, submits through the form. */
-export declare function ModalShell({ ariaLabel, title, error, pending, submitLabel, onSubmit, onClose, secondaryAction, children, }: {
+export declare function ModalShell({ ariaLabel, title, error, pending, submitLabel, onSubmit, onClose, secondaryAction, phase, children, }: {
     ariaLabel: string;
     title: string;
     error: string | undefined;
@@ -20,6 +21,8 @@ export declare function ModalShell({ ariaLabel, title, error, pending, submitLab
         label: string;
         onSubmit: () => void;
     };
+    /** Which leg of the enter/exit motion pair the surface is on. */
+    phase?: OverlayPhase;
     children: ReactNode;
 }): import("react").JSX.Element;
 /**

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

@@ -0,0 +1,23 @@
+/**
+ * One execution's goal-acceptance report.
+ *
+ * Rendered inside the execution-history row, so a rerun or a scheduled run
+ * keeps its OWN report and a later cycle never overwrites an earlier verdict.
+ * It shows what the board decided and the evidence it decided on: the verdict,
+ * the judge route and reasoning level, the acceptance count, the total and
+ * per-criterion scores against their threshold, the findings the judge located,
+ * the evidence scope with its truncation, and the token usage.
+ *
+ * Deliberately adds no new `data-dsh-part` value: the part enum is owned by the
+ * cross-repository semantic-attribute contract, and this report reuses the
+ * execution row's existing markup instead of extending that enum.
+ */
+import { type ExecutionVerification } from '../../core/verification.ts';
+/**
+ * Render one execution's acceptance report.
+ * @param props - the execution's persisted acceptance block.
+ * @returns the report, or nothing when acceptance never applied.
+ */
+export declare function VerificationReport({ verification }: {
+    verification: ExecutionVerification;
+}): import("react").JSX.Element | null;

package/lib/types/client/board/card-view.d.ts

@@ -0,0 +1,113 @@
+/**
+ * Card view model: the pure derivations a task card renders from its record.
+ *
+ * Everything here is a function of the task record (plus the clock and the
+ * Host time zone for the recency groups), so the card stays a thin renderer and
+ * every rule is unit-testable without mounting React. Nothing here writes the
+ * record: the type prefix, the tone and the time label are presentation only.
+ *
+ * @module @linxin666/dsh-client-ui-task-board/client/board/card-view
+ */
+import { type ExecutionOutcome, type ExecutionRecord, type TaskRecord, type TaskStatus } from '../../core/tasks.ts';
+import type { TaskBoardKey } from '../locales.ts';
+/** A title split into its bracketed type prefix and the remaining text. */
+export interface TitleParts {
+    /** Bracketed type prefix such as `Bug` from `[Bug]: ...`; absent when none. */
+    kind?: string;
+    /** Title text without the prefix (the whole title when there is no prefix). */
+    text: string;
+}
+/**
+ * Split an issue-form style type prefix off a title. The prefix becomes a
+ * badge, so the clamped title lines carry the text the reader scans for. A
+ * title that is only a prefix keeps its full text.
+ * @param summary - the plain-text title.
+ * @returns the prefix (when present) and the remaining title text.
+ */
+export declare function splitTitleKind(summary: string): TitleParts;
+/** Stripe tone of a card: the state of its latest execution. */
+export type CardTone = 'running' | ExecutionOutcome;
+/** What the card reports about its latest execution. */
+export interface CardOutcome {
+    /** Stripe tone; absent on an archived card or a card that never ran. */
+    tone?: CardTone;
+    /** The latest execution record, when the card ran at least once. */
+    latest?: ExecutionRecord;
+    /**
+     * The column disagrees with the latest settled run: a card in Done whose last
+     * run did not succeed, or a card in Failed whose last run succeeded. The
+     * column was then set by hand or by a provider (a closed issue), and the
+     * card says so instead of letting a red run count read as a contradiction.
+     */
+    declared: boolean;
+}
+/**
+ * Derive the card's execution outcome.
+ * @param task - the task record.
+ * @param archived - whether the card renders in the archive view.
+ */
+export declare function cardOutcome(task: TaskRecord, archived: boolean): CardOutcome;
+/** Locale key of the latest settled result shown before the run count. */
+export declare const RESULT_KEY: Record<ExecutionOutcome, TaskBoardKey>;
+/** The one time a card shows, and what that time means. */
+export interface CardTimeline {
+    /** Locale key with a `{time}` placeholder. */
+    key: TaskBoardKey;
+    /** The instant (ms epoch). */
+    at: number;
+}
+/**
+ * Pick the time that tells cards in the same column apart. `updatedAt` moves
+ * on every provider sync, so a column of synced cards would all read
+ * "updated 4m"; each column instead shows the instant its cards differ by:
+ * planning columns the creation time, an executing card its start, settled
+ * columns the latest run's settlement, the archive the archive time.
+ * @param task - the task record.
+ * @param archived - whether the card renders in the archive view.
+ */
+export declare function cardTimeline(task: TaskRecord, archived: boolean): CardTimeline;
+/** Recency bucket of a settled card. */
+export type RecencyGroup = 'today' | 'week' | 'earlier';
+/** Group order, newest first. */
+export declare const RECENCY_GROUPS: readonly RecencyGroup[];
+/** Locale key of each recency group header. */
+export declare const RECENCY_KEY: Record<RecencyGroup, TaskBoardKey>;
+/**
+ * Bucket an instant: the same Host calendar day as now, the last seven days, or
+ * earlier.
+ * @param at - the instant to bucket.
+ * @param now - the current instant.
+ * @param timeZone - Host IANA zone the calendar day is read in.
+ */
+export declare function recencyGroup(at: number, now: number, timeZone?: string): RecencyGroup;
+/** One recency group and its items, newest first. */
+export interface RecencyBucket<T> {
+    group: RecencyGroup;
+    items: T[];
+}
+/**
+ * Sort items newest first and split them into recency groups; empty groups are
+ * omitted.
+ * @param items - the items to group.
+ * @param at - the instant each item is ordered and bucketed by.
+ * @param now - the current instant.
+ * @param timeZone - Host IANA zone.
+ */
+export declare function groupByRecency<T>(items: readonly T[], at: (item: T) => number, now: number, timeZone?: string): RecencyBucket<T>[];
+/** Columns that render compact by default: the long settled column. */
+export declare const DEFAULT_COMPACT_COLUMNS: readonly TaskStatus[];
+/** Browser storage key of the per-column density choice. */
+export declare const COMPACT_COLUMNS_KEY = "dsh.taskBoard.compactColumns.v1";
+/**
+ * Read the columns the user set to compact. A missing, unreadable or malformed
+ * value falls back to the default rather than failing the board.
+ * @param storage - browser storage (absent outside a browser).
+ */
+export declare function readCompactColumns(storage: Pick<Storage, 'getItem'> | undefined): TaskStatus[];
+/**
+ * Persist the compact columns; a storage failure (quota, privacy mode) only
+ * loses the preference.
+ * @param storage - browser storage (absent outside a browser).
+ * @param columns - the compact columns.
+ */
+export declare function writeCompactColumns(storage: Pick<Storage, 'setItem'> | undefined, columns: readonly TaskStatus[]): void;

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

@@ -0,0 +1,32 @@
+/**
+ * The board's own vector glyphs.
+ *
+ * Every control glyph the board draws comes from here, so one action always
+ * has one metaphor and one stroke recipe: a 16-unit viewBox, `currentColor`,
+ * 1.3 stroke, round caps and joins — the same recipe the sidebar panel glyph
+ * (`native-panel.tsx`) uses, which is why the board's chrome and its sidebar
+ * row read as one product. Icon-only controls pass a localized `title` and an
+ * accessible name at the call site; the glyph itself is always decorative.
+ *
+ * @module @linxin666/dsh-client-ui-task-board/client/board/icons
+ */
+import type { ReactElement } from 'react';
+/** Props of one board glyph: the shared recipe plus an explicit pixel size. */
+export interface BoardIconProps {
+    /** Rendered square edge in CSS pixels. */
+    size?: number;
+}
+/** Leave the board: the back-to-chat chevron. */
+export declare function IconChevronLeft(props: BoardIconProps): ReactElement;
+/** Dismiss a transient surface. */
+export declare function IconClose(props: BoardIconProps): ReactElement;
+/** Add: create a task, a label row, or a subtask. */
+export declare function IconPlus(props: BoardIconProps): ReactElement;
+/** Open the execution's session transcript. */
+export declare function IconSession(props: BoardIconProps): ReactElement;
+/** Switch a column to single-line cards. */
+export declare function IconCompactRows(props: BoardIconProps): ReactElement;
+/** Switch a column back to full cards. */
+export declare function IconExpandRows(props: BoardIconProps): ReactElement;
+/** A scheduled run: the recurrence mark on a card. */
+export declare function IconClock(props: BoardIconProps): ReactElement;

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

@@ -0,0 +1,69 @@
+/**
+ * Shared behavior of the board's transient surfaces (the task detail overlay
+ * and every modal that opens above it).
+ *
+ * Two concerns live here because they are one contract:
+ *
+ * - `usePresence` keeps a surface mounted through its exit leg. The board's
+ *   overlays are mounted by a boolean at the call site; the moment that
+ *   boolean flips the node would vanish, so the enter animation had no
+ *   reverse. Presence turns the boolean into `open` -> `closing` -> gone and
+ *   paints the phase on the surface, which is what the CSS transition pair
+ *   reads. Dimensions never change across the pair, so nothing around the
+ *   overlay reflows.
+ * - `useDialog` owns the keyboard and focus contract of a modal surface:
+ *   focus moves into the dialog when it opens and returns to the control that
+ *   opened it when it closes, Tab cycles inside it, and Escape asks the owner
+ *   to close.
+ *
+ * @module @linxin666/dsh-client-ui-task-board/client/board/overlay
+ */
+import { type MouseEvent } from 'react';
+/**
+ * Exit duration in milliseconds. It matches `--dsh-tb-motion-close` in
+ * `board.module.css`; under `prefers-reduced-motion` the stylesheet keeps the
+ * same duration and drops only the spatial travel, so the unmount delay stays
+ * valid for both motion settings.
+ */
+export declare const OVERLAY_EXIT_MS = 140;
+/** Lifecycle phase of one transient surface. */
+export type OverlayPhase = 'open' | 'closing';
+/** Presence of one transient surface. */
+export interface OverlayPresence {
+    /** Whether the surface should render at all (true through the exit leg). */
+    mounted: boolean;
+    /** Which leg of the motion pair the surface is on. */
+    phase: OverlayPhase;
+}
+/**
+ * Keep a surface mounted until its exit transition has run.
+ *
+ * `open=false` starts the exit leg immediately (the surface paints
+ * `data-state="closing"`) and unmounts it one exit duration later. Re-opening
+ * during the exit leg cancels the unmount, so a fast toggle never leaves a
+ * half-faded surface behind.
+ * @param open - the owner's mount request.
+ * @param exitMs - exit duration; defaults to {@link OVERLAY_EXIT_MS}.
+ * @returns the mount decision and the phase to paint.
+ */
+export declare function usePresence(open: boolean, exitMs?: number): OverlayPresence;
+/** The dialog's keyboard/focus handle. */
+export interface DialogHandle<T extends HTMLElement> {
+    /** Callback ref for the dialog element itself (it must accept focus). */
+    attach: (node: T | null) => void;
+    /** Backdrop press handler: closes only on a press of the backdrop itself. */
+    onMouseDown: (event: MouseEvent<HTMLElement>) => void;
+}
+/**
+ * Bind a modal surface's keyboard and focus contract.
+ *
+ * Focus enters the dialog on mount (its first focusable control, or the dialog
+ * itself) and returns to the control that opened it on unmount. Tab wraps
+ * inside the dialog, and Escape asks the owner to close — but only while the
+ * surface is on its enter leg, so a repeat press during the exit cannot queue
+ * a second close.
+ * @param onClose - the owner's close request.
+ * @param phase - the surface's current motion phase.
+ * @returns the ref to attach and the backdrop press handler.
+ */
+export declare function useDialog<T extends HTMLElement>(onClose: () => void, phase: OverlayPhase): DialogHandle<T>;

package/lib/types/client/board/status-key.d.ts

@@ -1,4 +1,19 @@
 import type { TaskStatus } from '../../core/tasks.ts';
+import { type ExecutionVerification, type VerificationPhase } from '../../core/verification.ts';
 import type { TaskBoardKey } from '../locales.ts';
 /** Task status → locale key (board column titles and the detail badge). */
 export declare const STATUS_KEY: Record<TaskStatus, TaskBoardKey>;
+/**
+ * Acceptance phase to the label the running column shows: executing,
+ * verifying, or fixing a failed acceptance. The card keeps one running label;
+ * this decides which one.
+ */
+export declare const VERIFICATION_PHASE_KEY: Record<VerificationPhase, TaskBoardKey>;
+/**
+ * The acceptance label for one open execution, or undefined when acceptance
+ * does not govern it (the switch was off at start, the run never became a goal
+ * run, or a teammate is covered by its Lead).
+ * @param verification - the execution's acceptance state.
+ * @returns the locale key to render, or undefined for the historical label.
+ */
+export declare function verificationRunningKey(verification: ExecutionVerification | undefined): TaskBoardKey | undefined;

package/lib/types/client/board/task-markdown.d.ts

@@ -0,0 +1,19 @@
+/** Readable summary without changing the task source or creating DOM HTML. */
+export declare function markdownToPlainText(source: string): string;
+/**
+ * Card excerpt: the plain text a reader can tell cards apart by.
+ *
+ * Issue-form bodies open with identical boilerplate (a duplicate-search
+ * checkbox, a plugin field, an issue-type field), so the plain-text prefix of
+ * every synced card read the same. The excerpt drops section headings, lists
+ * made only of checkboxes, raw HTML, rules and empty-field placeholders; when a
+ * summary-like section exists its body wins. A description that loses
+ * everything to those rules falls back to its full plain text, so no card goes
+ * blank. The stored description is never changed.
+ * @param source - the task description (Markdown).
+ */
+export declare function markdownExcerpt(source: string): string;
+/** Markdown rendered as React nodes: raw HTML and automatic image loads are disabled. */
+export declare function TaskMarkdown({ source }: {
+    source: string;
+}): import("react").JSX.Element;

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

@@ -12,6 +12,7 @@ import type { Context as ClientContext } from '@deepseek-ai/cordis';
 import type { ConfigForm, ConfigForms } from '@deepseek-ai/dsh-client-ui-settings/client';
 import { type TaskBoardSettings } from './TaskBoardSettingsCard.tsx';
 import { type TaskBoardKey } from './locales.ts';
+import { type TaskBoardCardDecorationProps, type TaskBoardDetailSectionProps, type TaskBoardSettingsSectionProps } from '../core/extension.ts';
 /** Domain-owned description of one settings namespace a family card binds. */
 export interface SettingsFormSpec<T> {
     /** Settings namespace the card edits. */
@@ -50,6 +51,24 @@ declare module '@deepseek-ai/dsh-client-ui-slots' {
             scope: 'root';
             owner: SettingsPluginItemOwnerProps;
         };
+        /** Provider task-detail section; the board declares and renders it. */
+        'task-board.detail.section': {
+            kind: 'list';
+            scope: 'root';
+            owner: TaskBoardDetailSectionProps;
+        };
+        /** Provider settings section; the board declares and renders it. */
+        'task-board.settings.section': {
+            kind: 'list';
+            scope: 'root';
+            owner: TaskBoardSettingsSectionProps;
+        };
+        /** Provider card decoration; the board declares and renders it. */
+        'task-board.card.decoration': {
+            kind: 'list';
+            scope: 'root';
+            owner: TaskBoardCardDecorationProps;
+        };
     }
 }
 /** Owner share of a plugin card (the section supplies nothing). */
@@ -69,11 +88,10 @@ declare module '@deepseek-ai/cordis' {
 }
 /**
  * Required services (fiber inject waiting — the runtime must be up first).
- * The generated remote faces are probed at use time instead of injected:
- * `remote.agentPresets` only registers on 0.1.2-alpha.2 hosts (the
- * api-remotes contribution), so a hard wait would pend the entry forever
- * on hosts below that cohort, which serve the same roster through the
- * connection RPC face.
+ * The generated remote namespaces are not all hard injects: `remote.session`
+ * is one, while `remote.agentPresets` is reached through a scoped inject at
+ * use time (see mountUi), because the namespace mounts with the official
+ * api-remotes assembly applied beside this entry rather than before it.
  */
 export declare const inject: string[];
 /**