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

package/src/client/board/TaskForm.tsx

@@ -5,9 +5,13 @@
  * are controlled components.
  */
 import type { ReactNode } from 'react'
+import { TAG_NAME_MAX_LENGTH, TAG_PROMPT_MAX_LENGTH, TASK_TAG_LIMIT, type TaskTag } from '../../core/tasks.ts'
 import { t } from '../locales.ts'
 import css from '../board.module.css'
 
+/** DOM id shared by the tag-name inputs and their datalist (one board at a time). */
+const TAG_NAME_LIST_ID = 'dsh-task-board-tag-names'
+
 /** Modal overlay: closes on backdrop press, submits through the form. */
 export function ModalShell({
   ariaLabel,
@@ -109,3 +113,91 @@ export function TaskContentFields({
     </>
   )
 }
+
+/**
+ * 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 function TaskTagFields({
+  tags,
+  knownTags,
+  onChange,
+}: {
+  tags: TaskTag[]
+  /** Labels already carried elsewhere on the board. */
+  knownTags: TaskTag[]
+  onChange: (tags: TaskTag[]) => void
+}) {
+  const update = (index: number, patch: Partial<TaskTag>): void => {
+    onChange(tags.map((tag, position) => (position === index ? { ...tag, ...patch } : tag)))
+  }
+
+  return (
+    <div className={css.field}>
+      <span className={css.fieldLabel}>{t('new.tags')}</span>
+      <span className={css.fieldHint}>{t('new.tagsHint')}</span>
+      {tags.map((tag, index) => (
+        <div className={css.tagRow} key={index}>
+          <input
+            className={css.input}
+            list={TAG_NAME_LIST_ID}
+            value={tag.name}
+            maxLength={TAG_NAME_MAX_LENGTH}
+            placeholder={t('new.tagNamePlaceholder')}
+            aria-label={t('new.tagName')}
+            onChange={(event) => {
+              const name = event.target.value
+              const known = knownTags.find(candidate => candidate.name === name)
+              const adoptsHint = known?.promptPrefix !== undefined && (tag.promptPrefix ?? '').trim() === ''
+              update(index, adoptsHint ? { name, promptPrefix: known.promptPrefix } : { name })
+            }}
+          />
+          <input
+            className={css.input}
+            value={tag.promptPrefix ?? ''}
+            maxLength={TAG_PROMPT_MAX_LENGTH}
+            placeholder={t('new.tagPromptPlaceholder')}
+            aria-label={t('new.tagPrompt')}
+            onChange={event => { update(index, { promptPrefix: event.target.value }) }}
+          />
+          <button
+            type="button"
+            className={css.ghostButton}
+            aria-label={t('new.tagRemove', { name: tag.name })}
+            onClick={() => { onChange(tags.filter((_, position) => position !== index)) }}
+          >
+            ×
+          </button>
+        </div>
+      ))}
+      <datalist id={TAG_NAME_LIST_ID}>
+        {knownTags.map(tag => <option key={tag.name} value={tag.name} />)}
+      </datalist>
+      <button
+        type="button"
+        className={css.ghostButton + ' ' + css.tagAddButton}
+        disabled={tags.length >= TASK_TAG_LIMIT}
+        onClick={() => { onChange([...tags, { name: '' }]) }}
+      >
+        + {t('new.tagAdd')}
+      </button>
+    </div>
+  )
+}
+
+/**
+ * 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).
+ */
+export function cleanTags(tags: readonly TaskTag[]): TaskTag[] {
+  const cleaned: TaskTag[] = []
+  for (const tag of tags) {
+    const name = tag.name.trim()
+    if (name === '') continue
+    const promptPrefix = tag.promptPrefix?.trim()
+    cleaned.push(promptPrefix === undefined || promptPrefix === '' ? { name } : { name, promptPrefix })
+  }
+  return cleaned
+}

package/src/client/board.module.css

@@ -1121,3 +1121,122 @@ html[data-dsh-taskboard-active]:not([data-dsh-ssh-active]) [class*='centerCol']
     animation: none;
   }
 }
+
+/* --- task tags (issue #1521) ---------------------------------------------------
+ * A badge takes its tone from a fixed six-colour palette chosen by hashing the
+ * name, so one label always paints the same way and nothing per-tag has to be
+ * stored. The fill is translucent and the text keeps the theme's own primary
+ * label colour, so badges stay readable on light, dark, and every skin without
+ * depending on a token a skin may not define.
+ * ----------------------------------------------------------------------------- */
+
+.cardTags {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 4px;
+}
+
+.cardTag {
+  max-width: 100%;
+  padding: 0 7px;
+  overflow: hidden;
+  border: 1px solid var(--dsh-task-tag-border);
+  border-radius: 999px;
+  background: var(--dsh-task-tag-fill);
+  color: var(--dsw-alias-label-primary);
+  font-size: 10px;
+  line-height: 16px;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.tagFilter {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: 6px;
+  margin: 0 0 10px;
+}
+
+.tagFilterLabel {
+  color: var(--dsw-alias-label-tertiary);
+  font-size: 11px;
+}
+
+.tagChip {
+  padding: 1px 9px;
+  border: 1px solid var(--dsh-task-tag-border);
+  border-radius: 999px;
+  background: transparent;
+  color: var(--dsw-alias-label-secondary);
+  cursor: pointer;
+  font-family: inherit;
+  font-size: 11px;
+  line-height: 18px;
+}
+
+.tagChip[data-active='true'] {
+  background: var(--dsh-task-tag-fill);
+  color: var(--dsw-alias-label-primary);
+}
+
+.cardTag[data-tag-tone='0'],
+.tagChip[data-tag-tone='0'] {
+  --dsh-task-tag-fill: #4e93e82e;
+  --dsh-task-tag-border: #4e93e866;
+}
+
+.cardTag[data-tag-tone='1'],
+.tagChip[data-tag-tone='1'] {
+  --dsh-task-tag-fill: #2ea36a2e;
+  --dsh-task-tag-border: #2ea36a66;
+}
+
+.cardTag[data-tag-tone='2'],
+.tagChip[data-tag-tone='2'] {
+  --dsh-task-tag-fill: #d08a2a2e;
+  --dsh-task-tag-border: #d08a2a66;
+}
+
+.cardTag[data-tag-tone='3'],
+.tagChip[data-tag-tone='3'] {
+  --dsh-task-tag-fill: #b456c82e;
+  --dsh-task-tag-border: #b456c866;
+}
+
+.cardTag[data-tag-tone='4'],
+.tagChip[data-tag-tone='4'] {
+  --dsh-task-tag-fill: #cf5f7a2e;
+  --dsh-task-tag-border: #cf5f7a66;
+}
+
+.cardTag[data-tag-tone='5'],
+.tagChip[data-tag-tone='5'] {
+  --dsh-task-tag-fill: #4a9fb52e;
+  --dsh-task-tag-border: #4a9fb566;
+}
+
+.fieldHint {
+  color: var(--dsw-alias-label-tertiary);
+  font-size: 11px;
+  line-height: 1.4;
+}
+
+.tagRow {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+}
+
+.tagRow .input {
+  flex: 1 1 0;
+  min-width: 0;
+}
+
+.tagRow .ghostButton {
+  flex: none;
+}
+
+.tagAddButton {
+  align-self: flex-start;
+}

package/src/client/locales.ts

@@ -55,6 +55,17 @@ export const zh = {
   'detail.handover': '交接包',
   'detail.handover.bundledAt': '打包于 {time}',
   'detail.handover.references': '引用',
+  'new.tags': '标签（可选）',
+  'new.tagsHint': '标签用于卡片徽章与顶栏筛选；填了「执行提示」的行会在每次执行前注入 Prompt，留空则只作展示。',
+  'new.tagName': '标签名',
+  'new.tagNamePlaceholder': '例如：工作',
+  'new.tagPrompt': '执行提示（可选）',
+  'new.tagPromptPlaceholder': '例如：产物归档到 02-工作/',
+  'new.tagAdd': '添加标签',
+  'new.tagRemove': '移除标签 {name}',
+  'board.tagFilter': '按标签筛选',
+  'board.tagFilterClear': '清除标签筛选',
+  'board.tagEmpty': '没有同时带这些标签的任务',
   'detail.permissionPending': '权限待确认：本卡有效权限（{permission}）高于会话默认，手动执行与定时调度都会被拒绝，需人工确认后才能运行。',
   'detail.permissionConfirm': '确认权限绑定',
   'detail.permissionConfirmed': '已确认权限绑定 · {time}',
@@ -209,6 +220,17 @@ export const en: Record<keyof typeof zh, string> = {
   'detail.handover': 'Handover bundle',
   'detail.handover.bundledAt': 'Bundled at {time}',
   'detail.handover.references': 'References',
+  'new.tags': 'Tags (optional)',
+  'new.tagsHint': 'Tags drive the card badges and the board filter; a row with an execution hint is injected ahead of the prompt on every run, an empty one is display-only.',
+  'new.tagName': 'Tag name',
+  'new.tagNamePlaceholder': 'e.g. Work',
+  'new.tagPrompt': 'Execution hint (optional)',
+  'new.tagPromptPlaceholder': 'e.g. Archive artefacts under 02-work/',
+  'new.tagAdd': 'Add tag',
+  'new.tagRemove': 'Remove tag {name}',
+  'board.tagFilter': 'Filter by tag',
+  'board.tagFilterClear': 'Clear tag filter',
+  'board.tagEmpty': 'No task carries all of these tags',
   'detail.permissionPending': 'Permission pending confirmation: this card\'s effective permission ({permission}) is above the session default; manual runs and cron are refused until a human confirms.',
   'detail.permissionConfirm': 'Confirm permission binding',
   'detail.permissionConfirmed': 'Permission confirmed · {time}',

package/src/core/store.ts

@@ -10,7 +10,7 @@
  * localStorage backend.
  */
 import { isValidCron } from './schedule.ts'
-import { isTaskPermission, isTaskStatus, normalizeTargetId, type ScheduleRule, type TaskFreeze, type TaskRecord, type TaskPermission, type TaskStatus } from './tasks.ts'
+import { isTaskPermission, isTaskStatus, normalizeTags, normalizeTargetId, type ScheduleRule, type TaskFreeze, type TaskRecord, type TaskPermission, type TaskStatus } from './tasks.ts'
 import type { TaskHandover } from './handover.ts'
 import { sanitizeFreezeSnapshot } from './freeze-snapshot.ts'
 import { sanitizeHandover } from './handover.ts'
@@ -189,6 +189,10 @@ export function parseLedger(raw: string | null): TaskRecord[] {
     task.reuseSession = row.reuseSession === true ? true : undefined
     task.freeze = normalizeFreeze(row.freeze)
     task.handover = normalizeHandover(row.handover)
+    // Tags are repaired field by field like the schedule: a malformed entry is
+    // dropped, and a list that repairs to nothing clears the field instead of
+    // dropping the task row.
+    task.tags = normalizeTags(row.tags)
     task.permissionConfirmedAt = typeof row.permissionConfirmedAt === 'number' && Number.isFinite(row.permissionConfirmedAt) ? row.permissionConfirmedAt : undefined
     tasks.push(task)
   }

package/src/core/tasks.ts

@@ -94,6 +94,105 @@ 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 const TASK_TAG_LIMIT = 8
+/** Maximum length of a tag name. */
+export const TAG_NAME_MAX_LENGTH = 32
+/** Maximum length of a tag's injected prompt line. */
+export const TAG_PROMPT_MAX_LENGTH = 200
+
+/** Whether an unknown value is a well-formed tag (strict: the wire gate). */
+export function isTaskTag(value: unknown): value is TaskTag {
+  if (typeof value !== 'object' || value === null || Array.isArray(value)) return false
+  const tag = value as Record<string, unknown>
+  if (Object.keys(tag).some(key => key !== 'name' && key !== 'promptPrefix')) return false
+  if (typeof tag.name !== 'string') return false
+  const name = tag.name.trim()
+  if (name === '' || name.length > TAG_NAME_MAX_LENGTH) return false
+  if (tag.promptPrefix !== undefined && typeof tag.promptPrefix !== 'string') return false
+  return tag.promptPrefix === undefined || (tag.promptPrefix as string).trim().length <= TAG_PROMPT_MAX_LENGTH
+}
+
+/**
+ * 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 function isTaskTagList(value: unknown): value is TaskTag[] {
+  return Array.isArray(value) && value.length > 0 && value.length <= TASK_TAG_LIMIT && value.every(isTaskTag)
+}
+
+/**
+ * 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 function normalizeTags(value: unknown): TaskTag[] | undefined {
+  if (!Array.isArray(value)) return undefined
+  const tags: TaskTag[] = []
+  const seen = new Set<string>()
+  for (const entry of value) {
+    if (typeof entry !== 'object' || entry === null || Array.isArray(entry)) continue
+    const row = entry as Record<string, unknown>
+    if (typeof row.name !== 'string') continue
+    const name = row.name.trim()
+    if (name === '' || name.length > TAG_NAME_MAX_LENGTH || seen.has(name)) continue
+    const raw = typeof row.promptPrefix === 'string' ? row.promptPrefix.trim() : ''
+    const promptPrefix = raw === '' ? undefined : raw.slice(0, TAG_PROMPT_MAX_LENGTH)
+    seen.add(name)
+    tags.push(promptPrefix === undefined ? { name } : { name, promptPrefix })
+    if (tags.length >= TASK_TAG_LIMIT) break
+  }
+  return tags.length === 0 ? undefined : tags
+}
+
+/**
+ * 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 function tagTone(name: string): number {
+  let hash = 0
+  for (const char of name) hash = (hash * 31 + (char.codePointAt(0) ?? 0)) >>> 0
+  return hash % 6
+}
+
+/**
+ * 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 function collectKnownTags(tasks: readonly TaskRecord[]): TaskTag[] {
+  const known: TaskTag[] = []
+  const seen = new Set<string>()
+  for (const task of tasks) {
+    for (const tag of task.tags ?? []) {
+      if (seen.has(tag.name)) continue
+      seen.add(tag.name)
+      known.push(tag)
+    }
+  }
+  return known
+}
+
 /** One task on the board. */
 export interface TaskRecord {
   /** Stable task id (uuid). */
@@ -158,6 +257,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
@@ -223,6 +328,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. */
@@ -281,6 +391,7 @@ export function freezeOf(
 
 /** Create a task from user input. */
 export function createTask(input: NewTaskInput, now: number, id: string): TaskRecord {
+  const tags = normalizeTags(input.tags)
   return {
     id,
     title: input.title.trim(),
@@ -297,6 +408,7 @@ export function createTask(input: NewTaskInput, now: number, id: string): TaskRe
     reuseSession: input.reuseSession === true ? true : undefined,
     ...(input.freeze === undefined ? {} : { freeze: freezeOf(input.freeze, now) }),
     ...(input.handover === undefined ? {} : { handover: { ...input.handover, bundledAt: now } }),
+    ...(tags === undefined ? {} : { tags }),
   }
 }
 

package/src/core/use-cases/task-update.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 { freezeOf, isTaskPermission, normalizeTargetId, type TaskRecord, type TaskPermission } from '../tasks.ts'
+import { freezeOf, isTaskPermission, normalizeTags, normalizeTargetId, type TaskRecord, type TaskPermission, type TaskTag } from '../tasks.ts'
 import type { FreezeSnapshot } from '../freeze-snapshot.ts'
 import type { TaskHandoverInput } from '../handover.ts'
 
@@ -20,6 +20,13 @@ export type TaskUpdatePatch = Partial<Pick<TaskRecord, 'title' | 'description' |
   freeze?: FreezeSnapshot & { redacted?: boolean } | 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
@@ -68,7 +75,7 @@ export function applyUpdateTask(
 ): readonly TaskRecord[] {
   return tasks.map(task => {
     if (task.id !== id) return task
-    const { freeze: freezePatch, handover: handoverPatch, ...rest } = patch
+    const { freeze: freezePatch, handover: handoverPatch, tags: tagsPatch, ...rest } = patch
     const workspaceId = 'workspaceId' in patch ? normalizeTargetId(patch.workspaceId) : undefined
     const mode = 'mode' in patch ? normalizeTargetId(patch.mode) : undefined
     const permission = 'permission' in patch ? normalizePermission(task.permission, patch.permission) : undefined
@@ -86,6 +93,9 @@ export function applyUpdateTask(
     next.freeze = freezePatch == null ? undefined : freezeOf(freezePatch, now)
     // Handover follows the same null-clears convention, restamping bundledAt.
     next.handover = handoverPatch == null ? undefined : { ...handoverPatch, bundledAt: now }
+    // Tags use the same convention: a present array replaces the set (after
+    // repair), an explicit null or a fully-invalid list clears it.
+    if ('tags' in patch) next.tags = tagsPatch == null ? undefined : normalizeTags(tagsPatch)
     // The permission confirmation binds the exact permission value: a change
     // of the pinned permission or of the handover bundle re-arms the gate
     // (blocking confirm-then-swap escalation). handover was destructured out

package/src/host-runner.ts

@@ -110,9 +110,15 @@ function escapeProvenanceDelimiter(value: string): string {
 export function promptText(task: TaskRecord): string {
   const body = task.prompt !== '' ? task.prompt : task.title
   const handover = task.handover
-  const preamble = handover === undefined || handover.references.length === 0
+  const handoverPreamble = handover === undefined || handover.references.length === 0
     ? undefined
     : `交接包引用（来自任务看板续接卡片，冻结于 ${new Date(handover.bundledAt).toISOString()}）：\n${handover.references.map(reference => `- ${reference}`).join('\n')}`
+  // Tag prompts come first: they are the run's standing context (business line,
+  // output location), the handover preamble is a per-card note, and the task
+  // body is the instruction itself.
+  const tagPreamble = tagPromptPreamble(task)
+  const preambles = [tagPreamble, handoverPreamble].filter((part): part is string => part !== undefined)
+  const preamble = preambles.length === 0 ? undefined : preambles.join('\n\n')
   const freeze = task.freeze
   if (freeze === undefined) {
     return preamble === undefined ? body : `${preamble}\n\n${body}`
@@ -122,6 +128,23 @@ export function promptText(task: TaskRecord): string {
   return preamble === undefined ? declaration : `${preamble}\n\n${declaration}`
 }
 
+/**
+ * Build the tag section of the execution prompt (issue #1521). Only tags with
+ * a non-blank `promptPrefix` contribute; a task whose tags are all bare names
+ * (or which has no tags at all) yields undefined and the prompt is byte-for-byte
+ * what it was before the feature.
+ */
+function tagPromptPreamble(task: TaskRecord): string | undefined {
+  const lines: string[] = []
+  for (const tag of task.tags ?? []) {
+    const prefix = tag.promptPrefix?.trim()
+    if (prefix === undefined || prefix === '') continue
+    lines.push(`- [${tag.name}] ${escapeProvenanceDelimiter(prefix)}`)
+  }
+  if (lines.length === 0) return undefined
+  return `标签提示（任务看板标签，每次执行前注入）：\n${lines.join('\n')}`
+}
+
 function isErrorTurnEnd(data: unknown): boolean {
   if (typeof data !== 'object' || data === null) return false
   const reason = (data as { reason?: unknown }).reason

package/src/protocol.ts

@@ -1,5 +1,5 @@
 import type { TaskUpdatePatch } from './core/use-cases/task-update.ts'
-import { isTaskPermission, isTaskStatus, type NewTaskInput, type TaskPermission, type TaskRecord, type TaskStatus } from './core/tasks.ts'
+import { isTaskPermission, isTaskStatus, isTaskTagList, type NewTaskInput, type TaskPermission, type TaskRecord, type TaskStatus } from './core/tasks.ts'
 import { parseLedger } from './core/store.ts'
 import { sanitizeFreezeSnapshot, type FreezeSnapshot } from './core/freeze-snapshot.ts'
 import { sanitizeHandover, type TaskHandoverInput } from './core/handover.ts'
@@ -101,6 +101,10 @@ function optionalFiniteNumber(value: unknown): boolean {
 }
 
 function validImportedKnownFields(value: Record<string, unknown>): boolean {
+  // Tags are validated (not repaired) on the import path: an imported task
+  // must carry a well-formed list or none at all, so a hand-edited export
+  // cannot smuggle a malformed tag past the gate.
+  if (value.tags !== undefined && !isTaskTagList(value.tags)) return false
   if (value.schedule !== undefined) {
     const schedule = record(value.schedule)
     if (schedule === undefined || typeof schedule.enabled !== 'boolean' || typeof schedule.cron !== 'string') return false
@@ -161,6 +165,7 @@ function importedTask(value: unknown): TaskRecord | undefined {
     ...(task.archivedAt === undefined ? {} : { archivedAt: task.archivedAt }),
     ...(task.freeze === undefined ? {} : { freeze: task.freeze }),
     ...(task.handover === undefined ? {} : { handover: task.handover }),
+    ...(task.tags === undefined ? {} : { tags: task.tags }),
     // 安全门（对抗场景 b）：import 不是人工确认动作，确认戳一律剥除——
     // 高于会话默认权限的绑定经 import 进入后必须重新武装 confirm-permission 门。
   }
@@ -194,11 +199,12 @@ function handoverPayload(value: unknown): TaskHandoverInput | undefined {
 
 function createInput(value: unknown): value is NewTaskInput {
   const input = record(value)
-  if (input === undefined || !exactKeys(input, ['title', 'description', 'prompt', 'workspaceId', 'mode', 'permission', 'schedule', 'freeze', 'handover', 'model', 'reuseSession'])) return false
+  if (input === undefined || !exactKeys(input, ['title', 'description', 'prompt', 'workspaceId', 'mode', 'permission', 'schedule', 'freeze', 'handover', 'model', 'reuseSession', 'tags'])) return false
   if (typeof input.title !== 'string' || typeof input.description !== 'string' || typeof input.prompt !== 'string') return false
   if (!optionalString(input.workspaceId) || !optionalString(input.mode) || !optionalString(input.model)) return false
   if (input.reuseSession !== undefined && typeof input.reuseSession !== 'boolean') return false
   if (input.permission !== undefined && !isTaskPermission(input.permission)) return false
+  if (input.tags !== undefined && !isTaskTagList(input.tags)) return false
   if (input.freeze !== undefined && freezePayload(input.freeze) === undefined) return false
   if (input.handover !== undefined && handoverPayload(input.handover) === undefined) return false
   if (input.schedule !== undefined) {
@@ -211,13 +217,15 @@ function createInput(value: unknown): value is NewTaskInput {
 
 function updatePatch(value: unknown): boolean {
   const patch = record(value)
-  if (patch === undefined || !exactKeys(patch, ['title', 'description', 'prompt', 'workspaceId', 'mode', 'permission', 'freeze', 'handover', 'model', 'reuseSession'])) return false
+  if (patch === undefined || !exactKeys(patch, ['title', 'description', 'prompt', 'workspaceId', 'mode', 'permission', 'freeze', 'handover', 'model', 'reuseSession', 'tags'])) return false
   // null (or false) clears the reuse opt-in; only a real boolean is accepted.
   if (patch.reuseSession !== undefined && patch.reuseSession !== null && typeof patch.reuseSession !== 'boolean') return false
   for (const key of ['title', 'description', 'prompt', 'workspaceId', 'mode', 'model'] as const) {
     if (!optionalString(patch[key])) return false
   }
   if (patch.permission !== undefined && !isTaskPermission(patch.permission)) return false
+  // null clears the label set; a present array must be a well-formed list.
+  if (patch.tags !== undefined && patch.tags !== null && !isTaskTagList(patch.tags)) return false
   // null clears the snapshot; an object must pass the freeze gate.
   if (patch.freeze !== undefined && patch.freeze !== null && freezePayload(patch.freeze) === undefined) return false
   // Same convention for the handover bundle.