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

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-ai.ts

@@ -0,0 +1,152 @@
+/**
+ * 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 { createUserMessage, type GenerateOptions, 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 const TASK_PARSE_TIMEOUT_MS = 45_000
+/** Largest pasted text one parse accepts (bytes). */
+export const TASK_PARSE_MAX_INPUT = 16 * 1024
+/** Longest title the form is willing to receive from a model. */
+const TASK_PARSE_TITLE_LIMIT = 120
+
+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 class TaskParseError extends Error {
+  constructor(readonly code: TaskParseFailureCode, message: string) {
+    super(message)
+    this.name = 'TaskParseError'
+  }
+}
+
+const SYSTEM_PROMPT = [
+  'You turn one pasted note into a task for a kanban board.',
+  'Reply with a single JSON object and nothing else, with exactly these keys:',
+  '{"title": string, "description": string, "prompt": string}',
+  '- title: one line, at most 80 characters, in the language of the note.',
+  '- description: what the task is and the context the note carries, as plain text.',
+  '- prompt: the instruction an agent should execute, keeping every fact that matters.',
+].join('\n')
+
+/** Split a qualified `provider/model` route the same way the runner does. */
+export function splitModelRoute(qualified: string | undefined): { provider: string; model: string } | undefined {
+  const raw = qualified?.trim() ?? ''
+  if (raw === '') return undefined
+  const slash = raw.indexOf('/')
+  if (slash <= 0 || slash === raw.length - 1) return undefined
+  const provider = raw.slice(0, slash).trim()
+  const model = raw.slice(slash + 1).trim()
+  if (provider === '' || model === '') return undefined
+  return { provider, model }
+}
+
+/** Trim one model-provided field to a single-line, bounded string. */
+function field(value: unknown, limit?: number): string {
+  if (typeof value !== 'string') return ''
+  const text = value.trim()
+  return limit === undefined || text.length <= limit ? text : text.slice(0, limit).trim()
+}
+
+/** First non-empty line of the pasted text, used when the model omits a title. */
+function firstLine(source: string): string {
+  const line = source.split(/\r?\n/).map(entry => entry.trim()).find(entry => entry !== '') ?? ''
+  return line.length <= TASK_PARSE_TITLE_LIMIT ? line : line.slice(0, TASK_PARSE_TITLE_LIMIT).trim()
+}
+
+/**
+ * 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 function extractTaskParseReply(reply: string): Partial<TaskBoardParseDraft> | undefined {
+  const withoutFences = reply.replace(/```[a-zA-Z]*\s*/g, '')
+  const start = withoutFences.indexOf('{')
+  const end = withoutFences.lastIndexOf('}')
+  if (start === -1 || end <= start) return undefined
+  let payload: unknown
+  try {
+    payload = JSON.parse(withoutFences.slice(start, end + 1))
+  } catch {
+    return undefined
+  }
+  if (typeof payload !== 'object' || payload === null) return undefined
+  const record = payload as { title?: unknown; description?: unknown; prompt?: string }
+  const draft: Partial<TaskBoardParseDraft> = {
+    title: field(record.title, TASK_PARSE_TITLE_LIMIT),
+    description: field(record.description),
+    prompt: field(record.prompt),
+  }
+  return draft.title === '' && draft.description === '' && draft.prompt === '' ? undefined : draft
+}
+
+/**
+ * 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 function draftFromReply(reply: string, source: string): TaskBoardParseDraft {
+  const parsed = extractTaskParseReply(reply)
+  return {
+    title: parsed?.title !== undefined && parsed.title !== '' ? parsed.title : firstLine(source),
+    description: parsed?.description ?? '',
+    prompt: parsed?.prompt !== undefined && parsed.prompt !== '' ? parsed.prompt : source.trim(),
+  }
+}
+
+/**
+ * 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 async function parseTaskDraft(
+  llm: LlmRuntime,
+  request: TaskBoardParseRequest,
+  signal?: AbortSignal,
+): Promise<TaskBoardParseDraft> {
+  const text = request.text.trim()
+  if (text === '') throw new TaskParseError('parse-failed', 'there is nothing to parse')
+  const route = splitModelRoute(request.model)
+  if (route === undefined) throw new TaskParseError('no-model', 'no model route was selected for parsing')
+  const timeout = new AbortController()
+  const timer = setTimeout(() => { timeout.abort() }, TASK_PARSE_TIMEOUT_MS)
+  const abortFromCaller = (): void => { timeout.abort() }
+  signal?.addEventListener('abort', abortFromCaller, { once: true })
+  try {
+    const options: GenerateOptions = {
+      provider: route.provider,
+      model: route.model,
+      system: SYSTEM_PROMPT,
+      messages: [createUserMessage({ content: [{ type: 'text', text }], source: { kind: 'user' } })],
+      signal: timeout.signal,
+    }
+    let reply = ''
+    for await (const chunk of llm.stream(options)) {
+      if (chunk.type === 'text-delta') reply += chunk.text
+    }
+    return draftFromReply(reply, text)
+  } catch (error) {
+    if (error instanceof TaskParseError) throw error
+    if (timeout.signal.aborted) {
+      throw new TaskParseError('timeout', `the model did not answer within ${TASK_PARSE_TIMEOUT_MS / 1_000}s`)
+    }
+    throw new TaskParseError('model-error', error instanceof Error ? error.message : String(error))
+  } finally {
+    clearTimeout(timer)
+    signal?.removeEventListener('abort', abortFromCaller)
+  }
+}

package/src/host-ledger.ts

@@ -216,6 +216,16 @@ function ownProcessStartTimeMs(): number | undefined {
  */
 const LEGACY_START_TOLERANCE_MS = 2000
 
+/**
+ * How long an unreadable lock must sit untouched before it may be reclaimed.
+ * The owner writes and fsyncs its record immediately after creating the file
+ * with O_EXCL, so a lock that cannot be parsed may still be mid-write by a
+ * live owner; only one that has been unreadable for longer than any write can
+ * take is treated as an unclean-shutdown leftover (issue #1528: a 0-byte lock
+ * kept the Host half from mounting until it was deleted by hand).
+ */
+const UNREADABLE_LOCK_GRACE_MS = 60_000
+
 /** Whether the recorded start time proves the recorded PID is another process. */
 function startTimeMismatch(recorded: number, actual: number, exact: boolean): boolean {
   return exact ? recorded !== actual : Math.abs(recorded - actual) > LEGACY_START_TOLERANCE_MS
@@ -842,9 +852,21 @@ export class HostTaskLedger {
           if (typeof owner.startedAt === 'number') ownerStartedAt = owner.startedAt
           ownerExact = owner.probe === 'exact'
         } catch {
-          // A power-loss mid-write can leave a truncated lock; the same event
-          // killed the writer, so fail closed but explain the recovery.
-          throw new Error(`task-board ledger lock is unreadable: ${this.lockFile}; if this is a leftover from an unclean shutdown and no other DSH host is running, remove it manually and retry`)
+          // A power-loss mid-write can leave an empty or truncated lock. Such a
+          // lock still fails closed while it is fresh (a live owner may be
+          // mid-write); once it is older than the grace window nothing can be
+          // writing it, so the leftover is reclaimed instead of blocking every
+          // later start until someone deletes it by hand (issue #1528).
+          const age = (() => {
+            try { return this.now() - statSync(this.lockFile).mtimeMs } catch { return Number.POSITIVE_INFINITY }
+          })()
+          if (age < UNREADABLE_LOCK_GRACE_MS) {
+            throw new Error(`task-board ledger lock is unreadable: ${this.lockFile}; if this is a leftover from an unclean shutdown and no other DSH host is running, remove it manually and retry`)
+          }
+          try { unlinkSync(this.lockFile) } catch (unlinkError) {
+            if ((unlinkError as NodeJS.ErrnoException).code !== 'ENOENT') throw unlinkError
+          }
+          continue
         }
         if (pid !== undefined && processIsAlive(pid)) {
           const actualStartedAt = pid === process.pid ? ownProcessStartTimeMs() : processStartTimeMs(pid)

package/src/host-routes.ts

@@ -4,7 +4,14 @@ import type { WebRoute } from '@deepseek-ai/dsh-host-webserver'
 import type { TaskBoardHostService } from './host-service.ts'
 import { writeJson } from './http.ts'
 import { isLoopbackAddress, isLoopbackRequest } from './loopback.ts'
-import { parseActionEnvelope, TASK_BOARD_API_PREFIX } from './protocol.ts'
+import { TaskParseError, TASK_PARSE_MAX_INPUT } from './host-ai.ts'
+import {
+  parseActionEnvelope,
+  parseTaskParseRequest,
+  TASK_BOARD_API_PREFIX,
+  type TaskBoardParseDraft,
+  type TaskBoardParseRequest,
+} from './protocol.ts'
 
 const ACTION_LIMIT = 64 * 1024
 const IMPORT_LIMIT = 2 * 1024 * 1024
@@ -19,6 +26,16 @@ export interface TaskBoardRouteAccess {
   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
@@ -119,7 +136,11 @@ async function readBody(req: IncomingMessage): Promise<{ raw: string; value: unk
   return { raw, value: JSON.parse(raw) }
 }
 
-export function makeTaskBoardRoutes(service: TaskBoardHostService, access: TaskBoardRouteAccess = {}): WebRoute[] {
+export function makeTaskBoardRoutes(
+  service: TaskBoardHostService,
+  access: TaskBoardRouteAccess = {},
+  options: TaskBoardRouteOptions = {},
+): WebRoute[] {
   const resolvedAccess = resolveAccess(access)
   const guard = (req: IncomingMessage, res: ServerResponse): boolean => {
     if (isTrustedTaskBoardRequest(req, resolvedAccess)) return true
@@ -188,5 +209,49 @@ export function makeTaskBoardRoutes(service: TaskBoardHostService, access: TaskB
       push()
     },
   }
-  return [state, action, events]
+  const parse: WebRoute = {
+    kind: 'exact',
+    path: `${TASK_BOARD_API_PREFIX}/parse`,
+    handler: async (req, res): Promise<void> => {
+      if (req.method !== 'POST') return writeJson(res, 405, { ok: false, error: 'method-not-allowed' }, { 'cache-control': 'no-store' })
+      if (!guard(req, res)) return
+      if (!(req.headers['content-type'] ?? '').toLowerCase().startsWith('application/json')) {
+        return writeJson(res, 415, { ok: false, error: 'json-required' }, { 'cache-control': 'no-store' })
+      }
+      let body: { raw: string; value: unknown }
+      try {
+        body = await readBody(req)
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error)
+        return writeJson(res, message === 'body-too-large' ? 413 : 400, { ok: false, error: message }, { 'cache-control': 'no-store' })
+      }
+      const request = parseTaskParseRequest(body.value)
+      if (request === undefined) return writeJson(res, 400, { ok: false, error: 'invalid-parse-request' }, { 'cache-control': 'no-store' })
+      if (Buffer.byteLength(request.text, 'utf8') > TASK_PARSE_MAX_INPUT) {
+        return writeJson(res, 413, { ok: false, error: 'text-too-large' }, { 'cache-control': 'no-store' })
+      }
+      const parseTask = options.parseTask
+      if (parseTask === undefined) {
+        return writeJson(res, 503, { ok: false, code: 'no-model', error: 'task-board parsing is unavailable' }, { 'cache-control': 'no-store' })
+      }
+      // The model call outlives a closed tab: stop it when the response goes
+      // away instead of holding the provider request open for the full timeout.
+      const controller = new AbortController()
+      const onClose = (): void => { controller.abort() }
+      res.once('close', onClose)
+      try {
+        const draft = await parseTask(request, controller.signal)
+        writeJson(res, 200, { ok: true, draft }, { 'cache-control': 'no-store' })
+      } catch (error) {
+        const failure = error instanceof TaskParseError
+          ? error
+          : new TaskParseError('model-error', error instanceof Error ? error.message : String(error))
+        const status = failure.code === 'no-model' ? 503 : failure.code === 'timeout' ? 504 : 502
+        writeJson(res, status, { ok: false, code: failure.code, error: failure.message }, { 'cache-control': 'no-store' })
+      } finally {
+        res.off('close', onClose)
+      }
+    },
+  }
+  return [state, action, events, parse]
 }

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/index.ts

@@ -15,7 +15,9 @@ import type {} from '@deepseek-ai/dsh-system-prompt'
 import type {} from '@deepseek-ai/dsh-api-gateway'
 import type {} from '@deepseek-ai/dsh-workspace'
 import type {} from '@deepseek-ai/dsh-host-webserver'
+import type { LlmRuntime } from '@deepseek-ai/dsh-llm'
 import { TaskBoardHostService } from './host-service.ts'
+import { parseTaskDraft, TaskParseError } from './host-ai.ts'
 import { TASK_PERMISSIONS, type TaskPermission } from './core/tasks.ts'
 import { DEFAULT_SESSION_PERMISSION } from './core/handover.ts'
 import { makeTaskBoardRoutes } from './host-routes.ts'
@@ -88,6 +90,22 @@ export function resolveProxyAccess(config: Config | undefined, env: NodeJS.Proce
 /** Schema default, re-read for hand-built test contexts (the loader applies them normally). */
 const DEFAULT_ANNOUNCE = false
 
+/**
+ * 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 function resolveLlmRuntime(ctx: Context): LlmRuntime | undefined {
+  try {
+    const llm = ctx.get('llm') as LlmRuntime | undefined
+    return llm !== undefined && typeof (llm as { stream?: unknown }).stream === 'function' ? llm : undefined
+  } catch {
+    return undefined
+  }
+}
+
 /**
  * Register the board's announcement section, gated on the composition entry's
  * `announceToAgent` (and the live settings value once the web settings
@@ -115,7 +133,14 @@ function applyImpl(ctx: Context, config?: Config): void {
   ctx.effect(() => {
     const disposers: Array<() => void> = []
     try {
-      for (const route of makeTaskBoardRoutes(host, resolveProxyAccess(config))) disposers.push(ctx.webServer.register(route))
+      const routes = makeTaskBoardRoutes(host, resolveProxyAccess(config), {
+        parseTask: async (request, signal) => {
+          const llm = resolveLlmRuntime(ctx)
+          if (llm === undefined) throw new TaskParseError('no-model', 'this deployment serves no llm service')
+          return await parseTaskDraft(llm, request, signal)
+        },
+      })
+      for (const route of routes) disposers.push(ctx.webServer.register(route))
     } catch (error) {
       for (const dispose of disposers) dispose()
       host.dispose()

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'
@@ -49,6 +49,40 @@ export interface TaskBoardEventPayload {
   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 function parseTaskParseRequest(value: unknown): TaskBoardParseRequest | undefined {
+  if (typeof value !== 'object' || value === null) return undefined
+  const record = value as { text?: unknown; model?: unknown }
+  if (typeof record.text !== 'string' || record.text.trim() === '') return undefined
+  if (record.model !== undefined && typeof record.model !== 'string') return undefined
+  const model = typeof record.model === 'string' ? record.model.trim() : ''
+  return { text: record.text, ...(model === '' ? {} : { model }) }
+}
+
+/** Whether a decoded reply carries the three draft strings the form accepts. */
+export function isTaskParseDraft(value: unknown): value is TaskBoardParseDraft {
+  if (typeof value !== 'object' || value === null) return false
+  const record = value as { title?: unknown; description?: unknown; prompt?: unknown }
+  return typeof record.title === 'string' && typeof record.description === 'string' && typeof record.prompt === 'string'
+}
+
 export type TaskBoardAction =
   | { kind: 'import'; sourceId: string; tasks: TaskRecord[] }
   | { kind: 'create'; id: string; input: NewTaskInput }
@@ -101,6 +135,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 +199,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 +233,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 +251,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.