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

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/board/TaskCard.d.ts

@@ -2,7 +2,6 @@ import type { TaskRecord } from '../../core/tasks.ts';
 /** Compact relative/absolute time label. */
 export declare function formatHostTimestamp(ms: number, timeZone?: string): string;
 export declare function formatTime(ms: number, timeZone?: string): string;
-/** One card in a column. */
 declare function TaskCardInner({ task, pending, timeZone, onClick }: {
     task: TaskRecord;
     pending: boolean;

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

@@ -2,8 +2,8 @@
  * Board controller: the single owner of task-ledger state and view state.
  *
  * In production it projects the Host ledger and submits confirmed actions;
- * the legacy store seam remains for v1 migration tests. It also closes the
- * board whenever the user navigates to a session.
+ * the legacy store seam remains for v1 migration tests. The board closes
+ * only on explicit user navigation, never implicitly on session-list churn.
  * Framework-free (structural runtime faces) so the whole orchestration is
  * unit-testable with fakes.
  *
@@ -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).
@@ -180,9 +188,17 @@ export declare class BoardController {
     runTask(id: string): Promise<boolean>;
     /** Re-run a settled task through the Host (the Host replans and executes). */
     rerunTask(id: string): Promise<void>;
-    /** Close the board when the user navigates to another session. */
+    /**
+     * Session-list notifications fire for all kinds of incidental churn
+     * (background navigation, the Host runner creating and selecting a fresh
+     * execution session, settlement, other plugins), so closing on `current`
+     * changes would evict the board without the user asking. The board closes
+     * only on explicit user navigation: a sidebar session/workspace row click
+     * (board-mount onClickSidebarRow) or the board's own actions
+     * (openSession / close). Keeping the hook preserves the subscription
+     * contract for future listeners.
+     */
     private onSessionsChanged;
-    private lastCurrent;
     private persistAndNotify;
     private commitRemote;
     private performRemote;

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.5",
   "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/TaskBoard.tsx

@@ -5,7 +5,7 @@
  */
 import { memo, useCallback, useEffect, useState } from 'react'
 import { selectedTaskOf, type BoardController } from '../../core/controller.ts'
-import { COLUMNS, type TaskRecord } from '../../core/tasks.ts'
+import { COLUMNS, canMoveManually, type TaskRecord } from '../../core/tasks.ts'
 import { t } from '../locales.ts'
 import css from '../board.module.css'
 import { NewTaskModal } from './NewTaskModal.tsx'
@@ -124,8 +124,27 @@ export function TaskBoard({ controller }: { controller: BoardController }) {
         ) : (
           COLUMNS.map(column => {
             const tasks = visible.filter(task => task.status === column.status)
+            const isManualDropTarget = column.status === 'backlog' || column.status === 'todo'
             return (
-              <section key={column.status} className={css.column} data-status={column.status} data-dsh-part="column">
+              <section
+                key={column.status}
+                className={css.column}
+                data-status={column.status}
+                data-dsh-part="column"
+                onDragOver={isManualDropTarget ? (event) => {
+                  event.preventDefault()
+                  event.dataTransfer.dropEffect = 'move'
+                } : undefined}
+                onDrop={isManualDropTarget ? (event) => {
+                  event.preventDefault()
+                  const taskId = event.dataTransfer.getData('text/plain')
+                  if (!taskId) return
+                  const dropped = snapshot.tasks.find(t => t.id === taskId)
+                  if (dropped && canMoveManually(dropped.status, column.status) && dropped.status !== column.status) {
+                    controller.moveTask(taskId, column.status)
+                  }
+                } : undefined}
+              >
                 <header className={css.columnHeader}>
                   <span className={css.statusDot} data-status={column.status} aria-hidden="true" />
                   <h3 className={css.columnTitle}>{t(STATUS_KEY[column.status])}</h3>

package/src/client/board/TaskCard.tsx

@@ -37,11 +37,12 @@ export function formatTime(ms: number, timeZone?: string): string {
   return `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, '0')}-${String(date.getDate()).padStart(2, '0')}`
 }
 
-/** One card in a column. */
 function TaskCardInner({ task, pending, timeZone, onClick }: { task: TaskRecord; pending: boolean; timeZone?: string; onClick: () => void }) {
   const latest = task.executions[task.executions.length - 1]
   const runs = task.executions.length
   const archived = task.archivedAt !== undefined
+  const isDraggable = !archived && task.status !== 'running' && !pending
+
   return (
     <button
       type="button"
@@ -49,6 +50,11 @@ function TaskCardInner({ task, pending, timeZone, onClick }: { task: TaskRecord;
       data-status={archived ? 'archived' : task.status}
       data-dsh-part="card"
       data-pending={pending || undefined}
+      draggable={isDraggable}
+      onDragStart={isDraggable ? (event) => {
+        event.dataTransfer.setData('text/plain', task.id)
+        event.dataTransfer.effectAllowed = 'move'
+      } : undefined}
       onClick={onClick}
       title={task.description !== '' ? task.description : task.title}
     >

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

@@ -2,8 +2,8 @@
  * Board controller: the single owner of task-ledger state and view state.
  *
  * In production it projects the Host ledger and submits confirmed actions;
- * the legacy store seam remains for v1 migration tests. It also closes the
- * board whenever the user navigates to a session.
+ * the legacy store seam remains for v1 migration tests. The board closes
+ * only on explicit user navigation, never implicitly on session-list churn.
  * Framework-free (structural runtime faces) so the whole orchestration is
  * unit-testable with fakes.
  *
@@ -108,11 +108,6 @@ function randomUuid(): string {
   return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`
 }
 
-/** Read the current selection off a session-list snapshot (structural). */
-function currentOf(sessions: SessionsControllerFace): string | undefined {
-  return sessions.list.getSnapshot().current
-}
-
 function messageOf(error: unknown): string {
   return error instanceof Error ? error.message : String(error)
 }
@@ -205,10 +200,11 @@ export class BoardController {
 
   openBoard(): void {
     if (this.boardOpen) return
-    // Baseline the selection the board opened against: the board stays open
-    // until the user navigates (selection changes), never on mere status
-    // updates of the already-selected session.
-    this.lastCurrent = currentOf(this.deps.sessions)
+    // The board stays open until the user explicitly closes it: by clicking
+    // the sidebar entry again, a sidebar session/workspace row, or a board
+    // action (openSession / close). Session-list churn (background
+    // navigation, the Host runner selecting a fresh execution session,
+    // settlement, other plugins) never evicts the board.
     this.boardOpen = true
     this.notify()
   }
@@ -273,13 +269,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
   }
 
   /**
@@ -420,16 +424,20 @@ export class BoardController {
 
   // --- internals ---------------------------------------------------------------
 
-  /** Close the board when the user navigates to another session. */
+  /**
+   * Session-list notifications fire for all kinds of incidental churn
+   * (background navigation, the Host runner creating and selecting a fresh
+   * execution session, settlement, other plugins), so closing on `current`
+   * changes would evict the board without the user asking. The board closes
+   * only on explicit user navigation: a sidebar session/workspace row click
+   * (board-mount onClickSidebarRow) or the board's own actions
+   * (openSession / close). Keeping the hook preserves the subscription
+   * contract for future listeners.
+   */
   private onSessionsChanged(): void {
-    if (!this.boardOpen) return
-    const current = currentOf(this.deps.sessions)
-    if (current !== this.lastCurrent) this.closeBoard()
-    this.lastCurrent = current
+    // Intentionally empty: never close the board implicitly.
   }
 
-  private lastCurrent: string | undefined = undefined
-
   private persistAndNotify(): void {
     if (this.deps.transport === undefined) this.deps.store.save(this.tasks)
     this.notify()