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

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

@@ -25,7 +25,6 @@ export declare const zh: {
     'board.status.failed': string;
     'board.runs': string;
     'board.pending': string;
-    'board.updated': string;
     'board.created': string;
     'board.hostError': string;
     'board.hostError.notMounted': string;
@@ -106,6 +105,22 @@ export declare const zh: {
     'board.tagFilter': string;
     'board.tagFilterClear': string;
     'board.tagEmpty': string;
+    'board.tagManage': string;
+    'tags.title': string;
+    'tags.hint': string;
+    'tags.empty': string;
+    'tags.usage': string;
+    'tags.rename': string;
+    'tags.renameLabel': string;
+    'tags.delete': string;
+    'tags.deleteTitle': string;
+    'tags.deleteConfirm': string;
+    'tags.deleteOk': string;
+    'tags.save': string;
+    'tags.mergeHint': string;
+    'tags.renameFailed': string;
+    'tags.deleteFailed': string;
+    'tags.done': string;
     'detail.permissionPending': string;
     'detail.permissionConfirm': string;
     'detail.permissionConfirmed': string;
@@ -121,6 +136,8 @@ export declare const zh: {
     'new.archiveOriginal': string;
     'detail.prompt': string;
     'detail.description': string;
+    'detail.expand': string;
+    'detail.collapse': string;
     'detail.execution': string;
     'detail.noExecution': string;
     'detail.run': string;
@@ -144,6 +161,9 @@ export declare const zh: {
     'delete.cancel': string;
     'status.move.backlog': string;
     'status.move.todo': string;
+    'status.move.running': string;
+    'status.move.done': string;
+    'status.move.failed': string;
     'exec.error.noWorkspace': string;
     'exec.error.promptRejected': string;
     'run.failed': string;
@@ -203,11 +223,14 @@ export declare const zh: {
     'exec.reuseSessionHint': string;
     'exec.goalRun': string;
     'exec.goalRunHint': string;
+    'exec.skipVerification': string;
+    'exec.skipVerificationHint': string;
     'detail.executionSettings': string;
     'exec.hint': string;
     'settings.title': string;
     'settings.description': string;
     'settings.enabled': string;
+    'settings.enabledCardHint': string;
     'settings.enabledHint': string;
     'settings.announceToAgent': string;
     'settings.announceToAgentHint': string;
@@ -235,6 +258,65 @@ export declare const zh: {
     'settings.maxSubtaskDepth': string;
     'settings.maxSubtaskDepthHint': string;
     'settings.maxSubtaskDepthOption': string;
+    'settings.goalVerificationTitle': string;
+    'settings.goalVerification': string;
+    'settings.goalVerificationCardHint': string;
+    'settings.goalVerificationHint': string;
+    'settings.goalVerificationModel': string;
+    'settings.goalVerificationModelHint': string;
+    'settings.goalVerificationModelInherit': string;
+    'settings.goalVerificationModelInheritUnknown': string;
+    'settings.goalVerificationEffort': string;
+    'settings.goalVerificationEffortHint': string;
+    'settings.goalVerificationEffortInherit': string;
+    'settings.goalVerificationEffortInheritUnknown': string;
+    'settings.goalVerificationResolved': string;
+    'settings.goalVerificationResolvedModel': string;
+    'settings.goalVerificationResolvedEffort': string;
+    'settings.goalVerificationResolvedNoEffort': string;
+    'settings.goalVerificationResolvedSource': string;
+    'settings.goalVerificationSourceInherit': string;
+    'settings.goalVerificationSourceExplicit': string;
+    'settings.goalVerificationResolvedPreset': string;
+    'settings.goalVerificationRouteMissing': string;
+    'settings.goalVerificationEffortFallback': string;
+    'settings.goalVerificationEffortFallbackNone': string;
+    'settings.goalVerificationModelInvalid': string;
+    'running.executing': string;
+    'running.verifying': string;
+    'running.repairing': string;
+    'running.verificationPassed': string;
+    'running.verificationFailed': string;
+    'verify.title': string;
+    'verify.status.passed': string;
+    'verify.status.failed': string;
+    'verify.status.exception': string;
+    'verify.status.verifying': string;
+    'verify.status.pending': string;
+    'verify.status.off': string;
+    'verify.summary': string;
+    'verify.criteria': string;
+    'verify.criterion': string;
+    'verify.rounds': string;
+    'verify.judge': string;
+    'verify.judgeNoEffort': string;
+    'verify.judgeInherited': string;
+    'verify.attempt': string;
+    'verify.attemptException': string;
+    'verify.counts': string;
+    'verify.findings': string;
+    'verify.noFindings': string;
+    'verify.evidence': string;
+    'verify.workspaceEvidence': string;
+    'verify.usage': string;
+    'verify.usageIncomplete': string;
+    'verify.finalFailure': string;
+    'verify.applicability.disabled': string;
+    'verify.applicability.goalUnavailable': string;
+    'verify.applicability.skipped': string;
+    'verify.applicability.teamMember': string;
+    'verify.effortFallback': string;
+    'verify.thresholdValue': string;
     'detail.parent': string;
     'detail.parent.open': string;
     'detail.subtasks': string;
@@ -258,6 +340,25 @@ export declare const zh: {
     'card.subtasksFailed': string;
     'card.subtasksRunning': string;
     'card.subtasksBreakdown': string;
+    'card.result.succeeded': string;
+    'card.result.failed': string;
+    'card.result.cancelled': string;
+    'card.declared': string;
+    'card.declaredHint': string;
+    'card.openSession': string;
+    'card.tagsLabel': string;
+    'card.time.created': string;
+    'card.time.started': string;
+    'card.time.settled': string;
+    'card.time.archived': string;
+    'card.time.updated': string;
+    'board.density.compact': string;
+    'board.density.comfortable': string;
+    'board.group.today': string;
+    'board.group.week': string;
+    'board.group.earlier': string;
+    'board.group.expand': string;
+    'board.group.collapse': string;
     'board.hideSubtasks': string;
     'board.showSubtasks': string;
     'board.subtaskFilterHint': string;
@@ -265,6 +366,7 @@ export declare const zh: {
 /** en dictionary, complete against the zh key set. */
 export declare const en: Record<keyof typeof zh, string>;
 /** The dictionary key union. */
+/** The dictionary key union. */
 export type TaskBoardKey = keyof typeof zh;
 /** The settings-card slice of the task-board dictionary. */
 export type SettingsCardKey = TaskBoardKey;

package/lib/types/client/native-panel.d.ts

@@ -1,23 +1,7 @@
-/**
- * Native panel registration for the task board.
- *
- * The board is an official-style center-column panel, not a DOM takeover: it
- * contributes a row into the sidebar shell's own global panel list
- * (`sidebar.panellist`) and its page into the layout's keyed `main` slot. The
- * shell then owns the row box, the label, the active highlight, the collapsed
- * rail, the panel switch and the window-chrome interplay exactly as it does for
- * the shipped Plugins and Schedule pages, so the board renders through the same
- * container the desktop application's Plugins page uses.
- *
- * Both registrations go through `ctx.slots.inject`, which fires only once the
- * owning shell entry has declared the seat: load order between this plugin and
- * ui-layout / ui-sidebar therefore does not matter, and neither does a shell
- * that cannot serve the seats (the callback simply never runs).
- *
- * @module @linxin666/dsh-client-ui-task-board/client
- */
+import type { ReactNode } from 'react';
 import type { Context as ClientContext } from '@deepseek-ai/cordis';
 import { TASK_BOARD_PANEL_ID, type BoardController } from '../core/controller.ts';
+import { type SlotRenderBinding } from './seats.tsx';
 /** The panel id shared by the sidebar row and the main-slot occupant. */
 export { TASK_BOARD_PANEL_ID };
 /**
@@ -45,9 +29,11 @@ export declare function TaskBoardPanelIcon({ size }: {
  * @param props - the framework main-slot share plus this entry's injected face.
  * @returns the board page.
  */
-export declare function TaskBoardPanel({ controller }: {
+export declare function TaskBoardPanel({ controller, renderSlot }: {
     controller: BoardController;
-}): React.ReactElement;
+    /** Child-slot renderer the registration declares (detail + card decoration). */
+    renderSlot?: SlotRenderBinding;
+}): ReactNode;
 /**
  * Register the board's sidebar row and center-column page.
  *

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

@@ -0,0 +1,18 @@
+import type { ReactNode } from 'react';
+import { type TaskBoardCardDecorationProps, type TaskBoardDetailSectionProps, type TaskBoardSettingsSectionProps } from '../core/extension.ts';
+/** The three provider seats, adapted to plain render functions. */
+export interface TaskBoardSeats {
+    detailSection: (props: TaskBoardDetailSectionProps) => ReactNode;
+    settingsSection: (props: TaskBoardSettingsSectionProps) => ReactNode;
+    cardDecoration: (props: TaskBoardCardDecorationProps) => ReactNode;
+}
+/** Nothing registered: every seat renders empty. */
+export declare const EMPTY_TASK_BOARD_SEATS: TaskBoardSeats;
+/** The framework `renderSlot` binding shape (key + owner props share). */
+export type SlotRenderBinding = (key: string, owner: Record<string, unknown>) => ReactNode;
+/** Adapt one framework renderSlot binding to the board's seat interface. */
+export declare function seatsFromRenderSlot(renderSlot: SlotRenderBinding | undefined): TaskBoardSeats;
+/** Provider the board's registered components wrap their subtree in. */
+export declare const TaskBoardSeatsProvider: import("react").Provider<TaskBoardSeats>;
+/** Read the current seat set (empty when no board registration is above). */
+export declare function useTaskBoardSeats(): TaskBoardSeats;

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

@@ -0,0 +1,32 @@
+/**
+ * The board's browser-half extension service (`taskBoard`).
+ *
+ * It gives a provider's browser half the client capability face from the
+ * contract: dispatch over the board's same-origin action channel, card
+ * visibility predicates, and a subscription to the board mirror. The board
+ * controller is attached and detached as the master switch mounts and unmounts
+ * the UI, so the service can be provided before any controller exists.
+ *
+ * @module dsh-task-board/client/service
+ */
+import type { BoardController } from '../core/controller.ts';
+import type { TaskBoardClientFace, TaskBoardClientMirror, TaskBoardExtensionActionRequest, TaskBoardVisibilityPredicate } from '../core/extension.ts';
+export declare class TaskBoardClientService implements TaskBoardClientFace {
+    private controller;
+    private enabled;
+    private unsubscribeController;
+    /** Predicates registered before the controller exists, replayed on attach. */
+    private readonly pendingVisibility;
+    private readonly listeners;
+    /** Bind the live board controller (called when the UI mounts). */
+    attach(controller: BoardController): void;
+    /** Release the current controller (called when the UI unmounts). */
+    detach(): void;
+    /** Apply the board's master switch. */
+    setEnabled(enabled: boolean): void;
+    dispatch(request: TaskBoardExtensionActionRequest): Promise<boolean>;
+    registerVisibility(predicate: TaskBoardVisibilityPredicate): () => void;
+    subscribe(callback: (mirror: TaskBoardClientMirror) => void): () => void;
+    snapshot(): TaskBoardClientMirror;
+    private notify;
+}

package/lib/types/client/settings-form.d.ts

@@ -134,6 +134,8 @@ export declare class CardForm<T> {
     private readonly disposeForm;
     private disposed;
     private saving;
+    /** A save asked for while one was in flight; it runs once the first settles (#1754). */
+    private saveQueued;
     private failed;
     private failedReason;
     /** @param scope - the bound configuration form for this card's namespace. */
@@ -167,6 +169,20 @@ export declare class CardForm<T> {
      * the user can correct them instead of retyping.
      * @returns settlement after the mutation and the read-back.
      */
+    /**
+     * Run one save, and re-run it once if another was asked for while this one
+     * was still in flight.
+     *
+     * A save is a Host round trip that also drives the profile reconcile, and
+     * the Host runs that write inside one exclusive transaction. Answering a
+     * press that arrives mid-flight by returning immediately dropped the edit
+     * with no explanation, which is the "the save button stops working after a
+     * few rounds" report (#1754). Serializing instead means a save pressed while
+     * another is still settling runs against the settled state - which is what
+     * the operator meant by pressing it again.
+     * @returns settlement after the mutation and the read-back.
+     */
+    requestSave(): Promise<void>;
     save(): Promise<void>;
     /**
      * Every staged edit a save would write. An entry whose draft is not a value

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

@@ -15,6 +15,7 @@ import type { TaskStore } from './store.ts';
 import { type NewTaskInput, type TaskRecord, type TaskStatus } from './tasks.ts';
 import { type TaskUpdatePatch } from './use-cases/task-update.ts';
 import type { TaskBoardAction, TaskBoardEventPayload, TaskBoardParseDraft, TaskBoardParseRequest, TaskBoardSnapshot } from '../protocol.ts';
+import type { TaskBoardExtensionActionRequest, TaskBoardVisibilityPredicate } from './extension.ts';
 export interface TaskBoardTransport {
     bootstrap(legacy: readonly TaskRecord[]): Promise<TaskBoardSnapshot>;
     state(): Promise<TaskBoardSnapshot>;
@@ -110,7 +111,7 @@ export interface ExecutionOptionsSnapshot {
  * (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'>;
+export type HostMirror = Pick<TaskBoardSnapshot, 'revision' | 'scheduler' | 'power' | 'sessionDefaultPermission' | 'maxSubtaskDepth' | 'teamRunAvailable' | 'extensions'>;
 /** Immutable controller snapshot for UI subscriptions. */
 export interface ControllerSnapshot {
     tasks: readonly TaskRecord[];
@@ -127,6 +128,15 @@ export interface ControllerSnapshot {
     canParseTask?: boolean;
     transportError?: string;
     host?: HostMirror;
+    /**
+     * Provider card-visibility predicates, in registration order. A task shows
+     * only while every predicate accepts it; providers hide their own off-board
+     * cards here instead of the board hard-coding a provider rule. Optional so a
+     * hand-built snapshot (tests, a shell-less composition) defaults to visible.
+     */
+    visibility?: readonly TaskBoardVisibilityPredicate[];
+    /** Read-only summaries published by running extensions, keyed by extension id. */
+    extensions?: Readonly<Record<string, unknown>>;
 }
 /** The selected task (resolved from the ledger), or undefined. */
 export declare function selectedTaskOf(snapshot: ControllerSnapshot): TaskRecord | undefined;
@@ -150,6 +160,8 @@ export declare class BoardController {
     private readonly taskQueues;
     private transportError;
     private hostState;
+    /** Provider visibility predicates (immutable array; replaced on change). */
+    private visibility;
     private remoteSubscribed;
     private remoteInitialization;
     /** @param deps - store and the sessions navigation face. */
@@ -159,6 +171,16 @@ export declare class BoardController {
     /** Stop all subscriptions and drop retained state (idempotent). */
     dispose(): void;
     getSnapshot(): ControllerSnapshot;
+    /**
+     * Register one card-visibility predicate. The returned disposer removes it;
+     * both changes notify subscribers so the board re-renders.
+     */
+    registerVisibility(predicate: TaskBoardVisibilityPredicate): () => void;
+    /**
+     * Deliver one provider action through the board's same-origin channel. A
+     * board without a Host transport (the legacy in-memory path) refuses it.
+     */
+    dispatchExtension(request: TaskBoardExtensionActionRequest): Promise<boolean>;
     subscribe(fn: () => void): () => void;
     /** Whether production mutations are confirmed by the Host transport. */
     isHostBacked(): boolean;
@@ -250,6 +272,20 @@ export declare class BoardController {
     setParent(id: string, parentId: string | null): Promise<boolean>;
     /** Restore an archived task back onto the board (same status column). */
     restoreTask(id: string): boolean;
+    /**
+     * Rename one label across the whole ledger; a name already in use merges the
+     * two labels. Host-backed: the ledger owns the transition and confirms it, so
+     * the board's label row reflects whether the Host accepted the edit.
+     * @returns true when the edit was accepted by the authority.
+     */
+    renameTag(from: string, to: string): Promise<boolean>;
+    /**
+     * Remove one label from every task that carries it, board and archive alike —
+     * the board's label row is drawn from the whole ledger, so a label left on an
+     * archived card would come straight back.
+     * @returns true when the edit was accepted by the authority.
+     */
+    deleteTag(name: string): Promise<boolean>;
     /**
      * Update a task's schedule rule. A blank or invalid cron expression is
      * rejected (returns false, state untouched). When the rule ends up enabled

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

@@ -0,0 +1,283 @@
+/**
+ * The task board's external provider extension contract.
+ *
+ * This module is the single source of truth for how another plugin adds a
+ * provider surface to the task board: the cordis service name both halves
+ * publish, the API version they negotiate, the child seats a provider renders
+ * into, the host capability face a provider implements against, and the client
+ * capability face the board's browser half provides. It is framework-free and
+ * shared by the host and browser programs; the only imported SDK type is
+ * type-only, so the browser bundle never pulls a value out of an SDK package.
+ *
+ * @module dsh-task-board/core/extension
+ */
+import type { ToolDefinition } from '@deepseek-ai/dsh-tools';
+import type { ExecutionOutcome, TaskRecord, TaskStatus } from './tasks.ts';
+/** Cordis service name the host and browser halves each publish. */
+export declare const TASK_BOARD_SERVICE_NAME = "taskBoard";
+/**
+ * Contract version of {@link TASK_BOARD_SERVICE_NAME}. A provider declares the
+ * version it was built against; the board refuses (visibly) any other version
+ * instead of guessing at a stale shape.
+ */
+export declare const TASK_BOARD_API_VERSION = 1;
+/** Child seat a provider registers its task-detail section into. */
+export declare const TASK_BOARD_DETAIL_SECTION = "task-board.detail.section";
+/** Child seat a provider registers its settings section into. */
+export declare const TASK_BOARD_SETTINGS_SECTION = "task-board.settings.section";
+/** Child seat a provider registers its card decoration into. */
+export declare const TASK_BOARD_CARD_DECORATION = "task-board.card.decoration";
+/** Every child seat the board declares for extensions, in render order. */
+export declare const TASK_BOARD_EXTENSION_SEATS: readonly string[];
+/**
+ * Largest accepted extension payload, in bytes of its JSON serialization. One
+ * integration entry — and one action payload — may carry schema the board does
+ * not interpret, but never enough of it to bloat the ledger or the action
+ * channel.
+ */
+export declare const TASK_BOARD_PAYLOAD_LIMIT_BYTES: number;
+/** One opaque provider payload the board stores and forwards without interpreting. */
+export type TaskBoardExtensionPayload = Record<string, unknown>;
+/**
+ * Validate one extension payload: a pure JSON object whose serialization fits
+ * {@link TASK_BOARD_PAYLOAD_LIMIT_BYTES}. Arrays, primitives and non-plain
+ * objects are refused; the board never interprets the keys.
+ * @param value - candidate payload.
+ * @returns whether the value is an acceptable opaque payload.
+ */
+export declare function isTaskBoardExtensionPayload(value: unknown): value is TaskBoardExtensionPayload;
+/** Byte length of a value's JSON serialization, or undefined when it does not serialize. */
+export declare function taskBoardPayloadBytes(value: unknown): number | undefined;
+/**
+ * Normalize a task's whole integrations container: a plain JSON object whose
+ * values are each an opaque provider payload within the size limit. A malformed
+ * container normalizes to undefined (the field is dropped), and one malformed
+ * entry is dropped alone so a single bad provider can never take a card — or
+ * another provider's data — with it.
+ * @param value - candidate container from the wire, the ledger, or a create input.
+ * @returns the cleaned container, or undefined when nothing usable remains.
+ */
+export declare function normalizeTaskIntegrations(value: unknown): Record<string, TaskBoardExtensionPayload> | undefined;
+/** One action a provider dispatches over the board's same-origin channel. */
+export interface TaskBoardExtensionActionRequest {
+    /** Id of the extension the action belongs to. */
+    extensionId: string;
+    /** Provider-owned action name, routed back to that extension's handleAction. */
+    action: string;
+    /** Task the action targets, when it targets one. */
+    taskId?: string;
+    /** Opaque provider payload, bounded like every other extension payload. */
+    payload?: TaskBoardExtensionPayload;
+}
+/**
+ * Deliver one extension action through the board's same-origin action channel.
+ * The extension never opens an HTTP surface of its own.
+ */
+export type TaskBoardExtensionDispatch = (request: TaskBoardExtensionActionRequest) => Promise<boolean>;
+/** Draft one provider creates a task from. */
+export interface TaskBoardTaskDraft {
+    title: string;
+    description: string;
+    prompt: string;
+    /** Column the created card opens in; absent means the board default (todo). */
+    status?: TaskStatus;
+    /** Parent card id, when the provider materializes a subtask. */
+    parentId?: string;
+    /**
+     * Workspace the execution must run in. Absent leaves the board's own
+     * inheritance rules in charge (the creating session's workspace for a root
+     * card, else the recent workspace at execution time), so a provider that has
+     * no reason to know better pins nothing.
+     */
+    workspaceId?: string;
+}
+/** Options of {@link TaskBoardTasksFace.create}. */
+export interface TaskBoardCreateOptions {
+    /** Opaque payload stored under the creating extension's id. */
+    payload?: TaskBoardExtensionPayload;
+    /** Create the card off-board: it exists in the ledger but is never shown on the board. */
+    hidden?: boolean;
+}
+/** One task linked to an extension, with that extension's own payload. */
+export interface TaskBoardLinkedTask {
+    task: TaskRecord;
+    payload: TaskBoardExtensionPayload;
+}
+/** Task reads and writes the board grants an extension. */
+export interface TaskBoardTasksFace {
+    /** Every task in the ledger, most recent mutation last. */
+    list(): readonly TaskRecord[];
+    /** One task by id, or undefined. */
+    get(taskId: string): TaskRecord | undefined;
+    /**
+     * Create a task through the board's own creation gate; the payload lands
+     * under the creating extension's id. Throws on a refused draft.
+     */
+    create(draft: TaskBoardTaskDraft, options?: TaskBoardCreateOptions): TaskRecord;
+    /**
+     * Patch a task's content. Reuses the board's own content gate: a task that
+     * has started executing keeps its recorded title/description/prompt.
+     * Throws when the card is frozen.
+     */
+    patchContent(taskId: string, patch: {
+        title?: string;
+        description?: string;
+        prompt?: string;
+    }): void;
+    /**
+     * Move a task through the board's existing status gates (running lock,
+     * permission confirmation gate). Throws on refusal.
+     */
+    setStatus(taskId: string, status: TaskStatus, initiator?: string): void;
+    /** Every task carrying this extension's payload. */
+    linked(): readonly TaskBoardLinkedTask[];
+}
+/** Storage face for one extension's own payload on a task. */
+export interface TaskBoardIntegrationFace {
+    /** Read this extension's payload, or undefined when the task carries none. */
+    read(taskId: string): TaskBoardExtensionPayload | undefined;
+    /**
+     * Shallow-merge this extension's payload into the task: the given keys
+     * replace the stored ones, and a key explicitly set to undefined clears it.
+     * The board stores the result opaquely; a non-JSON or oversized payload is
+     * refused.
+     */
+    write(taskId: string, payload: TaskBoardExtensionPayload): void;
+}
+/** Status-change notification. */
+export interface TaskBoardStatusChangedEvent {
+    taskId: string;
+    status: TaskStatus;
+    previous: TaskStatus;
+    initiator?: string;
+}
+/** Execution-settlement notification. */
+export interface TaskBoardExecutionSettledEvent {
+    taskId: string;
+    executionId: string;
+    outcome: ExecutionOutcome;
+    error?: string;
+}
+/** Task-deletion notification. */
+export interface TaskBoardTaskDeletedEvent {
+    taskId: string;
+}
+/**
+ * Event subscriptions an extension registers for. Every callback runs isolated:
+ * a throw is logged and never interrupts the board's own execution path.
+ */
+export interface TaskBoardEventFace {
+    onStatusChanged(callback: (event: TaskBoardStatusChangedEvent) => void): () => void;
+    onExecutionSettled(callback: (event: TaskBoardExecutionSettledEvent) => void): () => void;
+    onTaskDeleted(callback: (event: TaskBoardTaskDeletedEvent) => void): () => void;
+}
+/**
+ * Host capability face handed to one extension while it is started. The face
+ * lives for the extension's enabled lifetime; the board revokes it by calling
+ * the extension's stop().
+ */
+export interface TaskBoardExtensionHost {
+    tasks: TaskBoardTasksFace;
+    integration: TaskBoardIntegrationFace;
+    events: TaskBoardEventFace;
+    /**
+     * Publish this extension's read-only summary; it lands in the snapshot's
+     * extensions[id] for the extension's browser half to render.
+     */
+    publish(summary: TaskBoardExtensionPayload): void;
+    /** Register one model-visible tool; the returned disposer unregisters it. */
+    registerTool(definition: ToolDefinition): () => void;
+}
+/** One external provider contributed to the task board. */
+export interface TaskBoardExtension {
+    /** Stable extension id; also the key of this extension's integration payload. */
+    readonly id: string;
+    /** Contract version this extension was built against. */
+    readonly apiVersion: number;
+    /** Volatile per-extension switch; absent means enabled. Read at use time. */
+    enabled?(): boolean;
+    /** Acquire the capability face and start any provider-side work. */
+    start?(host: TaskBoardExtensionHost): void;
+    /** Release provider-side work. Never clears stored data. */
+    stop?(): void;
+    /** Route one dispatched action; the returned value goes back to the dispatcher. */
+    handleAction?(request: TaskBoardExtensionActionRequest): unknown | Promise<unknown>;
+}
+/** Board mirror an extension's browser half observes. */
+export interface TaskBoardClientMirror {
+    /** Whether the board's master switch currently runs the extension faces. */
+    enabled: boolean;
+    /** Tasks the board currently holds. */
+    tasks: readonly TaskRecord[];
+    /** Published extension summaries, keyed by extension id (opaque to the board). */
+    extensions: Readonly<Record<string, unknown>>;
+}
+/** Whether a task should be shown on the board; false hides it. */
+export type TaskBoardVisibilityPredicate = (task: TaskRecord) => boolean;
+/**
+ * Client capability face the board's browser half provides. A provider's
+ * browser half resolves it from the shared cordis service name; it never
+ * value-imports the board package.
+ */
+export interface TaskBoardClientFace {
+    /** Deliver one action through the board's same-origin action channel. */
+    dispatch(request: TaskBoardExtensionActionRequest): Promise<boolean>;
+    /** Register one card visibility predicate; the returned disposer removes it. */
+    registerVisibility(predicate: TaskBoardVisibilityPredicate): () => void;
+    /** Subscribe to the board mirror. */
+    subscribe(callback: (mirror: TaskBoardClientMirror) => void): () => void;
+    /** Read the current board mirror. */
+    snapshot(): TaskBoardClientMirror;
+}
+/** Owner props of the task-detail seat. */
+export interface TaskBoardDetailSectionProps {
+    task: TaskRecord;
+    dispatch: TaskBoardExtensionDispatch;
+}
+/** Owner props of the settings seat. */
+export interface TaskBoardSettingsSectionProps {
+    dispatch: TaskBoardExtensionDispatch;
+}
+/** Owner props of the card-decoration seat. */
+export interface TaskBoardCardDecorationProps {
+    task: TaskRecord;
+}
+/**
+ * Host-half service face published under {@link TASK_BOARD_SERVICE_NAME}. A
+ * provider package's host half resolves this from the shared cordis service
+ * and registers its extension; the board's ledger never crosses this boundary.
+ */
+export interface TaskBoardHostFace {
+    /**
+     * Admit one provider extension. Idempotent by extension id; the returned
+     * disposer releases it without clearing stored data.
+     */
+    registerExtension(extension: TaskBoardExtension): () => void;
+    /** Whether the board currently runs a given extension (board x extension). */
+    isExtensionEnabled(extensionId: string): boolean;
+}
+declare module '@deepseek-ai/cordis' {
+    interface Context {
+        /**
+         * The board's extension service. The host half publishes
+         * {@link TaskBoardHostFace}; the browser half publishes
+         * {@link TaskBoardClientFace} under the same name. The two halves never run
+         * in one process, so the browser half resolves its face through
+         * {@link resolveTaskBoardClientFace} and this shared declaration names the
+         * host face that registration-side consumers type against.
+         */
+        taskBoard: TaskBoardHostFace;
+    }
+}
+/** The narrow context seat {@link resolveTaskBoardClientFace} needs. */
+export interface TaskBoardClientContextSeat {
+    get(name: string): unknown;
+}
+/**
+ * Resolve the browser half's client capability face by service name. Returns
+ * undefined when the board is not loaded or the service is not served, so a
+ * provider's browser half can degrade instead of throwing.
+ * @param ctx - client context.
+ * @returns the client face, or undefined.
+ */
+export declare function resolveTaskBoardClientFace(ctx: TaskBoardClientContextSeat): TaskBoardClientFace | undefined;