@linxin666/dsh-client-ui-task-board 0.3.22 → 0.3.24

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

@@ -6,3 +6,9 @@ export declare function EditTaskModal({ controller, task, onClose }: {
     task: TaskRecord;
     onClose: () => void;
 }): import("react").JSX.Element;
+/** Edit-tags modal: edit labels only, shown for tasks after first execution. */
+export declare function EditTagsModal({ controller, task, onClose }: {
+    controller: BoardController;
+    task: TaskRecord;
+    onClose: () => void;
+}): import("react").JSX.Element;

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

@@ -5,8 +5,13 @@ export interface NewTaskModalProps {
     onClose: () => void;
     /** Optional task template to clone/duplicate from. */
     initialTask?: TaskRecord;
+    /**
+     * Workspace the board's project filter has selected (#1536): a task created
+     * while a project is open belongs to that project unless the user changes it.
+     */
+    defaultWorkspaceId?: string;
     /** Optional callback after successful duplication (e.g. to archive source). */
     onDuplicateSuccess?: (sourceTaskId: string) => Promise<void>;
 }
 /** New-task form overlay. */
-export declare function NewTaskModal({ controller, onClose, initialTask, onDuplicateSuccess }: NewTaskModalProps): import("react").JSX.Element;
+export declare function NewTaskModal({ controller, onClose, initialTask, defaultWorkspaceId, onDuplicateSuccess }: NewTaskModalProps): import("react").JSX.Element;

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

@@ -1,5 +1,7 @@
 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. */
 export declare function matchesFilter(task: TaskRecord, filter: string): boolean;
 /**

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

@@ -7,7 +7,7 @@
 import type { ReactNode } from 'react';
 import { type TaskTag } from '../../core/tasks.ts';
 /** Modal overlay: closes on backdrop press, submits through the form. */
-export declare function ModalShell({ ariaLabel, title, error, pending, submitLabel, onSubmit, onClose, children, }: {
+export declare function ModalShell({ ariaLabel, title, error, pending, submitLabel, onSubmit, onClose, secondaryAction, children, }: {
     ariaLabel: string;
     title: string;
     error: string | undefined;
@@ -15,6 +15,11 @@ export declare function ModalShell({ ariaLabel, title, error, pending, submitLab
     submitLabel: string;
     onSubmit: () => void;
     onClose: () => void;
+    /** Optional second action beside the primary submit (e.g. create and run). */
+    secondaryAction?: {
+        label: string;
+        onSubmit: () => void;
+    };
     children: ReactNode;
 }): import("react").JSX.Element;
 /** Title + description + prompt fields shared by the new and edit task forms. */
@@ -40,7 +45,7 @@ export declare function TaskTagFields({ tags, knownTags, onChange, }: {
     onChange: (tags: TaskTag[]) => void;
 }): import("react").JSX.Element;
 /**
- * Drop blank rows and trim what survives, so the wire always carries a valid
- * tag list (the protocol rejects a list with a blank name or an empty array).
+ * Clean a tag list via normalizeTags: trim, drop blanks and duplicates, cap
+ * lengths and count, so the wire always carries a valid tag list.
  */
 export declare function cleanTags(tags: readonly TaskTag[]): TaskTag[];

package/lib/types/client/board/parse-model-pref.d.ts

@@ -0,0 +1,4 @@
+/** The remembered parse model; '' means the Host default (or no preference). */
+export declare function readParseModelPreference(storage?: Pick<Storage, 'getItem'> | undefined): string;
+/** Remember the picked parse model; '' records the Host-default choice. */
+export declare function writeParseModelPreference(model: string, storage?: Pick<Storage, 'setItem'> | undefined): void;

package/lib/types/client/host-api.d.ts

@@ -1,10 +1,26 @@
 import type { TaskRecord } from '../core/tasks.ts';
-import { type TaskBoardAction, type TaskBoardEventPayload, type TaskBoardSnapshot } from '../protocol.ts';
+import { type TaskBoardAction, type TaskBoardEventPayload, type TaskBoardParseDraft, type TaskBoardParseRequest, type TaskBoardSnapshot } from '../protocol.ts';
+/**
+ * Failure classes of the Host API, in the language the panel renders
+ * (issue #1528). The Host is the only part that knows whether a task-board
+ * route exists at all, so a raw fetch/parse error must never reach the user:
+ * "Unexpected token 'o', \"not found\" is not valid JSON" is what a missing
+ * Host half looks like today.
+ */
+export type HostApiFailure = 'not-mounted' | 'unauthorized' | 'locked' | 'rejected' | 'timeout' | 'unreachable' | 'unexpected';
+/** Transport failure carrying a stable class next to its user-facing message. */
+export declare class HostApiError extends Error {
+    readonly failure: HostApiFailure;
+    readonly status?: number | undefined;
+    constructor(failure: HostApiFailure, message: string, status?: number | undefined);
+}
 export interface TaskBoardHostTransport {
     bootstrap(legacy: readonly TaskRecord[]): Promise<TaskBoardSnapshot>;
     state(): Promise<TaskBoardSnapshot>;
     action(action: TaskBoardAction, initiator?: string): Promise<TaskBoardSnapshot>;
     subscribe(listener: (event?: TaskBoardEventPayload) => void): () => void;
+    /** One-shot model parse of pasted text (issue #1540). */
+    parseDraft(request: TaskBoardParseRequest, signal?: AbortSignal): Promise<TaskBoardParseDraft>;
 }
 export declare class HttpTaskBoardHostTransport implements TaskBoardHostTransport {
     private readonly storage;
@@ -14,5 +30,11 @@ export declare class HttpTaskBoardHostTransport implements TaskBoardHostTranspor
     action(action: TaskBoardAction, initiator?: string): Promise<TaskBoardSnapshot>;
     private post;
     private request;
+    /**
+     * Ask the Host to turn pasted text into task fields. The route answers a
+     * typed failure (no model, timeout, unparseable reply) already phrased for
+     * the form, so the UI never renders a raw status code (issue #1540).
+     */
+    parseDraft(request: TaskBoardParseRequest, signal?: AbortSignal): Promise<TaskBoardParseDraft>;
     subscribe(listener: (event?: TaskBoardEventPayload) => void): () => void;
 }

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

@@ -28,6 +28,30 @@ export declare const zh: {
     'board.updated': string;
     'board.created': string;
     'board.hostError': string;
+    'board.hostError.notMounted': string;
+    'board.hostError.unauthorized': string;
+    'board.hostError.locked': string;
+    'board.hostError.timeout': string;
+    'board.hostError.unreachable': string;
+    'board.hostError.unexpected': string;
+    'board.project': string;
+    'board.projectAll': string;
+    'board.projectNew': string;
+    'board.projectNewPath': string;
+    'board.projectNewPathPlaceholder': string;
+    'board.projectCreate': string;
+    'board.projectCreateFailed': string;
+    'new.aiParse': string;
+    'new.aiParseHint': string;
+    'new.aiParsePlaceholder': string;
+    'new.aiParseModel': string;
+    'new.aiParseRun': string;
+    'new.aiParseCancel': string;
+    'new.aiParseEmpty': string;
+    'new.aiParseNoModel': string;
+    'new.aiParseUnavailable': string;
+    'new.aiParseTimeout': string;
+    'new.aiParseFailed': string;
     'board.retryHost': string;
     'board.hostMeta': string;
     'new.title': string;
@@ -37,6 +61,7 @@ export declare const zh: {
     'new.prompt': string;
     'new.promptPlaceholder': string;
     'new.submit': string;
+    'new.createAndRun': string;
     'new.cancel': string;
     'new.required': string;
     'new.freeze': string;
@@ -70,6 +95,7 @@ export declare const zh: {
     'detail.permissionConfirmed': string;
     'detail.title': string;
     'detail.edit': string;
+    'detail.editTags': string;
     'detail.duplicate': string;
     'detail.duplicateAndEdit': string;
     'detail.close': string;

package/lib/types/client/plugin-card-seat.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Family plugin-card seat.
+ *
+ * A family plugin contributes its settings card to whichever plugin-card seat
+ * the running host actually renders:
+ *
+ * - `web-ui.plugin.item` — the list seat declared by the dsh-web-settings
+ *   group section (this family's own first-level "Web UI plugins" section);
+ * - `settings.plugin.item` — the official keyed seat of the harness's
+ *   `ui-settings-plugins` tab, keyed by the settings namespace the card edits.
+ *
+ * SEAT SELECTION IS NOT A DECLARATION PROBE. The official `ui-settings-plugins`
+ * row belongs to the harness bundle and its `configurable` tab always declares
+ * `settings.plugin.item` before any external plugin's `apply()` runs, so
+ * "is the official seat declared?" answers yes even in the deployment whose
+ * whole point is the family group. Choosing on that probe sends every family
+ * card to the official Plugins tab and leaves the group's own section
+ * permanently empty — the family of reports where the section renders its
+ * heading and zero cards.
+ *
+ * The signal that actually distinguishes the two deployments is whether
+ * dsh-web-settings is loaded: it is the package that owns the group section and
+ * it publishes the `webUiSettings` service during `apply()`, which every
+ * family plugin already reads for its settings scope. Group loaded -> the family
+ * seat; group absent -> the official seat.
+ *
+ * The decision is re-evaluated on every `slots/changed` because the group may
+ * apply after this plugin (the family aggregate orders it first, a profile that
+ * installs the group separately need not): the initial contribution goes to the
+ * official seat, then moves to the family seat the moment the group's section
+ * registers. The entry is disposed before the replacement is registered, so a
+ * card is never in two seats at once.
+ *
+ * The shared tree has no client-SDK dependency, so this module reads its
+ * context through the structural shape below; callers pass the plugin's own
+ * `ctx`.
+ */
+/** The family list seat key. */
+export declare const FAMILY_PLUGIN_CARD_SEAT = "web-ui.plugin.item";
+/** The official keyed plugin-card seat key. */
+export declare const OFFICIAL_PLUGIN_CARD_SEAT = "settings.plugin.item";
+/** The service dsh-web-settings publishes while it is loaded. */
+export declare const FAMILY_GROUP_SERVICE = "webUiSettings";
+/** The slot-registry member this helper uses (structurally satisfied by ctx.slots). */
+export interface PluginCardSlots {
+    /** Contribution of one card entry. */
+    register(options: never, component: never): unknown;
+}
+/** The slice of the client context a card contribution needs. */
+export interface PluginCardContext {
+    slots: PluginCardSlots;
+    /** Service lookup; absent on a context double that only models the slots. */
+    get?(name: string): unknown;
+    /** Event subscription seat; absent on an event-less test double. */
+    on?(event: string, listener: (...args: never[]) => void): unknown;
+}
+/** Owner share of a plugin card (both seats supply nothing). */
+export interface SettingsPluginItemOwnerProps {
+    /** Marker field: card owner props are intentionally empty. */
+    children?: never;
+}
+/** One family plugin's card contribution. */
+export interface PluginCardSeat {
+    /** Settings namespace the card edits (the official seat's dispatch key). */
+    namespace: string;
+    /** Family list-seat entry id. */
+    id: string;
+    /** Family list-seat sort order. */
+    order?: number;
+    /** Family list-seat display label; the official keyed seat carries none. */
+    label?: () => string;
+    /** Locale namespace the card renders with. */
+    locale: string;
+    /** Business-face factory of the registration. */
+    inject?: () => object;
+    /**
+     * The card component. Its props type is the seat's composed shape, which is
+     * chosen at runtime, so the helper takes it erased; the registrant keeps its
+     * own precise typing at the call site.
+     */
+    component: unknown;
+}
+/**
+ * Whether the family group (dsh-web-settings) is loaded in this page. The
+ * service is the group package's own contract, so the probe cannot be fooled
+ * by a harness release that starts declaring the official seat differently.
+ */
+export declare function familyGroupLoaded(ctx: PluginCardContext): boolean;
+/**
+ * Contribute one family plugin card to the seat this host renders, following
+ * the group if it loads later. The entry is disposed and re-registered on a
+ * seat change, never duplicated.
+ * @param ctx - client context (its slot registry decides the seat).
+ * @param seat - the card contribution.
+ */
+export declare function installPluginCard(ctx: PluginCardContext, seat: PluginCardSeat): void;

package/lib/types/client/sidebar-entry-core.d.ts

@@ -1,3 +1,29 @@
+/**
+ * One trailing action button seated at the entry row's right edge (e.g. a
+ * refresh command or a collapse chevron). Rows with actions switch from the
+ * classic single-button structure to a container with a main button plus the
+ * action buttons (nested interactive elements are invalid HTML); rows without
+ * actions keep the classic structure untouched.
+ */
+export interface SidebarEntryAction {
+    /** Stable id stamped as data-dsh-entry-action="<id>" (CSS hooks and tests). */
+    id: string;
+    /** Inline icon markup while the row is active (always, when inactiveIcon is unset). */
+    icon: string;
+    /**
+     * Optional icon while the row is inactive. Setting it makes the action a
+     * state mirror (a collapse chevron): the core swaps the icon and stamps
+     * aria-expanded on every active-state change. Requires the active bridge.
+     */
+    inactiveIcon?: string;
+    /** Localized accessible label (aria-label + title); receives the active state. */
+    label(active: boolean): string;
+    /**
+     * Click handler; receives the button so the caller can drive transient
+     * affordances (a refresh cooldown) without a re-render.
+     */
+    onClick(button: HTMLButtonElement): void;
+}
 /** Per-package configuration for one sidebar entry row. */
 export interface SidebarEntryOptions {
     /** Full attribute name identifying the injected row (idempotency key), e.g. 'data-dsh-ssh-entry'. */
@@ -31,6 +57,12 @@ export interface SidebarEntryOptions {
     };
     /** Click action (open/toggle the owning panel). */
     onToggle(): void;
+    /**
+     * Optional trailing action buttons at the row's right edge. Requires the
+     * package CSS to seat entryMain / entryAction; empty keeps the classic
+     * single-button row.
+     */
+    actions?: readonly SidebarEntryAction[];
     /** Family-block position: 'before' inserts ahead of sibling plugin rows, 'after' behind them. */
     position: 'before' | 'after';
     /**

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

@@ -14,7 +14,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, TaskBoardSnapshot } from '../protocol.ts';
+import type { TaskBoardAction, TaskBoardEventPayload, TaskBoardParseDraft, TaskBoardParseRequest, TaskBoardSnapshot } from '../protocol.ts';
 export interface TaskBoardTransport {
     bootstrap(legacy: readonly TaskRecord[]): Promise<TaskBoardSnapshot>;
     state(): Promise<TaskBoardSnapshot>;
@@ -24,6 +24,11 @@ export interface TaskBoardTransport {
      */
     action(action: TaskBoardAction, initiator?: string): Promise<TaskBoardSnapshot>;
     subscribe(listener: (event?: TaskBoardEventPayload) => void): () => void;
+    /**
+     * One-shot model parse of pasted text (issue #1540). Optional: a deployment
+     * that cannot parse simply omits it, and the form hides the section.
+     */
+    parseDraft?(request: TaskBoardParseRequest, signal?: AbortSignal): Promise<TaskBoardParseDraft>;
 }
 /** The sessions face the controller needs for navigation awareness. */
 export interface SessionsControllerFace {
@@ -47,6 +52,14 @@ export interface ControllerDeps {
     /** Host-authoritative transport; absent keeps the legacy in-memory test path. */
     transport?: TaskBoardTransport;
 }
+/**
+ * Register one host directory as a DSH project (workspace). Wired by the
+ * browser apply() to the runtime's workspace controller; without it the board
+ * hides its "new project" action instead of offering a dead control (#1536).
+ */
+export type WorkspaceCreator = (path: string) => Promise<{
+    workspaceId: string;
+}>;
 /** One workspace option the execution-target pickers offer. */
 export interface ExecutionWorkspaceOption {
     workspaceId: string;
@@ -85,6 +98,10 @@ export interface ControllerSnapshot {
     /** Picker option sets (workspace list + agent-preset roster). */
     executionOptions: ExecutionOptionsSnapshot;
     pendingTaskIds: readonly string[];
+    /** Whether the board may offer "register a new project" (issue #1536). */
+    canCreateWorkspace?: boolean;
+    /** Whether this deployment can parse pasted text into task fields (issue #1540). */
+    canParseTask?: boolean;
     transportError?: string;
     host?: Pick<TaskBoardSnapshot, 'revision' | 'scheduler' | 'power' | 'sessionDefaultPermission'>;
 }
@@ -101,6 +118,7 @@ export declare class BoardController {
     private archiveView;
     private selectedTaskId;
     private executionOptions;
+    private workspaceCreator;
     private listeners;
     private disposers;
     private readonly now;
@@ -151,6 +169,22 @@ export declare class BoardController {
      * and agent-preset roster come from the runtime, not the ledger).
      */
     setExecutionOptions(patch: Partial<ExecutionOptionsSnapshot>): void;
+    /** Wire (or clear) the runtime's project registration face (issue #1536). */
+    setWorkspaceCreator(creator: WorkspaceCreator | undefined): void;
+    /**
+     * Register an existing host directory as a DSH project, exactly as the GUI's
+     * own "add project" does; the runtime's failure message surfaces unchanged.
+     */
+    createWorkspace(path: string): Promise<{
+        workspaceId: string;
+    }>;
+    /** Whether this deployment can parse pasted text into task fields (issue #1540). */
+    canParseTask(): boolean;
+    /**
+     * Parse pasted text into task fields through the Host. The transport already
+     * phrases every failure for the user, so its message surfaces unchanged.
+     */
+    parseTaskDraft(request: TaskBoardParseRequest, signal?: AbortSignal): Promise<TaskBoardParseDraft>;
     moveTask(id: string, status: TaskStatus): void;
     deleteTask(id: string): void;
     /**

package/lib/types/core/session-reuse.d.ts

@@ -8,8 +8,10 @@ import type { TaskRecord } from './tasks.ts';
  * Pick the session a new execution of this task may continue in, or undefined
  * to mint a fresh conversation. Reuse requires ALL of:
  * - the task opted in (`reuseSession === true`);
- * - the task's newest execution carries a session id and has settled (an open
- *   execution would have made the ledger refuse the run in the first place);
+ * - the task's newest SETTLED execution carries a session id (issue #1587: the
+ *   launch path calls this after `startExecution` appended this run's own open
+ *   record, so reading the array tail always found an unsettled row and reuse
+ *   never happened);
  * - the roster is known and that session is present and idle.
  *
  * An unknown roster (session/list unavailable) never reuses: minting a fresh

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

@@ -0,0 +1,51 @@
+/**
+ * One-shot model parse behind the board's "parse pasted text" action
+ * (issue #1540).
+ *
+ * The browser half never talks to a model: it posts the pasted text and the
+ * route the user picked to the Host, which calls the injected `llm` service
+ * once and answers with the three draft fields the new-task form accepts. The
+ * reply is untrusted text, so extraction is defensive: code fences are
+ * stripped, the first JSON object wins, and an unusable reply falls back to
+ * the user's own words instead of an empty form.
+ */
+import { type LlmRuntime } from '@deepseek-ai/dsh-llm';
+import type { TaskBoardParseDraft, TaskBoardParseRequest } from './protocol.ts';
+/** How long one parse may take before the Host gives up on the model. */
+export declare const TASK_PARSE_TIMEOUT_MS = 45000;
+/** Largest pasted text one parse accepts (bytes). */
+export declare const TASK_PARSE_MAX_INPUT: number;
+export type TaskParseFailureCode = 'no-model' | 'model-error' | 'parse-failed' | 'timeout';
+/** Typed parse failure; the route maps the code onto a status and a body. */
+export declare class TaskParseError extends Error {
+    readonly code: TaskParseFailureCode;
+    constructor(code: TaskParseFailureCode, message: string);
+}
+/** Split a qualified `provider/model` route the same way the runner does. */
+export declare function splitModelRoute(qualified: string | undefined): {
+    provider: string;
+    model: string;
+} | undefined;
+/**
+ * Read the draft out of a model reply. Fences and surrounding prose are
+ * tolerated; anything unusable returns undefined so the caller can decide
+ * between a typed failure and a fallback.
+ * @param reply - raw model text.
+ */
+export declare function extractTaskParseReply(reply: string): Partial<TaskBoardParseDraft> | undefined;
+/**
+ * Fill the three form fields, falling back to the pasted text so a weak model
+ * reply never loses what the user actually wrote.
+ * @param reply - raw model text.
+ * @param source - the text the user pasted.
+ */
+export declare function draftFromReply(reply: string, source: string): TaskBoardParseDraft;
+/**
+ * Parse one pasted text through the injected `llm` service.
+ * @param llm - the Host's llm service.
+ * @param request - pasted text plus the qualified model route.
+ * @param signal - caller cancellation (client disconnect); combined with the timeout.
+ * @returns the draft fields.
+ * @throws TaskParseError with a code the route maps onto a status.
+ */
+export declare function parseTaskDraft(llm: LlmRuntime, request: TaskBoardParseRequest, signal?: AbortSignal): Promise<TaskBoardParseDraft>;

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

@@ -37,6 +37,21 @@ export interface LedgerRuntimeView {
  */
 export declare function processState(pid: number): string | undefined;
 export declare function processIsAlive(pid: number): boolean;
+/** Runs one PowerShell script and returns its trimmed stdout. */
+export type PowerShellProbe = (script: string, timeoutMs: number) => string | undefined;
+/**
+ * Windows start time (Unix epoch ms) of a live process.
+ *
+ * `Get-Process` is the precise first choice, but an unprivileged caller cannot
+ * read `.StartTime` for a protected process (System, svchost): the property is
+ * empty, so the probe returns nothing. Without a fallback, a crash leftover
+ * lock whose PID was reused by such a process could never be proven stale and
+ * blocked every startup until the lock was deleted by hand (issue #1629).
+ * Win32_Process through CIM reports the same CreationDate for those processes
+ * at the same millisecond precision, so it is the second identity source. The
+ * probe is injectable so the fallback chain is testable off Windows.
+ */
+export declare function win32StartTimeMs(pid: number, probe?: PowerShellProbe): number | undefined;
 export declare class HostTaskLedger {
     private readonly now;
     private document;

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

@@ -1,6 +1,7 @@
 import type { IncomingMessage } from 'node:http';
 import type { WebRoute } from '@deepseek-ai/dsh-host-webserver';
 import type { TaskBoardHostService } from './host-service.ts';
+import { type TaskBoardParseDraft, type TaskBoardParseRequest } from './protocol.ts';
 /** Header replaced by an authenticated same-host reverse proxy. */
 export declare const TASK_BOARD_PROXY_TOKEN_HEADER = "x-dsh-task-board-proxy-token";
 /** Optional authenticated reverse-proxy access layered over the loopback default. */
@@ -8,6 +9,15 @@ export interface TaskBoardRouteAccess {
     trustedProxyHosts?: readonly string[];
     proxyToken?: string;
 }
+/**
+ * Host faces the routes need beyond the ledger service. The parse face is
+ * resolved lazily by the caller, so a deployment without an llm service still
+ * registers the route and answers with a typed "no model" failure instead of
+ * leaving the panel with an unmounted path (issue #1540).
+ */
+export interface TaskBoardRouteOptions {
+    parseTask?: (request: TaskBoardParseRequest, signal: AbortSignal) => Promise<TaskBoardParseDraft>;
+}
 interface ResolvedRouteAccess {
     trustedProxyHosts: ReadonlySet<string>;
     proxyToken?: string;
@@ -22,5 +32,5 @@ interface ResolvedRouteAccess {
  * internal token header after their own authentication step.
  */
 export declare function isTrustedTaskBoardRequest(req: IncomingMessage, access: ResolvedRouteAccess): boolean;
-export declare function makeTaskBoardRoutes(service: TaskBoardHostService, access?: TaskBoardRouteAccess): WebRoute[];
+export declare function makeTaskBoardRoutes(service: TaskBoardHostService, access?: TaskBoardRouteAccess, options?: TaskBoardRouteOptions): WebRoute[];
 export {};

package/lib/types/index.d.ts

@@ -8,6 +8,7 @@
 import type { Context } from '@deepseek-ai/cordis';
 import type { SettingsNamespace } from '@deepseek-ai/dsh-settings';
 import z from 'schemastery';
+import type { LlmRuntime } from '@deepseek-ai/dsh-llm';
 import { type TaskPermission } from './core/tasks.ts';
 /** Default environment variable holding the authenticated proxy token. */
 export declare const DEFAULT_PROXY_TOKEN_ENV = "DSH_TASK_BOARD_PROXY_TOKEN";
@@ -49,6 +50,14 @@ export declare function resolveProxyAccess(config: Config | undefined, env?: Nod
     trustedProxyHosts: string[];
     proxyToken?: string;
 };
+/**
+ * Read the optional `llm` service. The board deliberately does not inject it:
+ * a deployment without a model must still mount the board, and the parse route
+ * answers a typed failure instead of the plugin failing to load (issue #1540).
+ * @param ctx - the plugin context.
+ * @returns the llm service, or undefined when this deployment serves none.
+ */
+export declare function resolveLlmRuntime(ctx: Context): LlmRuntime | undefined;
 /**
  * Register the board's announcement section, gated on the composition entry's
  * `announceToAgent` (and the live settings value once the web settings

package/lib/types/protocol.d.ts

@@ -36,6 +36,25 @@ export interface TaskBoardEventPayload {
     scheduler: TaskBoardSchedulerSnapshot;
     power: TaskBoardPowerSnapshot;
 }
+/**
+ * Request body of `POST {TASK_BOARD_API_PREFIX}/parse` (issue #1540): the text
+ * the user pasted plus the `provider/model` route that should parse it.
+ */
+export interface TaskBoardParseRequest {
+    text: string;
+    /** Qualified route from the model picker; absent when no route was chosen. */
+    model?: string;
+}
+/** Draft fields a parse returns; the user reviews them before creating the task. */
+export interface TaskBoardParseDraft {
+    title: string;
+    description: string;
+    prompt: string;
+}
+/** Strict parse of a `/parse` request body; undefined rejects the request. */
+export declare function parseTaskParseRequest(value: unknown): TaskBoardParseRequest | undefined;
+/** Whether a decoded reply carries the three draft strings the form accepts. */
+export declare function isTaskParseDraft(value: unknown): value is TaskBoardParseDraft;
 export type TaskBoardAction = {
     kind: 'import';
     sourceId: string;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@linxin666/dsh-client-ui-task-board",
   "description": "Host-authoritative task board for the DSH Web GUI with real session execution, Host cron scheduling, and optional cross-platform idle-sleep protection; mounted without DSH source changes.",
-  "version": "0.3.22",
+  "version": "0.3.24",
   "type": "module",
   "main": "lib/index.js",
   "types": "lib/types/index.d.ts",
@@ -68,6 +68,7 @@
     "@types/node": "^22.20.0",
     "@types/react": "~18.3.1",
     "@types/react-dom": "^18.3.5",
+    "@vitest/coverage-v8": "^3.2.7",
     "jsdom": "^25.0.0",
     "react": "^18.3.1",
     "react-dom": "^18.3.1",

package/src/client/board/EditTaskModal.tsx

@@ -69,3 +69,39 @@ export function EditTaskModal({ controller, task, onClose }: { controller: Board
     </ModalShell>
   )
 }
+
+/** Edit-tags modal: edit labels only, shown for tasks after first execution. */
+export function EditTagsModal({ controller, task, onClose }: { controller: BoardController; task: TaskRecord; onClose: () => void }) {
+  const [tags, setTags] = useState<TaskTag[]>(task.tags ?? [])
+  const [error, setError] = useState<string | undefined>(undefined)
+  const [pending, setPending] = useState(false)
+
+  const submit = async (): Promise<void> => {
+    setPending(true)
+    const tagList = cleanTags(tags)
+    const patch = {
+      tags: tagList.length > 0 ? tagList : null,
+    }
+    if (await controller.updateTask(task.id, patch)) {
+      onClose()
+      return
+    }
+    setPending(false)
+    setError(controller.getSnapshot().transportError ?? t('new.required'))
+  }
+
+  return (
+    <ModalShell
+      ariaLabel={t('detail.editTags')}
+      title={t('detail.editTags')}
+      error={error}
+      pending={pending}
+      submitLabel={t('edit.save')}
+      onSubmit={() => { void submit() }}
+      onClose={onClose}
+    >
+      <TaskTagFields tags={tags} knownTags={collectKnownTags(controller.getSnapshot().tasks)} onChange={setTags} />
+    </ModalShell>
+  )
+}
+