@linxin666/dsh-client-ui-task-board 0.3.21 → 0.3.23

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

@@ -1,8 +1,14 @@
 import type { BoardController } from '../../core/controller.ts';
-import type { TaskRecord } from '../../core/tasks.ts';
+import { type TaskRecord } from '../../core/tasks.ts';
 /** Edit-task form overlay. */
 export declare function EditTaskModal({ controller, task, onClose }: {
     controller: BoardController;
     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,7 +1,16 @@
 import { type BoardController } from '../../core/controller.ts';
 import { type TaskRecord } from '../../core/tasks.ts';
-/** Case-insensitive title/description/freeze-snapshot match. */
+/** 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;
+/**
+ * Whether a task carries every selected label (issue #1521). Multi-select is
+ * conjunctive: adding a label narrows the board instead of widening it, which
+ * is the only reading that keeps "工作" selected from dragging unrelated cards
+ * back in when a second label is added.
+ */
+export declare function matchesTagFilter(task: TaskRecord, selected: readonly string[]): boolean;
 /** Board component; subscribes to the controller snapshot. */
 export declare function TaskBoard({ controller }: {
     controller: BoardController;

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

@@ -5,6 +5,7 @@
  * are controlled components.
  */
 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, }: {
     ariaLabel: string;
@@ -26,3 +27,20 @@ export declare function TaskContentFields({ title, description, prompt, onTitleC
     onDescriptionChange: (value: string) => void;
     onPromptChange: (value: string) => void;
 }): import("react").JSX.Element;
+/**
+ * Task labels (issue #1521): one row per label holding the badge name and an
+ * optional execution hint. The name inputs offer the labels already used on the
+ * board through a datalist, and picking one adopts its hint when the row has
+ * none — so a business line is defined once and reused by every later task.
+ */
+export declare function TaskTagFields({ tags, knownTags, onChange, }: {
+    tags: TaskTag[];
+    /** Labels already carried elsewhere on the board. */
+    knownTags: TaskTag[];
+    onChange: (tags: TaskTag[]) => void;
+}): import("react").JSX.Element;
+/**
+ * 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/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;
@@ -54,11 +78,23 @@ export declare const zh: {
     'detail.handover': string;
     'detail.handover.bundledAt': string;
     'detail.handover.references': string;
+    'new.tags': string;
+    'new.tagsHint': string;
+    'new.tagName': string;
+    'new.tagNamePlaceholder': string;
+    'new.tagPrompt': string;
+    'new.tagPromptPlaceholder': string;
+    'new.tagAdd': string;
+    'new.tagRemove': string;
+    'board.tagFilter': string;
+    'board.tagFilterClear': string;
+    'board.tagEmpty': string;
     'detail.permissionPending': string;
     'detail.permissionConfirm': string;
     'detail.permissionConfirmed': string;
     'detail.title': string;
     'detail.edit': string;
+    'detail.editTags': string;
     'detail.duplicate': string;
     'detail.duplicateAndEdit': string;
     'detail.close': string;

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/tasks.d.ts

@@ -81,6 +81,55 @@ export interface TaskFreeze extends FreezeSnapshot {
      */
     frozenBy?: string;
 }
+/**
+ * One task label (issue #1521). The name is the badge and the tag-filter key;
+ * the optional prompt line rides the execution prompt, so a label may be
+ * display-only (no prefix) or carry an instruction (business-line routing,
+ * output directory, house style) that every run of the task inherits.
+ */
+export interface TaskTag {
+    /** Display name; trimmed, non-empty, unique within the task. */
+    name: string;
+    /**
+     * Prompt line injected ahead of the execution prompt. Absent (or blank
+     * after trimming) keeps the tag display-only: it never touches the prompt,
+     * so a label with no prefix has zero execution side effects.
+     */
+    promptPrefix?: string;
+}
+/** Maximum number of tags carried by one task. */
+export declare const TASK_TAG_LIMIT = 8;
+/** Maximum length of a tag name. */
+export declare const TAG_NAME_MAX_LENGTH = 32;
+/** Maximum length of a tag's injected prompt line. */
+export declare const TAG_PROMPT_MAX_LENGTH = 200;
+/** Whether an unknown value is a well-formed tag (strict: the wire gate). */
+export declare function isTaskTag(value: unknown): value is TaskTag;
+/**
+ * Whether an unknown value is a well-formed tag list (strict: the wire gate).
+ * An empty list is rejected — clearing tags is expressed by omitting the field
+ * (create) or by an explicit null (update), never by an empty array.
+ */
+export declare function isTaskTagList(value: unknown): value is TaskTag[];
+/**
+ * Repair a persisted tag list: keep the well-formed entries, trim, drop
+ * blanks and repeats, cap the count, and collapse a blank prompt line to
+ * "display-only". Returns undefined when nothing usable remains, so the caller
+ * clears the field instead of storing an empty array.
+ */
+export declare function normalizeTags(value: unknown): TaskTag[] | undefined;
+/**
+ * Stable palette slot (0..5) for a tag name. The same label always lands on the
+ * same tone, so a badge needs no stored colour and two tasks sharing a label
+ * cannot disagree about it.
+ */
+export declare function tagTone(name: string): number;
+/**
+ * Union of the labels already carried by `tasks`, first occurrence wins (the
+ * oldest task's hint is the one offered). Feeds the editor's name datalist and
+ * the board's tag filter, so a label defined once can be reused everywhere.
+ */
+export declare function collectKnownTags(tasks: readonly TaskRecord[]): TaskTag[];
 /** One task on the board. */
 export interface TaskRecord {
     /** Stable task id (uuid). */
@@ -145,6 +194,12 @@ export interface TaskRecord {
      * bundle's triplet overrides the legacy pin fields at execution time.
      */
     handover?: TaskHandover;
+    /**
+     * Task labels (issue #1521): optional, additive, and absent on every task
+     * created before the field existed. A tag whose `promptPrefix` is set is
+     * prepended to the execution prompt; a bare name is display and filter only.
+     */
+    tags?: TaskTag[];
     /**
      * Human confirmation stamp for an above-default effective permission
      * (ms epoch). Absent while the binding awaits confirmation; any permission
@@ -208,6 +263,11 @@ export interface NewTaskInput {
      * sanitized by the protocol gate) attached at creation.
      */
     handover?: TaskHandoverInput;
+    /**
+     * Optional task labels. A tag with a non-blank `promptPrefix` is injected
+     * ahead of the execution prompt; a bare name changes nothing at run time.
+     */
+    tags?: TaskTag[];
 }
 /** The five kanban columns, in display order. */
 export declare const COLUMNS: readonly {

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

@@ -8,7 +8,7 @@
  * back to the runtime default); an unknown permission string is ignored so
  * stale UI can never persist a value the execution service rejects.
  */
-import { type TaskRecord } from '../tasks.ts';
+import { type TaskRecord, type TaskTag } from '../tasks.ts';
 import type { FreezeSnapshot } from '../freeze-snapshot.ts';
 import type { TaskHandoverInput } from '../handover.ts';
 /**
@@ -21,6 +21,13 @@ export type TaskUpdatePatch = Partial<Pick<TaskRecord, 'title' | 'description' |
     } | null;
     /** Replaces the handover bundle (restamping bundledAt); an explicit null clears it. */
     handover?: TaskHandoverInput | null;
+    /**
+     * Replaces the task's labels (issue #1521). Unlike the content fields, tags
+     * stay editable after the first run: they classify the task and shape the
+     * NEXT execution prompt, they are not the record of what already ran. An
+     * explicit null (or a list that normalizes to nothing) clears them.
+     */
+    tags?: TaskTag[] | null;
 };
 /** The fields that edit the task's content (what the user reads and what the
  * next execution sends). Unlike the execution targets they stay editable only

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-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.21",
+  "version": "0.3.23",
   "type": "module",
   "main": "lib/index.js",
   "types": "lib/types/index.d.ts",

package/src/client/board/EditTaskModal.tsx

@@ -7,15 +7,16 @@
  */
 import { useState } from 'react'
 import type { BoardController } from '../../core/controller.ts'
-import type { TaskRecord } from '../../core/tasks.ts'
+import { collectKnownTags, type TaskRecord, type TaskTag } from '../../core/tasks.ts'
 import { t } from '../locales.ts'
-import { ModalShell, TaskContentFields } from './TaskForm.tsx'
+import { ModalShell, TaskContentFields, TaskTagFields, cleanTags } from './TaskForm.tsx'
 
 /** Edit-task form overlay. */
 export function EditTaskModal({ controller, task, onClose }: { controller: BoardController; task: TaskRecord; onClose: () => void }) {
   const [title, setTitle] = useState(task.title)
   const [description, setDescription] = useState(task.description)
   const [prompt, setPrompt] = useState(task.prompt)
+  const [tags, setTags] = useState<TaskTag[]>(task.tags ?? [])
   const [error, setError] = useState<string | undefined>(undefined)
   const [pending, setPending] = useState(false)
 
@@ -27,7 +28,17 @@ export function EditTaskModal({ controller, task, onClose }: { controller: Board
     setPending(true)
     // The Host confirms the mutation (and its fail-closed checks); only a
     // confirmed save closes the modal.
-    if (await controller.updateTask(task.id, { title, description, prompt })) {
+    // Labels ride the same patch as the content fields. A task that never
+    // carried one is not sent a clearing null: the wire stays minimal, and the
+    // no-tags path keeps producing exactly the patch it produced before.
+    const tagList = cleanTags(tags)
+    const patch = {
+      title,
+      description,
+      prompt,
+      ...(tagList.length > 0 ? { tags: tagList } : (task.tags === undefined ? {} : { tags: null })),
+    }
+    if (await controller.updateTask(task.id, patch)) {
       onClose()
       return
     }
@@ -53,6 +64,44 @@ export function EditTaskModal({ controller, task, onClose }: { controller: Board
         onDescriptionChange={setDescription}
         onPromptChange={setPrompt}
       />
+
+      <TaskTagFields tags={tags} knownTags={collectKnownTags(controller.getSnapshot().tasks)} onChange={setTags} />
+    </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>
   )
 }
+