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

package/src/core/controller.ts

@@ -18,7 +18,13 @@ import { applyCreateTask } from './use-cases/task-create.ts'
 import { applyDeleteTask } from './use-cases/task-delete.ts'
 import { applyScheduleNextRun as applyScheduleRollForward, applySetSchedule } from './use-cases/task-schedule.ts'
 import { applyUpdateTask, 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>
@@ -29,6 +35,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. */
@@ -57,6 +68,13 @@ export interface ControllerDeps {
   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
@@ -99,6 +117,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'>
 }
@@ -139,6 +161,7 @@ export class BoardController {
   private archiveView = false
   private selectedTaskId: string | undefined
   private executionOptions: ExecutionOptionsSnapshot = { workspaces: [], presets: [], models: [] }
+  private workspaceCreator: WorkspaceCreator | undefined
   private listeners = new Set<() => void>()
   private disposers: Array<() => void> = []
   private readonly now: () => number
@@ -193,6 +216,8 @@ export class BoardController {
       selectedTaskId: this.selectedTaskId,
       executionOptions: this.executionOptions,
       pendingTaskIds: [...this.pendingTaskIds],
+      ...(this.workspaceCreator === undefined ? {} : { canCreateWorkspace: true }),
+      ...(typeof this.deps.transport?.parseDraft === 'function' ? { canParseTask: true } : {}),
       ...(this.transportError === undefined ? {} : { transportError: this.transportError }),
       ...(this.hostState === undefined ? {} : { host: this.hostState }),
     }
@@ -306,6 +331,37 @@ export class BoardController {
     this.notify()
   }
 
+  /** Wire (or clear) the runtime's project registration face (issue #1536). */
+  setWorkspaceCreator(creator: WorkspaceCreator | undefined): void {
+    this.workspaceCreator = creator
+    this.notify()
+  }
+
+  /**
+   * 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.
+   */
+  async createWorkspace(path: string): Promise<{ workspaceId: string }> {
+    if (this.workspaceCreator === undefined) throw new Error('workspace creation is unavailable')
+    return await this.workspaceCreator(path)
+  }
+
+  /** Whether this deployment can parse pasted text into task fields (issue #1540). */
+  canParseTask(): boolean {
+    return typeof this.deps.transport?.parseDraft === 'function'
+  }
+
+  /**
+   * Parse pasted text into task fields through the Host. The transport already
+   * phrases every failure for the user, so its message surfaces unchanged.
+   */
+  async parseTaskDraft(request: TaskBoardParseRequest, signal?: AbortSignal): Promise<TaskBoardParseDraft> {
+    const transport = this.deps.transport
+    const parse = transport?.parseDraft
+    if (transport === undefined || parse === undefined) throw new Error('task parsing is unavailable')
+    return await parse.call(transport, request, signal)
+  }
+
   moveTask(id: string, status: TaskStatus): void {
     if (this.deps.transport !== undefined) {
       void this.commitRemote({ kind: 'move', taskId: id, status }, id)

package/src/core/session-reuse.ts

@@ -3,14 +3,16 @@
  * previous execution's conversation. Pure, so the fail-closed conditions stay
  * unit-testable without a gateway.
  */
-import type { TaskRecord } from './tasks.ts'
+import type { ExecutionRecord, 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
@@ -25,7 +27,14 @@ export function reusableSessionId(
   idleSessionIds: ReadonlySet<string> | undefined,
 ): string | undefined {
   if (task.reuseSession !== true || idleSessionIds === undefined) return undefined
-  const last = task.executions[task.executions.length - 1]
-  if (last === undefined || last.sessionId === undefined || last.endedAt === undefined) return undefined
+  let last: ExecutionRecord | undefined
+  for (let index = task.executions.length - 1; index >= 0; index -= 1) {
+    const candidate = task.executions[index]
+    if (candidate.sessionId !== undefined && candidate.endedAt !== undefined) {
+      last = candidate
+      break
+    }
+  }
+  if (last === undefined || last.sessionId === undefined) return undefined
   return idleSessionIds.has(last.sessionId) ? last.sessionId : undefined
 }

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

@@ -134,6 +134,11 @@ export function processIsAlive(pid: number): boolean {
 }
 
 const PROCESS_PROBE_TIMEOUT_MS = 3000
+/**
+ * The CIM fallback pays a WMI cold start, so it gets a wider budget than the
+ * direct `Get-Process` read it backs up.
+ */
+const CIM_PROBE_TIMEOUT_MS = 8000
 
 let ownStartTime: number | undefined
 let ownStartTimeResolved = false
@@ -161,6 +166,59 @@ function linuxStartTimeMs(pid: number): number | undefined {
   }
 }
 
+/** Runs one PowerShell script and returns its trimmed stdout. */
+export type PowerShellProbe = (script: string, timeoutMs: number) => string | undefined
+
+/** Default probe: one hidden, profile-free PowerShell process per script. */
+const runPowerShellProbe: PowerShellProbe = (script, timeoutMs) => {
+  const probe = spawnSync('powershell', ['-NoProfile', '-NonInteractive', '-Command', script], {
+    timeout: timeoutMs,
+    windowsHide: true,
+  })
+  if (probe.status !== 0 || probe.stdout.length === 0) return undefined
+  return probe.stdout.toString('utf8').trim()
+}
+
+/** The epoch-millisecond reading a probe printed, or undefined when unusable. */
+function parseProbeEpochMs(raw: string | undefined): number | undefined {
+  if (raw === undefined || raw.trim() === '') return undefined
+  const started = Number(raw.trim())
+  return Number.isFinite(started) ? started : undefined
+}
+
+/** Start time through Get-Process: precise, but empty for protected processes. */
+function getProcessStartScript(pid: number): string {
+  return '[DateTimeOffset]::FromFileTime((Get-Process -Id ' + String(pid)
+    + ' -ErrorAction SilentlyContinue).StartTime.ToUniversalTime().ToFileTime()).ToUnixTimeMilliseconds()'
+}
+
+/** Start time through Win32_Process: readable for System/svchost too. */
+function cimStartScript(pid: number): string {
+  return '$p=Get-CimInstance Win32_Process -Filter "ProcessId=' + String(pid)
+    + '" -ErrorAction SilentlyContinue;if($p -ne $null){[DateTimeOffset]::FromFileTime($p.CreationDate.ToUniversalTime().ToFileTime()).ToUnixTimeMilliseconds()}'
+}
+
+/**
+ * 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 function win32StartTimeMs(pid: number, probe: PowerShellProbe = runPowerShellProbe): number | undefined {
+  // The pid is interpolated into a PowerShell script, so it must be a plain
+  // positive integer before any probe runs.
+  if (!Number.isSafeInteger(pid) || pid <= 0) return undefined
+  const direct = parseProbeEpochMs(probe(getProcessStartScript(pid), PROCESS_PROBE_TIMEOUT_MS))
+  if (direct !== undefined) return direct
+  return parseProbeEpochMs(probe(cimStartScript(pid), CIM_PROBE_TIMEOUT_MS))
+}
+
 /**
  * Best-effort start time (Unix epoch ms) of a live process. Used to prove
  * whether the ledger lock really belongs to the PID recorded in it, so a
@@ -170,17 +228,7 @@ function linuxStartTimeMs(pid: number): number | undefined {
  */
 function processStartTimeMs(pid: number): number | undefined {
   if (process.platform === 'linux') return linuxStartTimeMs(pid)
-  if (process.platform === 'win32') {
-    const probe = spawnSync(
-      'powershell',
-      ['-NoProfile', '-NonInteractive', '-Command',
-        '[DateTimeOffset]::FromFileTime((Get-Process -Id ' + String(pid) + ' -ErrorAction SilentlyContinue).StartTime.ToUniversalTime().ToFileTime()).ToUnixTimeMilliseconds()'],
-      { timeout: PROCESS_PROBE_TIMEOUT_MS, windowsHide: true },
-    )
-    if (probe.status !== 0 || probe.stdout.length === 0) return undefined
-    const started = Number(probe.stdout.toString('utf8').trim())
-    return Number.isFinite(started) ? started : undefined
-  }
+  if (process.platform === 'win32') return win32StartTimeMs(pid)
   // Other POSIX (macOS...): ps lstart with a forced English locale, falling
   // back to the elapsed-seconds column when lstart cannot be parsed.
   const env = { ...process.env, LC_ALL: 'C' }
@@ -216,6 +264,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 +900,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/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

@@ -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 }