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

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

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

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

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

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

@@ -1,5 +1,7 @@
 import { type BoardController } from '../../core/controller.ts';
 import { type TaskRecord } from '../../core/tasks.ts';
+/** Sentinel option value of the project row's "register a new project" entry. */
+export declare const NEW_PROJECT_VALUE = "__dsh_new_project__";
 /** Case-insensitive title/description/tag/freeze-snapshot match. */
 export declare function matchesFilter(task: TaskRecord, filter: string): boolean;
 /**

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

@@ -40,7 +40,7 @@ export declare function TaskTagFields({ tags, knownTags, onChange, }: {
     onChange: (tags: TaskTag[]) => void;
 }): import("react").JSX.Element;
 /**
- * Drop blank rows and trim what survives, so the wire always carries a valid
- * tag list (the protocol rejects a list with a blank name or an empty array).
+ * Clean a tag list via normalizeTags: trim, drop blanks and duplicates, cap
+ * lengths and count, so the wire always carries a valid tag list.
  */
 export declare function cleanTags(tags: readonly TaskTag[]): TaskTag[];

package/lib/types/client/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;
@@ -70,6 +94,7 @@ export declare const zh: {
     'detail.permissionConfirmed': string;
     'detail.title': string;
     'detail.edit': string;
+    'detail.editTags': string;
     'detail.duplicate': string;
     'detail.duplicateAndEdit': string;
     'detail.close': string;

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

package/src/client/board/EditTaskModal.tsx

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

package/src/client/board/NewTaskModal.tsx

@@ -2,7 +2,7 @@
  * New-task modal: title + description + the prompt that execution will send.
  * Creates through the Host and closes only after the Host confirms it.
  */
-import { useEffect, useState } from 'react'
+import { useEffect, useRef, useState } from 'react'
 import type { BoardController } from '../../core/controller.ts'
 import { isValidCron, nextRunAtMs } from '../../core/schedule.ts'
 import { parseFreezeRequest } from '../../core/freeze-snapshot.ts'
@@ -17,17 +17,22 @@ 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 function NewTaskModal({ controller, onClose, initialTask, onDuplicateSuccess }: NewTaskModalProps) {
+export function NewTaskModal({ controller, onClose, initialTask, defaultWorkspaceId, onDuplicateSuccess }: NewTaskModalProps) {
   const isDuplicate = initialTask !== undefined
   const [title, setTitle] = useState(initialTask?.title ?? '')
   const [description, setDescription] = useState(initialTask?.description ?? '')
   const [prompt, setPrompt] = useState(initialTask?.prompt ?? '')
-  const [workspaceId, setWorkspaceId] = useState(initialTask?.workspaceId ?? '')
+  const [workspaceId, setWorkspaceId] = useState(initialTask?.workspaceId ?? defaultWorkspaceId ?? '')
   const [mode, setMode] = useState(initialTask?.mode ?? '')
   const [permission, setPermission] = useState(initialTask?.permission ?? '')
   const [model, setModel] = useState(initialTask?.model ?? '')
@@ -45,6 +50,15 @@ export function NewTaskModal({ controller, onClose, initialTask, onDuplicateSucc
   const [error, setError] = useState<string | undefined>(undefined)
   const [pending, setPending] = useState(false)
   const [options, setOptions] = useState(controller.getSnapshot().executionOptions)
+  // "Parse pasted text" (issue #1540) exists only when the deployment carries a
+  // parse face; the section stays hidden otherwise.
+  const [canParse] = useState(controller.getSnapshot().canParseTask === true)
+  const [parseText, setParseText] = useState('')
+  const [parseModel, setParseModel] = useState('')
+  const [parsePending, setParsePending] = useState(false)
+  const [parseError, setParseError] = useState<string | undefined>(undefined)
+  const parseAbort = useRef<AbortController | undefined>(undefined)
+  const parseModels = options.models ?? []
 
   // The workspace list and preset roster arrive from the runtime after mount;
   // follow them so the pickers never freeze on an empty snapshot.
@@ -53,6 +67,36 @@ export function NewTaskModal({ controller, onClose, initialTask, onDuplicateSucc
     [controller],
   )
 
+  // The model roster arrives asynchronously: default to its first entry, which
+  // the user can change before parsing.
+  useEffect(() => {
+    if (parseModel === '' && parseModels.length > 0) setParseModel(parseModels[0]!.id)
+  }, [parseModel, options.models])
+
+  const runParse = async (): Promise<void> => {
+    const text = parseText.trim()
+    if (text === '') {
+      setParseError(t('new.aiParseEmpty'))
+      return
+    }
+    const abort = new AbortController()
+    parseAbort.current = abort
+    setParsePending(true)
+    setParseError(undefined)
+    try {
+      const draft = await controller.parseTaskDraft({ text, ...(parseModel === '' ? {} : { model: parseModel }) }, abort.signal)
+      setTitle(draft.title)
+      setDescription(draft.description)
+      setPrompt(draft.prompt)
+    } catch (parseFailure) {
+      // A cancelled parse reports nothing: the user asked for it to stop.
+      if (!abort.signal.aborted) setParseError(parseFailure instanceof Error ? parseFailure.message : String(parseFailure))
+    } finally {
+      parseAbort.current = undefined
+      setParsePending(false)
+    }
+  }
+
   const submit = async (): Promise<void> => {
     if (scheduleEnabled) {
       const cron = scheduleCron.trim()
@@ -132,6 +176,50 @@ export function NewTaskModal({ controller, onClose, initialTask, onDuplicateSucc
       onSubmit={() => { void submit() }}
       onClose={onClose}
     >
+      {canParse && (
+        <section className={css.aiParse} data-dsh-part="ai-parse">
+          <span className={css.fieldLabel}>{t('new.aiParse')}</span>
+          <p className={css.fieldHint}>{t('new.aiParseHint')}</p>
+          <textarea
+            className={css.input}
+            rows={3}
+            value={parseText}
+            placeholder={t('new.aiParsePlaceholder')}
+            spellCheck={false}
+            onChange={event => { setParseText(event.target.value); setParseError(undefined) }}
+          />
+          <div className={css.aiParseRow}>
+            <select
+              className={css.select}
+              value={parseModel}
+              aria-label={t('new.aiParseModel')}
+              onChange={event => { setParseModel(event.target.value) }}
+            >
+              {parseModels.map(option => (
+                <option key={option.id} value={option.id}>{option.name ?? option.id}</option>
+              ))}
+            </select>
+            {parsePending
+              ? (
+                <button type="button" className={css.ghostButton} onClick={() => { parseAbort.current?.abort() }}>
+                  {t('new.aiParseCancel')}
+                </button>
+                )
+              : (
+                <button
+                  type="button"
+                  className={css.primaryButton}
+                  disabled={parseText.trim() === ''}
+                  onClick={() => { void runParse() }}
+                >
+                  {t('new.aiParseRun')}
+                </button>
+                )}
+          </div>
+          {parseError !== undefined && <p className={css.formError}>{parseError}</p>}
+        </section>
+      )}
+
       <TaskContentFields
         title={title}
         description={description}

package/src/client/board/TaskBoard.tsx

@@ -13,6 +13,9 @@ import { STATUS_KEY } from './status-key.ts'
 import { TaskCard } from './TaskCard.tsx'
 import { TaskDetail } from './TaskDetail.tsx'
 
+/** Sentinel option value of the project row's "register a new project" entry. */
+export const NEW_PROJECT_VALUE = '__dsh_new_project__'
+
 /** Case-insensitive title/description/tag/freeze-snapshot match. */
 export function matchesFilter(task: TaskRecord, filter: string): boolean {
   if (filter.trim() === '') return true
@@ -55,6 +58,13 @@ export function TaskBoard({ controller }: { controller: BoardController }) {
   const [filter, setFilter] = useState('')
   const [tagFilter, setTagFilter] = useState<string[]>([])
   const [showNew, setShowNew] = useState(false)
+  // Project partition (#1536): '' means "all projects". A selected project
+  // narrows the board and becomes the new-task form's default workspace.
+  const [projectId, setProjectId] = useState('')
+  const [showNewProject, setShowNewProject] = useState(false)
+  const [newProjectPath, setNewProjectPath] = useState('')
+  const [newProjectError, setNewProjectError] = useState<string | undefined>(undefined)
+  const [newProjectPending, setNewProjectPending] = useState(false)
   const selected = selectedTaskOf(snapshot)
   const archiveView = snapshot.archiveView
   // Every label in use across the ledger (board and archive alike), so the
@@ -63,9 +73,28 @@ export function TaskBoard({ controller }: { controller: BoardController }) {
   // Archived tasks leave the columns; the archive view shows them instead.
   const visible = snapshot.tasks.filter(task =>
     (archiveView ? task.archivedAt !== undefined : task.archivedAt === undefined)
+    && (projectId === '' || task.workspaceId === projectId)
     && matchesFilter(task, filter)
     && matchesTagFilter(task, tagFilter),
   )
+  const projects = snapshot.executionOptions.workspaces
+  const canCreateProject = snapshot.canCreateWorkspace === true
+  const submitNewProject = async (): Promise<void> => {
+    const path = newProjectPath.trim()
+    if (path === '') return
+    setNewProjectPending(true)
+    setNewProjectError(undefined)
+    try {
+      const created = await controller.createWorkspace(path)
+      setProjectId(created.workspaceId)
+      setShowNewProject(false)
+      setNewProjectPath('')
+    } catch (error) {
+      setNewProjectError(error instanceof Error ? error.message : String(error))
+    } finally {
+      setNewProjectPending(false)
+    }
+  }
   const toggleTag = useCallback((name: string): void => {
     setTagFilter(current => current.includes(name)
       ? current.filter(entry => entry !== name)
@@ -96,6 +125,32 @@ export function TaskBoard({ controller }: { controller: BoardController }) {
             })}
           </span>
         )}
+        {(projects.length > 0 || canCreateProject) && (
+          <label className={css.projectFilter}>
+            <span className={css.projectFilterLabel}>{t('board.project')}</span>
+            <select
+              className={css.select}
+              data-dsh-part="project-filter"
+              value={projectId}
+              aria-label={t('board.project')}
+              onChange={event => {
+                const value = event.target.value
+                if (value === NEW_PROJECT_VALUE) {
+                  setNewProjectError(undefined)
+                  setShowNewProject(true)
+                  return
+                }
+                setProjectId(value)
+              }}
+            >
+              <option value="">{t('board.projectAll')}</option>
+              {projects.map(project => (
+                <option key={project.workspaceId} value={project.workspaceId}>{project.title}</option>
+              ))}
+              {canCreateProject && <option value={NEW_PROJECT_VALUE}>{t('board.projectNew')}</option>}
+            </select>
+          </label>
+        )}
         <input
           className={css.search}
           type="search"
@@ -122,6 +177,39 @@ export function TaskBoard({ controller }: { controller: BoardController }) {
         </button>
       </header>
 
+      {showNewProject && (
+        <div className={css.projectDialog} data-dsh-part="project-dialog">
+          <label className={css.field}>
+            <span className={css.fieldLabel}>{t('board.projectNewPath')}</span>
+            <input
+              className={css.input}
+              value={newProjectPath}
+              placeholder={t('board.projectNewPathPlaceholder')}
+              spellCheck={false}
+              onChange={event => { setNewProjectPath(event.target.value); setNewProjectError(undefined) }}
+            />
+          </label>
+          {newProjectError !== undefined && <p className={css.formError}>{t('board.projectCreateFailed', { error: newProjectError })}</p>}
+          <div className={css.projectDialogActions}>
+            <button
+              type="button"
+              className={css.ghostButton}
+              onClick={() => { setShowNewProject(false); setNewProjectError(undefined) }}
+            >
+              {t('new.cancel')}
+            </button>
+            <button
+              type="button"
+              className={css.primaryButton}
+              disabled={newProjectPending || newProjectPath.trim() === ''}
+              onClick={() => { void submitNewProject() }}
+            >
+              {t('board.projectCreate')}
+            </button>
+          </div>
+        </div>
+      )}
+
       {!archiveView && knownTags.length > 0 && (
         <div className={css.tagFilter} data-dsh-part="tag-filter">
           <span className={css.tagFilterLabel}>{t('board.tagFilter')}</span>
@@ -225,6 +313,7 @@ export function TaskBoard({ controller }: { controller: BoardController }) {
       {showNew && (
         <NewTaskModal
           controller={controller}
+          {...(projectId === '' ? {} : { defaultWorkspaceId: projectId })}
           onClose={() => { setShowNew(false) }}
         />
       )}