@linxin666/dsh-client-ui-task-board 0.1.1

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

@@ -0,0 +1,129 @@
+/**
+ * Board controller: the single owner of task-ledger state and view state.
+ *
+ * It keeps the ledger in memory, persists every mutation through the
+ * {@link TaskStore}, drives real executions through the
+ * {@link ExecutionService}, and closes the board view whenever the user
+ * navigates to a session (the sessions-list `current` selection changes).
+ * Framework-free (structural runtime faces) so the whole orchestration is
+ * unit-testable with fakes.
+ */
+import { ExecutionService } from './execution.ts';
+import type { TaskStore } from './store.ts';
+import { type NewTaskInput, type TaskRecord, type TaskStatus } from './tasks.ts';
+/** The sessions face the controller needs for navigation awareness. */
+export interface SessionsControllerFace {
+    list: {
+        getSnapshot(): {
+            current: string | undefined;
+        };
+        subscribe(fn: () => void): () => void;
+    };
+    /** Select a session as current (navigates the conversation view). */
+    open(id: string): void;
+}
+/** Controller dependencies (all swappable in tests). */
+export interface ControllerDeps {
+    store: TaskStore;
+    exec: ExecutionService;
+    sessions: SessionsControllerFace;
+    /** Clock; defaults to Date.now. */
+    now?: () => number;
+    /** Id minting; defaults to a random-uuid. */
+    uuid?: () => string;
+    /** Debounce (ms) for session-list-changed reconciles; defaults to 350. */
+    reconcileDebounceMs?: number;
+}
+/** Immutable controller snapshot for UI subscriptions. */
+export interface ControllerSnapshot {
+    tasks: readonly TaskRecord[];
+    boardOpen: boolean;
+    selectedTaskId: string | undefined;
+}
+/** The selected task (resolved from the ledger), or undefined. */
+export declare function selectedTaskOf(snapshot: ControllerSnapshot): TaskRecord | undefined;
+/**
+ * Board controller (see module doc). All mutations bump the snapshot and
+ * persist through the store; UI and DOM mounts subscribe and re-render.
+ */
+export declare class BoardController {
+    private readonly deps;
+    private tasks;
+    private boardOpen;
+    private selectedTaskId;
+    private listeners;
+    private disposers;
+    private readonly now;
+    private readonly uuid;
+    /** @param deps - store, execution service, and the sessions navigation face. */
+    constructor(deps: ControllerDeps);
+    /** Load the persisted ledger and start the navigation/status subscriptions. */
+    start(): void;
+    /** Stop all subscriptions and drop retained state (idempotent). */
+    dispose(): void;
+    getSnapshot(): ControllerSnapshot;
+    subscribe(fn: () => void): () => void;
+    openBoard(): void;
+    closeBoard(): void;
+    toggleBoard(): void;
+    openTask(id: string): void;
+    closeTask(): void;
+    createTask(input: NewTaskInput): TaskRecord | undefined;
+    updateTask(id: string, patch: Partial<Pick<TaskRecord, 'title' | 'description' | 'prompt'>>): void;
+    moveTask(id: string, status: TaskStatus): void;
+    deleteTask(id: string): void;
+    /**
+     * Update a task's schedule rule. A blank or invalid cron expression is
+     * rejected (returns false, state untouched). When the rule ends up enabled
+     * the next run instant is computed immediately; a disabled rule carries no
+     * next-run instant.
+     * @param id - the task to schedule.
+     * @param patch - fields to change (absent fields keep their current value).
+     * @returns true when applied, false when rejected (invalid cron / unknown task).
+     */
+    setSchedule(id: string, patch: {
+        enabled?: boolean;
+        cron?: string;
+    }): boolean;
+    /**
+     * Roll a task's schedule forward (scheduler callback): persist the next due
+     * instant and the trigger instant of this run. No-op when the task has no
+     * schedule rule (it was deleted mid-tick, for example).
+     */
+    applyScheduleNextRun(id: string, nextRunAt: number | undefined, lastTriggeredAt: number | undefined): void;
+    /**
+     * Jump to an execution's session transcript. Selecting the session changes
+     * `current`, which closes the board (the conversation view takes over).
+     * @param sessionId - the execution session to open.
+     */
+    openSession(sessionId: string): void;
+    /**
+     * Execute a task for real: move it to 'running', open an execution record,
+     * and hand off to the ExecutionService. A second call while the task is
+     * already running is ignored.
+     */
+    runTask(id: string): Promise<boolean>;
+    /** Re-run a settled task: move it back to 'todo' first, then execute. */
+    rerunTask(id: string): Promise<void>;
+    private handleExecutionEvent;
+    /** Reconcile running tasks and close the board when the user navigates. */
+    private onSessionsChanged;
+    private lastCurrent;
+    /** Execution ids launched on this page; they settle via their live watch, never list reconciliation. */
+    private readonly activeExecutionIds;
+    /** Debounce timer for {@link reconcileRunningTasks}. */
+    private reconcileTimer;
+    /** Whether a reconcile pass is underway (single-flight guard). */
+    private reconcileInFlight;
+    /**
+     * Debounce + single-flight trigger for the running-task reconciliation.
+     * Session-list notifications arrive in bursts (one per session status
+     * change); both guards together keep a burst from reading the history API
+     * once per running task.
+     */
+    private scheduleReconcile;
+    /** Settle tasks left 'running' whose sessions already finished. */
+    private reconcileRunningTasks;
+    private persistAndNotify;
+    private notify;
+}

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

@@ -0,0 +1,136 @@
+/**
+ * Execution service: runs a task through dsh's real session machinery.
+ *
+ * The board's "run" button must make dsh actually work, not fake a status:
+ * the service connects a real session (workspace blank-session reuse or
+ * `session.create` on the host via the workspaces service), renames it to
+ * the task title, sends the task prompt with `session.prompt`, and then
+ * watches the session's conversation snapshot until its turn settles. The
+ * task board controller consumes {@link ExecutionEvent}s to move the card
+ * running → done/failed and to keep the execution record.
+ *
+ * Deliberately framework-free: the runtime faces are declared structurally
+ * (a narrow slice of the real `ctx.sessions` / `ctx.workspaces` contracts)
+ * so tests drive it with plain fakes.
+ */
+import type { ExecutionRecord, TaskRecord } from './tasks.ts';
+/** The narrow sessions face the service needs. */
+export interface SessionsExecutionFace {
+    list: {
+        getSnapshot(): {
+            /** Baseline arrival lifecycle — 'pending' until the host list has loaded. */
+            phase: 'pending' | 'ready';
+            byId: Record<string, {
+                running: boolean;
+                completed?: boolean;
+            }>;
+        };
+        subscribe(fn: () => void): () => void;
+    };
+    binding(id: string): {
+        session: SessionDriver;
+    } | undefined;
+}
+/** The narrow workspaces face the service needs. */
+export interface WorkspacesExecutionFace {
+    list: {
+        getSnapshot(): {
+            items: readonly {
+                workspaceId: string;
+            }[];
+            recentWorkspaceId: string | undefined;
+        };
+    };
+    connectWorkspace(workspaceId: string): Promise<string>;
+}
+/** One raw session-history event narrowed to the failure signal reconcile needs. */
+export interface ExecutionHistoryEvent {
+    type: string;
+    data?: unknown;
+}
+/** Optional raw-history face used to detect failures of never-opened sessions. */
+export interface HistoryExecutionFace {
+    loadTail(sessionId: string): Promise<{
+        events: readonly ExecutionHistoryEvent[];
+    } | undefined>;
+}
+/** The behavior verbs the service invokes on an execution session. */
+export interface SessionDriver {
+    rename(title: string): Promise<unknown>;
+    prompt(content: readonly unknown[], mode: 'queue'): Promise<{
+        ok: true;
+    } | {
+        ok: false;
+        error: unknown;
+    }>;
+    getSnapshot(): {
+        running: boolean;
+        lastAgentError: string | null;
+        turnEnds: ReadonlyMap<number, number>;
+    };
+    subscribe(fn: () => void): () => void;
+}
+/** Everything the service needs from the runtime. */
+export interface ExecutionEnvironment {
+    sessions: SessionsExecutionFace;
+    workspaces: WorkspacesExecutionFace;
+    /** Raw-history reader for failure detection of never-opened sessions. */
+    history?: HistoryExecutionFace;
+}
+/** Outcome events the service emits to the controller. */
+export type ExecutionEvent = {
+    kind: 'started';
+    taskId: string;
+    executionId: string;
+    sessionId: string;
+} | {
+    kind: 'settled';
+    taskId: string;
+    executionId: string;
+    outcome: 'succeeded' | 'failed' | 'cancelled';
+    error?: string;
+};
+/**
+ * Run one task to completion (or to a settled failure).
+ *
+ * @param task - the task being executed.
+ * @param execution - the freshly opened execution record (id + start time).
+ * @param onEvent - callback for started/settled events.
+ * @returns resolves when the run settles (or fails to start); never rejects —
+ *   every failure path is reported as a settled event.
+ */
+export declare class ExecutionService {
+    private readonly env;
+    /** @param env - the runtime faces (real or fake). */
+    constructor(env: ExecutionEnvironment);
+    run(task: TaskRecord, execution: ExecutionRecord, onEvent: (event: ExecutionEvent) => void): Promise<void>;
+    /**
+     * Inspect a reloaded/background task that was left 'running' and emit a
+     * settled event when its session already finished.
+     *
+     * A session that was never opened keeps a cold conversation snapshot (the
+     * runtime only maintains the window for the staged/current session), so the
+     * settled outcome is decided by the strongest available signal, in order:
+     * 1. the list summary — missing session → cancelled; still running → pending;
+     * 2. a warm conversation snapshot → `lastAgentError` decides failed/succeeded;
+     * 3. the raw history tail (when a history face is wired) — a `turn/end`
+     *    error reason proves failure;
+     * 4. otherwise a finished session counts as succeeded.
+     *
+     * @param task - a task whose latest execution has no endedAt.
+     * @returns a settled event when the session state proves completion, else undefined.
+     */
+    reconcile(task: TaskRecord): Promise<ExecutionEvent | undefined>;
+    /** Best-effort failure probe over the raw history tail (false when unavailable). */
+    private historyShowsFailure;
+    private connectSession;
+    private driverOf;
+    private sendPrompt;
+    /**
+     * Subscribe to the execution session and settle the run once the accepted
+     * turn completes (turn counter advanced past the acceptance baseline and
+     * the session is no longer running). Never settles while the session is
+     * still running; unsubscribes on settle.
+     */
+    private watchForSettlement;
+}

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

@@ -0,0 +1,40 @@
+/**
+ * Minimal 5-field cron parsing and next-run computation for scheduled task
+ * runs. Framework-free and dependency-free so the scheduler and controller
+ * share one tiny pure module.
+ *
+ * Grammar: five whitespace-separated fields, 分 时 日 月 周. Every field
+ * supports the wildcard, step (wildcard or range + "/n"), single value,
+ * inclusive range a-b, and comma lists mixing any of those. Ranges: minutes
+ * 0-59, hours 0-23, days 1-31, months 1-12, weekdays 0-7 (0 and 7 both mean
+ * Sunday). When both the day and weekday fields are restricted they combine
+ * with OR semantics (standard cron). Invalid expressions parse to null and
+ * are rejected by the UI/controller.
+ */
+/** The parsed match sets of one cron expression. */
+export interface CronSchedule {
+    minutes: ReadonlySet<number>;
+    hours: ReadonlySet<number>;
+    days: ReadonlySet<number>;
+    months: ReadonlySet<number>;
+    /** Weekdays 0-6, 0 = Sunday (input 7 normalized to 0). */
+    weekdays: ReadonlySet<number>;
+    /** Whether the day-of-month field was the literal '*' (unrestricted). */
+    dayWildcard: boolean;
+    /** Whether the weekday field was the literal '*' (unrestricted). */
+    weekdayWildcard: boolean;
+}
+/**
+ * Parse a 5-field cron expression.
+ * @returns the match sets, or null when the expression is invalid.
+ */
+export declare function parseCron(expr: string): CronSchedule | null;
+/** Whether the expression parses. */
+export declare function isValidCron(expr: string): boolean;
+/**
+ * Compute the next matching instant after `fromMs` (ms epoch), in local time,
+ * at minute granularity, strictly greater than `fromMs`. Returns the ms epoch
+ * of the matching minute's start, or undefined when nothing matches within
+ * 366 days (e.g. `0 0 30 2 *`).
+ */
+export declare function nextRunAtMs(expr: string, fromMs: number): number | undefined;

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

@@ -0,0 +1,49 @@
+import type { TaskRecord } from './tasks.ts';
+/** Everything the scheduler needs from its host (the board controller). */
+export interface SchedulerDeps {
+    /** Read the current task ledger (the controller snapshot). */
+    tasks(): readonly TaskRecord[];
+    /** Clock; defaults to Date.now in the controller wiring. */
+    now(): number;
+    /** Trigger one task's real execution (the controller's runTask); resolves
+     *  true when the run was accepted, false when rejected (e.g. the task is
+     *  already running). */
+    runTask(id: string): Promise<boolean>;
+    /** Persist a rolled-forward schedule (next due + this trigger instant). */
+    applySchedule(id: string, nextRunAt: number | undefined, lastTriggeredAt: number | undefined): void;
+    /** Tick cadence; defaults to 60_000 ms. */
+    tickMs?: number;
+    /**
+     * Gate: while false the tick no-ops (e.g. the session list baseline has not
+     * arrived on page load, so executions would fail). Defaults to always ready.
+     */
+    ready?: () => boolean;
+    /** Environment listeners for tab-visibility recovery (browser only). */
+    environment?: {
+        addEventListener(type: 'visibilitychange', listener: () => void): void;
+        removeEventListener(type: 'visibilitychange', listener: () => void): void;
+    };
+}
+/**
+ * The schedule heartbeat (see module doc). `tick` is public so tests and
+ * callers can drive a check without waiting for the interval.
+ */
+export declare class SchedulerService {
+    private readonly deps;
+    private timer;
+    private disposed;
+    /** @param deps - tasks/clock/trigger/apply faces (see {@link SchedulerDeps}). */
+    constructor(deps: SchedulerDeps);
+    /** Start ticking: one immediate check (catch-up after reload) + the interval. */
+    start(): void;
+    /** Stop ticking and drop listeners (idempotent). */
+    dispose(): void;
+    /**
+     * Check every enabled schedule and trigger the due ones. Idempotent per
+     * task per tick: the schedule is rolled forward only after runTask accepts
+     * the run, so a rejected run keeps its due slot and is retried on the next
+     * tick instead of being silently dropped.
+     */
+    tick(): Promise<void>;
+    private readonly onVisibility;
+}

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

@@ -0,0 +1,36 @@
+import type { TaskRecord } from './tasks.ts';
+/** Persistence seam for the task ledger. */
+export interface TaskStore {
+    /** Read the persisted ledger (empty when nothing is stored yet). */
+    load(): TaskRecord[];
+    /** Persist the whole ledger (replaces the stored document). */
+    save(tasks: readonly TaskRecord[]): void;
+    /** Drop the persisted ledger (leaves the in-memory state alone). */
+    clear(): void;
+}
+/** Storage key for the task ledger document. */
+export declare const DEFAULT_STORAGE_KEY = "dsh.taskBoard.v1";
+/** A task record is structurally valid if it round-trips through the UI. */
+export declare function isTaskRecord(value: unknown): value is TaskRecord;
+/** Parse + validate a persisted ledger document; invalid rows are dropped. */
+export declare function parseLedger(raw: string | null): TaskRecord[];
+/** localStorage-backed store (the browser backend). */
+export declare class LocalStorageTaskStore implements TaskStore {
+    private readonly key;
+    private readonly storage;
+    /**
+     * @param key - storage key for the ledger document.
+     * @param storage - storage backend (defaults to the global localStorage; tests inject fakes).
+     */
+    constructor(key?: string, storage?: Pick<Storage, 'getItem' | 'setItem' | 'removeItem'> | undefined);
+    load(): TaskRecord[];
+    save(tasks: readonly TaskRecord[]): void;
+    clear(): void;
+}
+/** In-memory backend (tests, and a fallback when storage is unavailable). */
+export declare class InMemoryTaskStore implements TaskStore {
+    private ledger;
+    load(): TaskRecord[];
+    save(tasks: readonly TaskRecord[]): void;
+    clear(): void;
+}

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

@@ -0,0 +1,111 @@
+/**
+ * Task board domain model: task lifecycle statuses, the task record shape,
+ * and the pure transition functions the controller and tests share.
+ * Framework-free (no cordis, no runtime imports) so the state machine is
+ * unit-testable in isolation.
+ */
+/** Task lifecycle status, one per kanban column. */
+export type TaskStatus = 'backlog' | 'todo' | 'running' | 'done' | 'failed';
+/**
+ * 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
+ * session's turn ended.
+ */
+export interface ExecutionRecord {
+    /** Execution attempt id (uuid). */
+    id: string;
+    /** The dsh session that ran this attempt; absent until creation resolves. */
+    sessionId: string | undefined;
+    /** When the run started (ms epoch). */
+    startedAt: number;
+    /** When the run settled; absent while still running. */
+    endedAt: number | undefined;
+    /** Outcome once settled. */
+    result: 'succeeded' | 'failed' | 'cancelled' | undefined;
+    /** Human failure text when the run failed (prompt rejection or agent error). */
+    error: string | undefined;
+}
+/**
+ * A scheduled-run rule attached to a task. The browser-side scheduler ticks
+ * every minute and triggers the task when `nextRunAt` is due; the rule is
+ * persisted with the task (localStorage), so scheduling survives refreshes.
+ */
+export interface ScheduleRule {
+    /** Whether the schedule is armed. */
+    enabled: boolean;
+    /** 5-field cron expression: `分 时 日 月 周`. */
+    cron: string;
+    /** Next due instant (ms epoch); maintained by the scheduler/controller. */
+    nextRunAt: number | undefined;
+    /** Instant of the latest scheduled trigger (ms epoch). */
+    lastTriggeredAt: number | undefined;
+}
+/** One task on the board. */
+export interface TaskRecord {
+    /** Stable task id (uuid). */
+    id: string;
+    /** Short display title. */
+    title: string;
+    /** Longer human description shown in the detail view. */
+    description: string;
+    /** The prompt sent to dsh when this task is executed. */
+    prompt: string;
+    /** Current column. */
+    status: TaskStatus;
+    /** Creation instant (ms epoch). */
+    createdAt: number;
+    /** Last mutation instant (ms epoch). */
+    updatedAt: number;
+    /** Every execution attempt, most recent last. */
+    executions: ExecutionRecord[];
+    /** Optional scheduled-run rule (absent on tasks without a schedule). */
+    schedule?: ScheduleRule;
+}
+/** Input for creating a task. */
+export interface NewTaskInput {
+    title: string;
+    description: string;
+    prompt: string;
+}
+/** The five kanban columns, in display order. */
+export declare const COLUMNS: readonly {
+    status: TaskStatus;
+    label: string;
+}[];
+/** Statuses a user may move a card to manually (execution states are owned by the runner). */
+export declare const MANUAL_STATUSES: readonly TaskStatus[];
+/** Statuses the runner may move a card to from 'running'. */
+export declare const RUNNER_SETTLE_STATUSES: readonly TaskStatus[];
+/** All valid statuses (closed union guard). */
+export declare const ALL_STATUSES: readonly TaskStatus[];
+/** Brand an unknown string as a status; undefined when it is not one. */
+export declare function isTaskStatus(value: unknown): value is TaskStatus;
+/** Whether a manual move target is allowed from the given status. */
+export declare function canMoveManually(_from: TaskStatus, to: TaskStatus): boolean;
+/** Create a task from user input. */
+export declare function createTask(input: NewTaskInput, now: number, id: string): TaskRecord;
+/** Clone a task with an updated status and a fresh updatedAt. */
+export declare function withStatus(task: TaskRecord, status: TaskStatus, now: number): TaskRecord;
+/**
+ * Merge a schedule patch into a task's schedule rule (creating it when
+ * absent), with a fresh updatedAt. Keys present in the patch overwrite the
+ * current value — including explicit `undefined`, which clears a field (used
+ * to disarm `nextRunAt`); absent keys keep their current value.
+ */
+export declare function withSchedule(task: TaskRecord, patch: Partial<ScheduleRule>, now: number): TaskRecord;
+/**
+ * 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.
+ */
+export declare function startExecution(task: TaskRecord, now: number, executionId: string): {
+    task: TaskRecord;
+    execution: ExecutionRecord;
+};
+/**
+ * Settle a running execution: record the outcome and move the task into the
+ * 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;
+/** A settled-execution summary string for the detail view. */
+export declare function executionLabel(execution: ExecutionRecord): string;

package/lib/types/index.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Host loader entry for the task-board plugin.
+ *
+ * Everything the board does is browser work (DOM, localStorage, driving the
+ * client runtime's session services over the wire), so the host half's main
+ * behavior is a system-prompt section announcing the plugin to every agent.
+ * The section registers while this plugin is in the host composition (mount /
+ * DSH restart) and disappears when the plugin leaves it (unmount / restart),
+ * so agents always know the board exists and how to cooperate with it. The
+ * announcement can be turned off through the web settings plugin-configuration
+ * surface (`announceToAgent`); the section then disappears live.
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import z from 'schemastery';
+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-ui \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\uFF1B\u4EFB\u52A1\u53EF\u771F\u5B9E\u6267\u884C\uFF08\u9A71\u52A8 agent \u4F1A\u8BDD\uFF09\uFF1B\u4EFB\u52A1\u652F\u6301 5 \u6BB5 cron \u5B9A\u65F6\u6267\u884C\uFF08\u5982 0 23 * * *\uFF09\uFF1B\u6570\u636E\u5B58\u6D4F\u89C8\u5668 localStorage\uFF08\u952E dsh.taskBoard.v1\uFF09\u3002\u9650\u5236\uFF1A\u5B9A\u65F6\u8C03\u5EA6\u5728\u6D4F\u89C8\u5668\u7AEF\uFF0C\u9700 GUI \u6807\u7B7E\u9875\u6253\u5F00\uFF0C\u9519\u8FC7\u5373\u8DF3\u8FC7\uFF1B\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";
+/**
+ * Settings namespace of the board's announcement capability — the section the
+ * web settings surface edits. Spelled here rather than imported: the browser
+ * half spells the same value and must not depend on a Host package.
+ */
+export declare const TASK_BOARD_SETTINGS_NAMESPACE: import("@deepseek-ai/dsh-settings").SettingsNamespace;
+/** Plugin config, validated by the same-named schemastery schema. */
+export interface Config {
+    /**
+     * When true (default), a system-prompt section announces the board to every
+     * agent. Set false to keep the board silent in prompts; agents then learn
+     * about it only when the user mentions it.
+     */
+    announceToAgent?: boolean;
+    /** Master switch for the plugin (browser half + host announcement). */
+    enabled?: boolean;
+}
+export declare const Config: z<Config>;
+/**
+ * Register the board's announcement section, gated on the composition entry's
+ * `announceToAgent` (and the live settings value once the web settings
+ * surface is served). The section is re-registered whenever the source
+ * changes, so a settings edit takes effect without a restart.
+ * @param ctx - the plugin context (systemPrompt injected).
+ * @param config - resolved plugin config (schema defaults applied by the loader).
+ */
+export declare function apply(ctx: Context, config?: Config): void;

package/lib/types/invariant.d.ts

@@ -0,0 +1,3 @@
+/** Invariant companion plugin (no assertions — nothing to check at runtime). */
+/** Provides no assertions: the board owns no cross-package runtime invariants. */
+export declare function apply(): void;

package/package.json

@@ -0,0 +1,85 @@
+{
+  "name": "@linxin666/dsh-client-ui-task-board",
+  "description": "Task board for the dsh web GUI: a sidebar entry plus a multi-column kanban view with local persistence, task details, and real execution through dsh sessions (session.prompt). Hot-pluggable — mounted via ~/.dsh/cordis.patch.yml + a profile node_modules symlink, no dsh source changes.",
+  "version": "0.1.1",
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/types/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./invariant": {
+      "types": "./lib/types/invariant.d.ts",
+      "default": "./lib/invariant.js"
+    },
+    "./client": {
+      "types": "./lib/types/client/index.d.ts",
+      "default": "./lib/client.js"
+    },
+    "./src/*": "./src/*",
+    "./package.json": "./package.json"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "inject": [
+        "@deepseek-ai/dsh-client-runtime",
+        "@deepseek-ai/dsh-client-connection",
+        "@deepseek-ai/dsh-client-ui-settings"
+      ],
+      "platform": "web"
+    }
+  },
+  "peerDependencies": {
+    "@deepseek-ai/dsh-client-connection": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-client-runtime": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-client-ui-settings": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-settings": "^0.1.0-rc.6",
+    "react": "^18.2.0"
+  },
+  "dependencies": {
+    "schemastery": "^3.18.0"
+  },
+  "devDependencies": {
+    "@deepseek-ai/cordis": "^4.0.1",
+    "@deepseek-ai/dsh-client-connection": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-client-locale": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-client-runtime": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-client-ui-settings": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-client-ui-slots": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-settings": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-system-prompt": "^0.1.0-rc.6",
+    "@types/react": "~18.3.1",
+    "@types/react-dom": "^18.3.5",
+    "jsdom": "^25.0.0",
+    "lightningcss": "1.32.0",
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1",
+    "schemastery": "^3.18.0",
+    "tsdown": "0.22.2",
+    "typescript": "~5.7.2",
+    "vitest": "^3.0.0"
+  },
+  "files": [
+    "lib/index.js",
+    "lib/invariant.js",
+    "lib/client.js",
+    "lib/types/**/*.d.ts",
+    "lib/types/**/*.d.ts.map",
+    "src",
+    "cordis.patch.yml"
+  ],
+  "license": "BSD-3-Clause",
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json && tsdown",
+    "bundle": "tsdown",
+    "watch": "tsdown --watch",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  }
+}