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

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
       }