@linxin666/dsh-client-ui-task-board 0.3.3 → 0.3.4

package/lib/index.js

@@ -5,6 +5,7 @@ import { createHash, timingSafeEqual } from "node:crypto";
 import { chmodSync, closeSync, existsSync, fsyncSync, mkdirSync, openSync, readFileSync, renameSync, statSync, unlinkSync, writeFileSync } from "node:fs";
 import { dirname, isAbsolute, join, win32 } from "node:path";
 import { homedir } from "node:os";
+import { isAbsolute as isAbsolute$1, join as join$1 } from "node:path/posix";
 //#region src/core/schedule.ts
 /** Inclusive ranges per field, in cron order. */
 const FIELD_RANGES = [
@@ -182,8 +183,9 @@ function isDigits(value) {
 */
 /** Expand a leading ~ (or ~user) in a path, platform-style. */
 function expandHome(path, home = homedir()) {
+	const j = home.startsWith("/") ? join$1 : join;
 	if (path === "~") return home;
-	if (path.startsWith("~/") || path.startsWith("~\\")) return join(home, path.slice(2));
+	if (path.startsWith("~/") || path.startsWith("~\\")) return j(home, path.slice(2));
 	return path;
 }
 /**
@@ -193,12 +195,15 @@ function expandHome(path, home = homedir()) {
 * @returns the absolute DSH home path.
 */
 function resolveDshHome(env = process.env, home = homedir()) {
+	const isPosix = home.startsWith("/");
+	const j = isPosix ? join$1 : join;
+	const isAbs = isPosix ? isAbsolute$1 : isAbsolute;
 	const raw = env.DSH_HOME;
 	if (raw !== void 0 && raw.trim() !== "") {
 		const expanded = expandHome(raw.trim(), home);
-		return isAbsolute(expanded) ? expanded : join(process.cwd(), expanded);
+		return isAbs(expanded) ? expanded : j(process.cwd(), expanded);
 	}
-	return join(home, ".dsh");
+	return j(home, ".dsh");
 }
 /** Resolve the DSH home directory from the live environment. */
 function dshHome() {
@@ -611,10 +616,34 @@ function applyScheduleNextRun(tasks, id, nextRunAt, lastTriggeredAt, now) {
 * fresh updatedAt. Pure ledger transition (no persistence or notify — the
 * controller orchestrates those).
 *
-* An explicit `undefined` in the patch clears the field (the task falls
-* back to the runtime default); an unknown permission string is ignored so
-* stale UI can never persist a value the execution service rejects.
+* An explicit `undefined` in the patch clears an execution-target field
+* (the task falls back to the runtime default); content fields are trimmed
+* and never cleared. An unknown permission string is ignored so stale UI
+* can never persist a value the execution service rejects.
 */
+/**
+* The fields that edit the task's content (what the user reads and what the
+* next execution sends). Unlike the execution targets they stay editable only
+* while the task has never started executing — after the first run the
+* recorded prompt is the record of what actually ran, so it becomes read-only.
+*/
+const TASK_CONTENT_FIELDS = [
+	"title",
+	"description",
+	"prompt"
+];
+/** Whether an update patch touches any task-content field. */
+function hasContentPatch(patch) {
+	return TASK_CONTENT_FIELDS.some((field) => field in patch);
+}
+/**
+* Whether a task's content may still be edited: the task must be on-board
+* (not archived) and must never have started executing. Fail-closed: a
+* running, settled, or cancelled-before-launch task keeps its content fixed.
+*/
+function canEditTaskContent(task) {
+	return task.archivedAt === void 0 && task.status !== "running" && task.executions.length === 0;
+}
 /** Keep an unknown permission string from entering the ledger. */
 function normalizePermission(current, value) {
 	if (value === void 0) return void 0;
@@ -639,6 +668,11 @@ function applyUpdateTask(tasks, id, patch, now) {
 			...patch,
 			updatedAt: now
 		};
+		for (const field of TASK_CONTENT_FIELDS) {
+			if (!(field in patch)) continue;
+			const value = patch[field];
+			next[field] = value === void 0 ? task[field] : value.trim();
+		}
 		if (workspaceId !== void 0 || "workspaceId" in patch) next.workspaceId = workspaceId;
 		if (mode !== void 0 || "mode" in patch) next.mode = mode;
 		if (permission !== void 0 || "permission" in patch) next.permission = permission;
@@ -1266,6 +1300,8 @@ var HostTaskLedger = class {
 				const task = this.document.tasks.find((task) => task.id === action.taskId);
 				if (task === void 0) throw new Error("task not found");
 				if (task.archivedAt !== void 0) throw new Error("archived task is read-only");
+				if (hasContentPatch(action.patch) && !canEditTaskContent(task)) throw new Error("task has already been executed");
+				if ("title" in action.patch && action.patch.title?.trim() === "") throw new Error("title is required");
 				this.document.tasks = [...applyUpdateTask(this.document.tasks, action.taskId, action.patch, now)];
 				break;
 			}

package/lib/types/client/PluginSettingsCard.d.ts

@@ -22,6 +22,8 @@ export interface PluginSettingsCardProps<TKey extends string = string> {
     titleKey: TKey;
     /** Locale key of the line describing what this plugin's settings govern. */
     descriptionKey: TKey;
+    /** Optional rich header description rendered instead of the plain t(descriptionKey) text (the plain text stays as the tooltip). */
+    descriptionNode?: ReactNode;
     /** The card's form state: availability, writability, and what a save would do. */
     state: CardShell;
     /** Write every staged edit. */

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

@@ -0,0 +1,8 @@
+import type { BoardController } from '../../core/controller.ts';
+import type { TaskRecord } from '../../core/tasks.ts';
+/** Edit-task form overlay. */
+export declare function EditTaskModal({ controller, task, onClose }: {
+    controller: BoardController;
+    task: TaskRecord;
+    onClose: () => void;
+}): import("react").JSX.Element;

package/lib/types/client/locales.d.ts

@@ -40,7 +40,10 @@ export declare const zh: {
     'new.cancel': string;
     'new.required': string;
     'detail.title': string;
+    'detail.edit': string;
     'detail.close': string;
+    'edit.title': string;
+    'edit.save': string;
     'detail.prompt': string;
     'detail.description': string;
     'detail.execution': string;

package/lib/types/core/controller.d.ts

@@ -125,7 +125,15 @@ export declare class BoardController {
     createTask(input: NewTaskInput): TaskRecord | undefined;
     /** Create through the Host and expose the task only after confirmation. */
     createTaskConfirmed(input: NewTaskInput): Promise<TaskRecord | undefined>;
-    updateTask(id: string, patch: TaskUpdatePatch): void;
+    /**
+     * Apply an editable-field patch (task content + execution targets).
+     * Host-backed: the Host ledger owns the fail-closed checks (the content of
+     * an executed task is read-only) and confirms the mutation, so the resolved
+     * value reflects whether the Host accepted it; the legacy in-memory path
+     * applies and persists synchronously.
+     * @returns true when the patch was accepted by the authority.
+     */
+    updateTask(id: string, patch: TaskUpdatePatch): Promise<boolean>;
     /**
      * Replace (a part of) the picker option sets the UI feeds (workspace list
      * and agent-preset roster come from the runtime, not the ledger).

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

@@ -4,13 +4,29 @@
  * fresh updatedAt. Pure ledger transition (no persistence or notify — the
  * controller orchestrates those).
  *
- * An explicit `undefined` in the patch clears the field (the task falls
- * back to the runtime default); an unknown permission string is ignored so
- * stale UI can never persist a value the execution service rejects.
+ * An explicit `undefined` in the patch clears an execution-target field
+ * (the task falls back to the runtime default); content fields are trimmed
+ * and never cleared. An unknown permission string is ignored so stale UI
+ * can never persist a value the execution service rejects.
  */
 import { type TaskRecord } from '../tasks.ts';
 /** Editable fields on a task (the update patch surface). */
 export type TaskUpdatePatch = Partial<Pick<TaskRecord, 'title' | 'description' | 'prompt' | 'workspaceId' | 'mode' | 'permission'>>;
+/**
+ * The fields that edit the task's content (what the user reads and what the
+ * next execution sends). Unlike the execution targets they stay editable only
+ * while the task has never started executing — after the first run the
+ * recorded prompt is the record of what actually ran, so it becomes read-only.
+ */
+export declare const TASK_CONTENT_FIELDS: readonly ["title", "description", "prompt"];
+/** Whether an update patch touches any task-content field. */
+export declare function hasContentPatch(patch: TaskUpdatePatch): boolean;
+/**
+ * Whether a task's content may still be edited: the task must be on-board
+ * (not archived) and must never have started executing. Fail-closed: a
+ * running, settled, or cancelled-before-launch task keeps its content fixed.
+ */
+export declare function canEditTaskContent(task: TaskRecord): boolean;
 /**
  * Apply an update across the ledger. Tasks that do not match the id are left
  * untouched; the matched task receives the patch plus a fresh updatedAt.

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

package/src/client/PluginSettingsCard.tsx

@@ -39,6 +39,8 @@ export interface PluginSettingsCardProps<TKey extends string = string> {
   titleKey: TKey
   /** Locale key of the line describing what this plugin's settings govern. */
   descriptionKey: TKey
+  /** Optional rich header description rendered instead of the plain t(descriptionKey) text (the plain text stays as the tooltip). */
+  descriptionNode?: ReactNode
   /** The card's form state: availability, writability, and what a save would do. */
   state: CardShell
   /** Write every staged edit. */
@@ -87,7 +89,7 @@ export function PluginSettingsCard<TKey extends string = string>(props: PluginSe
       <div className={css.headerStatic}>
         <span className={css.headText}>
           <span className={css.name} title={title}>{title}</span>
-          <span className={css.description} title={description}>{description}</span>
+          <span className={css.description} title={description}>{props.descriptionNode ?? description}</span>
         </span>
         {state.dirty ? <span className={css.pending} title={props.t('settings.unsaved')}>{props.t('settings.unsaved')}</span> : null}
       </div>
@@ -102,7 +104,7 @@ export function PluginSettingsCard<TKey extends string = string>(props: PluginSe
       >
         <span className={css.headText}>
           <span className={css.name} title={title}>{title}</span>
-          <span className={css.description} title={description}>{description}</span>
+          <span className={css.description} title={description}>{props.descriptionNode ?? description}</span>
         </span>
         {state.dirty ? <span className={css.pending} title={props.t('settings.unsaved')}>{props.t('settings.unsaved')}</span> : null}
         <svg

package/src/client/board/EditTaskModal.tsx

@@ -0,0 +1,94 @@
+/**
+ * Edit-task modal: title + description + the prompt the next execution will
+ * send, pre-filled from the task. Shown only for tasks that have never
+ * started executing (the detail view gates on canEditTaskContent); the Host
+ * still re-checks at submit, so a task that started running while the modal
+ * was open fails closed and the error surfaces here.
+ */
+import { useState } from 'react'
+import type { BoardController } from '../../core/controller.ts'
+import type { TaskRecord } from '../../core/tasks.ts'
+import { t } from '../locales.ts'
+import css from '../board.module.css'
+
+/** Edit-task form overlay. */
+export function EditTaskModal({ controller, task, onClose }: { controller: BoardController; task: TaskRecord; onClose: () => void }) {
+  const [title, setTitle] = useState(task.title)
+  const [description, setDescription] = useState(task.description)
+  const [prompt, setPrompt] = useState(task.prompt)
+  const [error, setError] = useState<string | undefined>(undefined)
+  const [pending, setPending] = useState(false)
+
+  const submit = async (): Promise<void> => {
+    if (title.trim() === '') {
+      setError(t('new.required'))
+      return
+    }
+    setPending(true)
+    // The Host confirms the mutation (and its fail-closed checks); only a
+    // confirmed save closes the modal.
+    if (await controller.updateTask(task.id, { title, description, prompt })) {
+      onClose()
+      return
+    }
+    setPending(false)
+    setError(controller.getSnapshot().transportError ?? t('new.required'))
+  }
+
+  return (
+    <div className={css.modalBackdrop} onMouseDown={event => { if (event.target === event.currentTarget) onClose() }}>
+      <form
+        className={css.modal}
+        role="dialog"
+        aria-label={t('edit.title')}
+        onSubmit={event => { event.preventDefault(); void submit() }}
+      >
+        <h2 className={css.modalTitle}>{t('edit.title')}</h2>
+
+        <label className={css.field}>
+          <span className={css.fieldLabel}>{t('new.title')}</span>
+          <input
+            className={css.input}
+            value={title}
+            autoFocus
+            placeholder={t('new.titlePlaceholder')}
+            onChange={event => { setTitle(event.target.value); setError(undefined) }}
+          />
+        </label>
+
+        <label className={css.field}>
+          <span className={css.fieldLabel}>{t('new.description')}</span>
+          <textarea
+            className={css.input}
+            rows={3}
+            value={description}
+            placeholder={t('new.descriptionPlaceholder')}
+            onChange={event => { setDescription(event.target.value) }}
+          />
+        </label>
+
+        <label className={css.field}>
+          <span className={css.fieldLabel}>{t('new.prompt')}</span>
+          <textarea
+            className={css.input}
+            rows={4}
+            value={prompt}
+            placeholder={t('new.promptPlaceholder')}
+            onChange={event => { setPrompt(event.target.value) }}
+          />
+        </label>
+
+        {error !== undefined && <p className={css.formError}>{error}</p>}
+
+        <footer className={css.modalFooter}>
+          <button type="button" className={css.ghostButton} onClick={onClose}>
+            {t('new.cancel')}
+          </button>
+          <button type="submit" className={css.primaryButton} disabled={pending}>
+            {t('edit.save')}
+          </button>
+        </footer>
+      </form>
+    </div>
+  )
+}

package/src/client/board/TaskDetail.tsx

@@ -8,10 +8,12 @@ import { useEffect, useState } from 'react'
 import type { BoardController } from '../../core/controller.ts'
 import { isValidCron } from '../../core/schedule.ts'
 import { MANUAL_STATUSES, TASK_PERMISSIONS, type ExecutionRecord, type TaskPermission, type TaskRecord } from '../../core/tasks.ts'
+import { canEditTaskContent } from '../../core/use-cases/task-update.ts'
 import { t, type TaskBoardKey } from '../locales.ts'
 import { SCHEDULE_PRESETS } from '../schedule-presets.ts'
 import css from '../board.module.css'
 import { ConfirmDialog } from './ConfirmDialog.tsx'
+import { EditTaskModal } from './EditTaskModal.tsx'
 import { formatHostTimestamp, formatTime } from './TaskCard.tsx'
 import { STATUS_KEY } from './status-key.ts'
 
@@ -232,10 +234,13 @@ function ScheduleSection({ controller, task, pending }: { controller: BoardContr
 /** Task detail overlay. */
 export function TaskDetail({ controller, task }: { controller: BoardController; task: TaskRecord }) {
   const [confirmDelete, setConfirmDelete] = useState(false)
+  const [showEdit, setShowEdit] = useState(false)
 
   // Keep the overlay in sync if the task record changes underneath.
   const [latest, setLatest] = useState(task)
   useEffect(() => { setLatest(task) }, [task])
+  // A re-used overlay instance must not carry an edit session across tasks.
+  useEffect(() => { setShowEdit(false) }, [task.id])
   const current = latest
   const snapshot = controller.getSnapshot()
   const running = current.status === 'running'
@@ -328,6 +333,16 @@ export function TaskDetail({ controller, task }: { controller: BoardController;
 
         <footer className={css.detailFooter}>
           {!archived && pending && <span className={css.detailMeta}>{t('board.pending')}…</span>}
+          {!archived && canEditTaskContent(current) && (
+            <button
+              type="button"
+              className={css.ghostButton}
+              disabled={pending}
+              onClick={() => { setShowEdit(true) }}
+            >
+              {t('detail.edit')}
+            </button>
+          )}
           {!archived && (
             <button
               type="button"
@@ -395,6 +410,10 @@ export function TaskDetail({ controller, task }: { controller: BoardController;
           }}
         />
       )}
+
+      {showEdit && !archived && canEditTaskContent(current) && (
+        <EditTaskModal controller={controller} task={current} onClose={() => { setShowEdit(false) }} />
+      )}
     </div>
   )
 }

package/src/client/locales.ts

@@ -41,7 +41,10 @@ export const zh = {
   'new.cancel': '取消',
   'new.required': '标题不能为空',
   'detail.title': '任务详情',
+  'detail.edit': '编辑',
   'detail.close': '关闭',
+  'edit.title': '编辑任务',
+  'edit.save': '保存',
   'detail.prompt': '执行 Prompt',
   'detail.description': '描述',
   'detail.execution': '执行记录',
@@ -164,7 +167,10 @@ export const en: Record<keyof typeof zh, string> = {
   'new.cancel': 'Cancel',
   'new.required': 'Title is required',
   'detail.title': 'Task Detail',
+  'detail.edit': 'Edit',
   'detail.close': 'Close',
+  'edit.title': 'Edit Task',
+  'edit.save': 'Save',
   'detail.prompt': 'Run Prompt',
   'detail.description': 'Description',
   'detail.execution': 'Execution History',

package/src/client/settings-card.module.css

@@ -24,6 +24,10 @@
 .header {
   appearance: none;
   width: 100%;
+  /* The suite does not force a global border-box, so width:100% + padding
+     would stretch the row 32px past the card and push the trailing pending
+     badge (last flex item) outside the card border. */
+  box-sizing: border-box;
   font: inherit;
   color: inherit;
   text-align: left;
@@ -44,6 +48,7 @@
 
 .headerStatic {
   width: 100%;
+  box-sizing: border-box;
   border-radius: 12px;
   align-items: center;
   gap: 12px;

package/src/core/controller.ts

@@ -273,13 +273,21 @@ export class BoardController {
       : undefined
   }
 
-  updateTask(id: string, patch: TaskUpdatePatch): void {
+  /**
+   * Apply an editable-field patch (task content + execution targets).
+   * Host-backed: the Host ledger owns the fail-closed checks (the content of
+   * an executed task is read-only) and confirms the mutation, so the resolved
+   * value reflects whether the Host accepted it; the legacy in-memory path
+   * applies and persists synchronously.
+   * @returns true when the patch was accepted by the authority.
+   */
+  async updateTask(id: string, patch: TaskUpdatePatch): Promise<boolean> {
     if (this.deps.transport !== undefined) {
-      void this.commitRemote({ kind: 'update', taskId: id, patch }, id)
-      return
+      return await this.commitRemote({ kind: 'update', taskId: id, patch }, id)
     }
     this.tasks = [...applyUpdateTask(this.tasks, id, patch, this.now())]
     this.persistAndNotify()
+    return true
   }
 
   /**

package/src/core/use-cases/task-update.ts

@@ -4,15 +4,38 @@
  * fresh updatedAt. Pure ledger transition (no persistence or notify — the
  * controller orchestrates those).
  *
- * An explicit `undefined` in the patch clears the field (the task falls
- * back to the runtime default); an unknown permission string is ignored so
- * stale UI can never persist a value the execution service rejects.
+ * An explicit `undefined` in the patch clears an execution-target field
+ * (the task falls back to the runtime default); content fields are trimmed
+ * and never cleared. An unknown permission string is ignored so stale UI
+ * can never persist a value the execution service rejects.
  */
 import { isTaskPermission, normalizeTargetId, type TaskRecord, type TaskPermission } from '../tasks.ts'
 
 /** Editable fields on a task (the update patch surface). */
 export type TaskUpdatePatch = Partial<Pick<TaskRecord, 'title' | 'description' | 'prompt' | 'workspaceId' | 'mode' | 'permission'>>
 
+/**
+ * The fields that edit the task's content (what the user reads and what the
+ * next execution sends). Unlike the execution targets they stay editable only
+ * while the task has never started executing — after the first run the
+ * recorded prompt is the record of what actually ran, so it becomes read-only.
+ */
+export const TASK_CONTENT_FIELDS = ['title', 'description', 'prompt'] as const
+
+/** Whether an update patch touches any task-content field. */
+export function hasContentPatch(patch: TaskUpdatePatch): boolean {
+  return (TASK_CONTENT_FIELDS as readonly string[]).some(field => field in patch)
+}
+
+/**
+ * Whether a task's content may still be edited: the task must be on-board
+ * (not archived) and must never have started executing. Fail-closed: a
+ * running, settled, or cancelled-before-launch task keeps its content fixed.
+ */
+export function canEditTaskContent(task: TaskRecord): boolean {
+  return task.archivedAt === undefined && task.status !== 'running' && task.executions.length === 0
+}
+
 /** Keep an unknown permission string from entering the ledger. */
 function normalizePermission(
   current: TaskPermission | undefined,
@@ -42,6 +65,13 @@ export function applyUpdateTask(
     const mode = 'mode' in patch ? normalizeTargetId(patch.mode) : undefined
     const permission = 'permission' in patch ? normalizePermission(task.permission, patch.permission) : undefined
     const next: TaskRecord = { ...task, ...patch, updatedAt: now }
+    // Content fields normalize like creation does (trimmed); an explicit
+    // undefined keeps the current value — content cannot be cleared.
+    for (const field of TASK_CONTENT_FIELDS) {
+      if (!(field in patch)) continue
+      const value = patch[field]
+      next[field] = value === undefined ? task[field] : value.trim()
+    }
     if (workspaceId !== undefined || 'workspaceId' in patch) next.workspaceId = workspaceId
     if (mode !== undefined || 'mode' in patch) next.mode = mode
     if (permission !== undefined || 'permission' in patch) next.permission = permission

package/src/dsh-home.ts

@@ -7,11 +7,14 @@
 
 import { homedir } from 'node:os'
 import { isAbsolute, join } from 'node:path'
+import { isAbsolute as posixIsAbsolute, join as posixJoin } from 'node:path/posix'
 
 /** Expand a leading ~ (or ~user) in a path, platform-style. */
 export function expandHome(path: string, home: string = homedir()): string {
+  const isPosix = home.startsWith('/')
+  const j = isPosix ? posixJoin : join
   if (path === '~') return home
-  if (path.startsWith('~/') || path.startsWith('~\\')) return join(home, path.slice(2))
+  if (path.startsWith('~/') || path.startsWith('~\\')) return j(home, path.slice(2))
   return path
 }
 
@@ -22,12 +25,15 @@ export function expandHome(path: string, home: string = homedir()): string {
  * @returns the absolute DSH home path.
  */
 export function resolveDshHome(env: NodeJS.ProcessEnv = process.env, home: string = homedir()): string {
+  const isPosix = home.startsWith('/')
+  const j = isPosix ? posixJoin : join
+  const isAbs = isPosix ? posixIsAbsolute : isAbsolute
   const raw = env.DSH_HOME
   if (raw !== undefined && raw.trim() !== '') {
     const expanded = expandHome(raw.trim(), home)
-    return isAbsolute(expanded) ? expanded : join(process.cwd(), expanded)
+    return isAbs(expanded) ? expanded : j(process.cwd(), expanded)
   }
-  return join(home, '.dsh')
+  return j(home, '.dsh')
 }
 
 /** Resolve the DSH home directory from the live environment. */

package/src/host-ledger.ts

@@ -10,7 +10,7 @@ import { applyArchiveTask, applyRestoreTask } from './core/use-cases/task-archiv
 import { applyCreateTask } from './core/use-cases/task-create.ts'
 import { applyDeleteTask } from './core/use-cases/task-delete.ts'
 import { applySetSchedule, applyScheduleNextRun } from './core/use-cases/task-schedule.ts'
-import { applyUpdateTask } from './core/use-cases/task-update.ts'
+import { applyUpdateTask, canEditTaskContent, hasContentPatch } from './core/use-cases/task-update.ts'
 import { TASK_BOARD_SCHEMA_VERSION, type TaskBoardAction, type TaskBoardSchedulerSnapshot } from './protocol.ts'
 
 interface PersistedScheduler extends TaskBoardSchedulerSnapshot {
@@ -482,6 +482,14 @@ export class HostTaskLedger {
         const task = this.document.tasks.find(task => task.id === action.taskId)
         if (task === undefined) throw new Error('task not found')
         if (task.archivedAt !== undefined) throw new Error('archived task is read-only')
+        // The task content (title/description/prompt) is the record of what
+        // was planned; once an execution started it must not change under a
+        // running session or an executed history. Execution targets stay
+        // editable (they only affect future runs).
+        if (hasContentPatch(action.patch) && !canEditTaskContent(task)) {
+          throw new Error('task has already been executed')
+        }
+        if ('title' in action.patch && action.patch.title?.trim() === '') throw new Error('title is required')
         this.document.tasks = [...applyUpdateTask(this.document.tasks, action.taskId, action.patch, now)]
         break
       }