@linxin666/dsh-client-ui-task-board 0.1.20 → 0.2.0

package/lib/client.js

@@ -172,7 +172,8 @@ window.__ModuleLoader__.load({
 		/**
 		* Archive one task: only settled statuses (done/failed) can be archived;
 		* a running or not-yet-settled task stays on the board (its runner still
-		* owns its lifecycle). Already-archived tasks are a no-op.
+		* owns its lifecycle). Archiving disarms a schedule; already-archived tasks
+		* are a no-op.
 		*/
 		function applyArchiveTask(tasks, id, now) {
 			let applied = false;
@@ -181,8 +182,14 @@ window.__ModuleLoader__.load({
 					if (task.id !== id || task.archivedAt !== void 0) return task;
 					if (!ARCHIVABLE_STATUSES.includes(task.status)) return task;
 					applied = true;
+					const schedule = task.schedule === void 0 ? void 0 : {
+						...task.schedule,
+						enabled: false,
+						nextRunAt: void 0
+					};
 					return {
 						...task,
+						...schedule === void 0 ? {} : { schedule },
 						archivedAt: now,
 						updatedAt: now
 					};
@@ -249,20 +256,46 @@ window.__ModuleLoader__.load({
 		/**
 		* Compute the next matching instant after `fromMs` (ms epoch), in local time,
 		* at minute granularity, strictly greater than `fromMs`. Returns the ms epoch
-		* of the matching minute's start, or undefined when nothing matches within
-		* 366 days (e.g. `0 0 30 2 *`).
+		* of the matching minute's start, or undefined when the calendar constraint
+		* can never match (for example `0 0 30 2 *`). The five-year horizon includes
+		* a full leap cycle, so a valid February 29 schedule remains reachable from
+		* every non-leap year.
 		*/
 		function nextRunAtMs(expr, fromMs) {
 			const schedule = parseCron(expr);
 			if (schedule === null) return void 0;
+			if (!hasPossibleCalendarDay(schedule)) return void 0;
 			const from = new Date(fromMs);
 			const scan = new Date(from.getFullYear(), from.getMonth(), from.getDate(), from.getHours(), from.getMinutes() + 1, 0, 0);
-			const limitMs = fromMs + 366 * 24 * 60 * 60 * 1e3;
+			const limitMs = fromMs + 5 * 366 * 24 * 60 * 60 * 1e3;
 			while (scan.getTime() <= limitMs) {
 				if (matches(schedule, scan)) return scan.getTime();
 				scan.setMinutes(scan.getMinutes() + 1);
 			}
 		}
+		/** Reject impossible month/day pairs without spending the multi-year scan. */
+		function hasPossibleCalendarDay(schedule) {
+			if (schedule.dayWildcard || !schedule.weekdayWildcard) return true;
+			const maximumDay = /* @__PURE__ */ new Map([
+				[1, 31],
+				[2, 29],
+				[3, 31],
+				[4, 30],
+				[5, 31],
+				[6, 30],
+				[7, 31],
+				[8, 31],
+				[9, 30],
+				[10, 31],
+				[11, 30],
+				[12, 31]
+			]);
+			for (const month of schedule.months) {
+				const maximum = maximumDay.get(month) ?? 0;
+				if ([...schedule.days].some((day) => day <= maximum)) return true;
+			}
+			return false;
+		}
 		/** Parse one comma-list field into the match set. */
 		function parseField(field, min, max, out) {
 			if (field === "*") {
@@ -366,9 +399,9 @@ window.__ModuleLoader__.load({
 		* the core cron parser (schedule.ts) and the withSchedule transition.
 		*/
 		/**
-		* Set a task's schedule rule. A blank or invalid cron is rejected (state
-		* untouched); an enabled rule computes the next run instant immediately, a
-		* disabled or invalid one carries no next-run instant.
+		* Set an on-board task's schedule rule. A blank or invalid cron, or an
+		* archived task, is rejected (state untouched); an enabled rule computes the
+		* next run instant immediately, a disabled one carries no next-run instant.
 		* @param tasks - current ledger.
 		* @param id - the task to schedule.
 		* @param patch - rule fields to change (absent fields keep their current value).
@@ -376,7 +409,7 @@ window.__ModuleLoader__.load({
 		*/
 		function applySetSchedule(tasks, id, patch, now) {
 			const task = tasks.find((candidate) => candidate.id === id);
-			if (task === void 0) return {
+			if (task === void 0 || task.archivedAt !== void 0) return {
 				tasks,
 				applied: false
 			};
@@ -388,6 +421,10 @@ window.__ModuleLoader__.load({
 			};
 			const enabled = patch.enabled ?? current?.enabled ?? false;
 			const nextRunAt = enabled ? nextRunAtMs(cron, now) : void 0;
+			if (enabled && nextRunAt === void 0) return {
+				tasks,
+				applied: false
+			};
 			return {
 				tasks: tasks.map((candidate) => candidate.id === id ? withSchedule(candidate, {
 					enabled,
@@ -408,7 +445,7 @@ window.__ModuleLoader__.load({
 		* @param now - clock instant (ms epoch).
 		*/
 		function applyScheduleNextRun(tasks, id, nextRunAt, lastTriggeredAt, now) {
-			return tasks.map((task) => task.id === id && task.schedule !== void 0 ? withSchedule(task, {
+			return tasks.map((task) => task.id === id && task.archivedAt === void 0 && task.schedule !== void 0 ? withSchedule(task, {
 				nextRunAt,
 				lastTriggeredAt
 			}, now) : task);
@@ -476,6 +513,9 @@ window.__ModuleLoader__.load({
 		function currentOf(sessions) {
 			return sessions.list.getSnapshot().current;
 		}
+		function messageOf(error) {
+			return error instanceof Error ? error.message : String(error);
+		}
 		/**
 		* Board controller (see module doc). All mutations bump the snapshot and
 		* persist through the store; UI and DOM mounts subscribe and re-render.
@@ -494,6 +534,12 @@ window.__ModuleLoader__.load({
 			disposers = [];
 			now;
 			uuid;
+			pendingTaskIds = /* @__PURE__ */ new Set();
+			taskQueues = /* @__PURE__ */ new Map();
+			transportError;
+			hostState;
+			remoteSubscribed = false;
+			remoteInitialization;
 			/** @param deps - store, execution service, and the sessions navigation face. */
 			constructor(deps) {
 				this.deps = deps;
@@ -503,11 +549,12 @@ window.__ModuleLoader__.load({
 			/** Load the persisted ledger and start the navigation/status subscriptions. */
 			start() {
 				this.tasks = this.deps.store.load();
-				this.reconcileRunningTasks();
-				const unsubscribeExternal = this.deps.store.subscribeExternal?.(() => {
+				if (this.deps.transport !== void 0) this.initializeRemote();
+				else this.reconcileRunningTasks();
+				const unsubscribeExternal = this.deps.transport === void 0 ? this.deps.store.subscribeExternal?.(() => {
 					this.tasks = this.deps.store.load();
 					this.notify();
-				});
+				}) : void 0;
 				if (unsubscribeExternal !== void 0) this.disposers.push(unsubscribeExternal);
 				this.disposers.push(this.deps.sessions.list.subscribe(() => {
 					this.onSessionsChanged();
@@ -527,7 +574,10 @@ window.__ModuleLoader__.load({
 					boardOpen: this.boardOpen,
 					archiveView: this.archiveView,
 					selectedTaskId: this.selectedTaskId,
-					executionOptions: this.executionOptions
+					executionOptions: this.executionOptions,
+					pendingTaskIds: [...this.pendingTaskIds],
+					...this.transportError === void 0 ? {} : { transportError: this.transportError },
+					...this.hostState === void 0 ? {} : { host: this.hostState }
 				};
 			}
 			subscribe(fn) {
@@ -536,6 +586,14 @@ window.__ModuleLoader__.load({
 					this.listeners.delete(fn);
 				};
 			}
+			/** Whether production mutations are confirmed by the Host transport. */
+			isHostBacked() {
+				return this.deps.transport !== void 0;
+			}
+			/** Retry initial migration/state synchronization after an explicit Host error. */
+			async retryHostSync() {
+				return await this.initializeRemote();
+			}
 			openBoard() {
 				if (this.boardOpen) return;
 				this.lastCurrent = currentOf(this.deps.sessions);
@@ -575,13 +633,33 @@ window.__ModuleLoader__.load({
 				this.notify();
 			}
 			createTask(input) {
-				const { task, tasks } = applyCreateTask(this.tasks, input, this.now(), this.uuid());
+				const id = this.uuid();
+				const { task, tasks } = applyCreateTask(this.tasks, input, this.now(), id);
 				if (task === void 0) return void 0;
 				this.tasks = [...tasks];
 				this.persistAndNotify();
 				return task;
 			}
+			/** Create through the Host and expose the task only after confirmation. */
+			async createTaskConfirmed(input) {
+				if (this.deps.transport === void 0) return this.createTask(input);
+				const id = this.uuid();
+				if (applyCreateTask(this.tasks, input, this.now(), id).task === void 0) return void 0;
+				return await this.commitRemote({
+					kind: "create",
+					id,
+					input
+				}, id) ? this.tasks.find((task) => task.id === id) : void 0;
+			}
 			updateTask(id, patch) {
+				if (this.deps.transport !== void 0) {
+					this.commitRemote({
+						kind: "update",
+						taskId: id,
+						patch
+					}, id);
+					return;
+				}
 				this.tasks = [...applyUpdateTask(this.tasks, id, patch, this.now())];
 				this.persistAndNotify();
 			}
@@ -597,10 +675,25 @@ window.__ModuleLoader__.load({
 				this.notify();
 			}
 			moveTask(id, status) {
+				if (this.deps.transport !== void 0) {
+					this.commitRemote({
+						kind: "move",
+						taskId: id,
+						status
+					}, id);
+					return;
+				}
 				this.tasks = this.tasks.map((task) => task.id === id ? withStatus(task, status, this.now()) : task);
 				this.persistAndNotify();
 			}
 			deleteTask(id) {
+				if (this.deps.transport !== void 0) {
+					this.commitRemote({
+						kind: "delete",
+						taskId: id
+					}, id);
+					return;
+				}
 				const { tasks, selectionCleared } = applyDeleteTask(this.tasks, this.selectedTaskId, id);
 				this.tasks = [...tasks];
 				if (selectionCleared) this.selectedTaskId = void 0;
@@ -615,6 +708,13 @@ window.__ModuleLoader__.load({
 			archiveTask(id) {
 				const { tasks, archived } = applyArchiveTask(this.tasks, id, this.now());
 				if (!archived) return false;
+				if (this.deps.transport !== void 0) {
+					this.commitRemote({
+						kind: "archive",
+						taskId: id
+					}, id);
+					return true;
+				}
 				this.tasks = [...tasks];
 				this.persistAndNotify();
 				return true;
@@ -623,7 +723,17 @@ window.__ModuleLoader__.load({
 			restoreTask(id) {
 				const { tasks, archived } = applyRestoreTask(this.tasks, id, this.now());
 				if (!archived) return false;
+				if (this.deps.transport !== void 0) {
+					this.commitRemote({
+						kind: "restore",
+						taskId: id
+					}, id).then((restored) => {
+						if (restored && this.selectedTaskId === id) this.closeTask();
+					});
+					return true;
+				}
 				this.tasks = [...tasks];
+				if (this.selectedTaskId === id) this.selectedTaskId = void 0;
 				this.persistAndNotify();
 				return true;
 			}
@@ -639,14 +749,21 @@ window.__ModuleLoader__.load({
 			setSchedule(id, patch) {
 				const { tasks, applied } = applySetSchedule(this.tasks, id, patch, this.now());
 				if (!applied) return false;
+				if (this.deps.transport !== void 0) {
+					this.commitRemote({
+						kind: "set-schedule",
+						taskId: id,
+						patch
+					}, id);
+					return true;
+				}
 				this.tasks = [...tasks];
 				this.persistAndNotify();
 				return true;
 			}
 			/**
-			* Roll a task's schedule forward (scheduler callback): persist the next due
-			* instant and the trigger instant of this run. No-op when the task has no
-			* schedule rule (it was deleted mid-tick, for example).
+			* Legacy pure-controller seam retained for migration-focused tests. The
+			* production browser never rolls schedules; the Host ledger owns them.
 			*/
 			applyScheduleNextRun(id, nextRunAt, lastTriggeredAt) {
 				const next = applyScheduleNextRun(this.tasks, id, nextRunAt, lastTriggeredAt, this.now());
@@ -654,12 +771,8 @@ window.__ModuleLoader__.load({
 				this.persistAndNotify();
 			}
 			/**
-			* Reload the ledger from the persisted store without notifying subscribers.
-			* The scheduler calls this before every tick so a task deleted in another
-			* tab (or a stale in-memory copy) can never be fired from this tab: the
-			* fire decision and the subsequent roll-forward both run on the freshest
-			* persisted truth. Deliberately silent — same-origin external changes still
-			* reach subscribers through the storage-event subscription.
+			* Reload the legacy v1 store without notifying subscribers. Production v2
+			* reads Host snapshots instead; this remains only for isolated legacy tests.
 			*/
 			reloadFromStore() {
 				this.tasks = this.deps.store.load();
@@ -679,11 +792,16 @@ window.__ModuleLoader__.load({
 			*/
 			async runTask(id) {
 				const task = this.tasks.find((candidate) => candidate.id === id);
-				if (task === void 0 || task.status === "running") return false;
+				if (task === void 0 || task.archivedAt !== void 0 || task.status === "running") return false;
+				if (this.deps.transport !== void 0) return await this.commitRemote({
+					kind: "run",
+					taskId: id
+				}, id);
 				const { task: next, execution } = startExecution(task, this.now(), this.uuid());
 				this.tasks = this.tasks.map((candidate) => candidate.id === id ? next : candidate);
 				this.persistAndNotify();
 				this.activeExecutionIds.add(execution.id);
+				if (this.deps.exec === void 0) throw new Error("legacy execution service is unavailable");
 				await this.deps.exec.run(next, execution, (event) => {
 					this.handleExecutionEvent(event);
 				});
@@ -692,7 +810,14 @@ window.__ModuleLoader__.load({
 			/** Re-run a settled task: move it back to 'todo' first, then execute. */
 			async rerunTask(id) {
 				const task = this.tasks.find((candidate) => candidate.id === id);
-				if (task === void 0) return;
+				if (task === void 0 || task.archivedAt !== void 0) return;
+				if (this.deps.transport !== void 0) {
+					await this.commitRemote({
+						kind: "rerun",
+						taskId: id
+					}, id);
+					return;
+				}
 				if (task.status !== "running") {
 					this.tasks = this.tasks.map((candidate) => candidate.id === id ? withStatus(candidate, "todo", this.now()) : candidate);
 					this.persistAndNotify();
@@ -711,7 +836,7 @@ window.__ModuleLoader__.load({
 			}
 			/** Reconcile running tasks and close the board when the user navigates. */
 			onSessionsChanged() {
-				this.scheduleReconcile();
+				if (this.deps.transport === void 0) this.scheduleReconcile();
 				if (!this.boardOpen) return;
 				const current = currentOf(this.deps.sessions);
 				if (current !== this.lastCurrent) this.closeBoard();
@@ -739,6 +864,7 @@ window.__ModuleLoader__.load({
 			}
 			/** Settle tasks left 'running' whose sessions already finished. */
 			async reconcileRunningTasks() {
+				if (this.deps.exec === void 0) return;
 				if (this.reconcileInFlight) return;
 				this.reconcileInFlight = true;
 				try {
@@ -769,442 +895,120 @@ window.__ModuleLoader__.load({
 				}
 			}
 			persistAndNotify() {
-				this.deps.store.save(this.tasks);
+				if (this.deps.transport === void 0) this.deps.store.save(this.tasks);
 				this.notify();
 			}
-			notify() {
-				for (const fn of [...this.listeners]) fn();
-			}
-		};
-		/** Record which session ran an execution (once the execution service reports it). */
-		function attachSessionId(task, executionId, sessionId, now) {
-			return {
-				...task,
-				updatedAt: now,
-				executions: task.executions.map((execution) => execution.id === executionId ? {
-					...execution,
-					sessionId
-				} : execution)
-			};
-		}
-		//#endregion
-		//#region src/core/execution.ts
-		/** Human copy for a run failure. */
-		function messageOf(error) {
-			if (error instanceof Error) return error.message;
-			return String(error);
-		}
-		/**
-		* Whether a rejected preset switch actually means "the session already runs
-		* this preset" (the host's agent-preset-conflict with a matching
-		* existingPreset). A blank-session reuse race can produce this even though
-		* the requested composition is in place.
-		*/
-		function presetAlreadyRuns(error, mode) {
-			if (typeof error !== "object" || error === null) return false;
-			const details = error.details;
-			if (typeof details !== "object" || details === null) return false;
-			return details.existingPreset === mode;
-		}
-		/** Whether a `turn/end` payload closed the turn with an error reason. */
-		function isErrorTurnEnd(data) {
-			if (typeof data !== "object" || data === null) return false;
-			const reason = data.reason;
-			return typeof reason === "object" && reason !== null && reason.kind === "error";
-		}
-		/**
-		* Run one task to completion (or to a settled failure).
-		*
-		* @param task - the task being executed.
-		* @param execution - the freshly opened execution record (id + start time).
-		* @param onEvent - callback for started/settled events.
-		* @returns resolves when the run settles (or fails to start); never rejects —
-		*   every failure path is reported as a settled event.
-		*/
-		var ExecutionService = class {
-			env;
-			/**
-			* In-flight preset switches keyed by `sessionId\u0000mode`. The session
-			* list mirror can lag behind a just-applied switch, so concurrent runs
-			* against one blank session would otherwise each issue the same select
-			* RPC (an amplified storm); sharing one in-flight call keeps the wire to
-			* a single request. The settled entry is forgotten so a later run can
-			* switch again.
-			*/
-			presetSwitches = /* @__PURE__ */ new Map();
-			/** @param env - the runtime faces (real or fake). */
-			constructor(env) {
-				this.env = env;
-			}
-			async run(task, execution, onEvent) {
-				const settleFailed = (error) => {
-					onEvent({
-						kind: "settled",
-						taskId: task.id,
-						executionId: execution.id,
-						outcome: "failed",
-						error
-					});
-				};
+			async commitRemote(action, taskId) {
+				if (this.deps.transport === void 0) return true;
+				if (taskId === void 0) return await this.performRemote(action);
+				const operation = (this.taskQueues.get(taskId) ?? Promise.resolve()).catch(() => {}).then(async () => await this.performRemote(action));
+				const tail = operation.then(() => {}, () => {});
+				this.taskQueues.set(taskId, tail);
+				this.pendingTaskIds.add(taskId);
+				this.notify();
 				try {
-					const sessionId = await this.connectSession(task.workspaceId);
-					onEvent({
-						kind: "started",
-						taskId: task.id,
-						executionId: execution.id,
-						sessionId
-					});
-					const driver = this.driverOf(sessionId);
-					if (driver === void 0) {
-						settleFailed("execution session is not ready");
-						return;
-					}
-					if (!await this.applyMode(driver, task, sessionId, settleFailed)) return;
-					if (!await this.applyPermission(driver, task, settleFailed)) return;
-					await driver.rename(task.title).catch(() => {});
-					const baseline = driver.getSnapshot().turnEnds.size;
-					const accepted = await this.sendPrompt(driver, task);
-					if (!accepted.ok) {
-						settleFailed(messageOf(accepted.error));
-						return;
+					return await operation;
+				} finally {
+					if (this.taskQueues.get(taskId) === tail) {
+						this.taskQueues.delete(taskId);
+						this.pendingTaskIds.delete(taskId);
+						this.notify();
 					}
-					this.watchForSettlement(driver, task.id, execution.id, onEvent, baseline);
-				} catch (error) {
-					settleFailed(messageOf(error));
 				}
 			}
-			/**
-			* Recompose the execution session's agent from the task-pinned preset.
-			* No-op when the task pins none or the session already runs it; fails the
-			* run when the session is no longer blank, the preset face is missing, or
-			* the wire refuses.
-			*/
-			async applyMode(driver, task, sessionId, settleFailed) {
-				const mode = task.mode;
-				if (mode === void 0 || mode === "") return true;
-				const summary = this.env.sessions.list.getSnapshot().byId[sessionId];
-				if (summary?.blank === false) {
-					settleFailed(`cannot switch agent preset to ${mode}: the execution session is not blank`);
-					return false;
-				}
-				if (summary?.agentPreset === mode) return true;
-				const presets = this.env.presets;
-				if (presets === void 0) {
-					settleFailed(`this deployment does not support agent presets (task asks for ${mode})`);
-					return false;
-				}
+			async performRemote(action) {
+				const transport = this.deps.transport;
+				if (transport === void 0) return true;
+				this.transportError = void 0;
+				this.notify();
 				try {
-					const result = await this.switchPreset(presets, sessionId, mode);
-					if (!result.ok) {
-						if (presetAlreadyRuns(result.error, mode)) {
-							this.env.sessions.noteAgentPreset?.(sessionId, mode);
-							return true;
-						}
-						settleFailed(`agent preset switch to ${mode} rejected: ${messageOf(result.error)}`);
-						return false;
-					}
+					return this.acceptRemote(await transport.action(action)) || await this.refreshRemote();
 				} catch (error) {
-					settleFailed(`agent preset switch to ${mode} failed: ${messageOf(error)}`);
+					await this.refreshRemote(messageOf(error));
 					return false;
 				}
-				this.env.sessions.noteAgentPreset?.(sessionId, mode);
-				return true;
-			}
-			/**
-			* One in-flight `select` per (session, preset): concurrent runs against
-			* the same blank session share the same wire call instead of each issuing
-			* a duplicate RPC. The entry is removed once the call settles, so a later
-			* run (after a shared failure, say) issues a fresh switch.
-			*/
-			switchPreset(presets, sessionId, mode) {
-				const key = `${sessionId}\u0000${mode}`;
-				const inflight = this.presetSwitches.get(key);
-				if (inflight !== void 0) return inflight;
-				const attempt = presets.select(sessionId, mode).finally(() => {
-					if (this.presetSwitches.get(key) === attempt) this.presetSwitches.delete(key);
-				});
-				this.presetSwitches.set(key, attempt);
-				return attempt;
 			}
-			/**
-			* Apply the task-pinned permission preset through the `/permission <id>`
-			* slash command. No-op when the task pins none; fails the run when the
-			* admission is rejected or no command claimed the line.
-			*/
-			async applyPermission(driver, task, settleFailed) {
-				const permission = task.permission;
-				if (permission === void 0) return true;
-				const line = `/permission ${permission}`;
+			async initializeRemote() {
+				if (this.remoteInitialization !== void 0) return await this.remoteInitialization;
+				const initialization = this.doInitializeRemote();
+				this.remoteInitialization = initialization;
 				try {
-					const result = await driver.command(line);
-					if (!result.ok) {
-						settleFailed(`permission command rejected: ${messageOf(result.error)}`);
-						return false;
-					}
-					if (!result.matched) {
-						settleFailed(`permission command not recognized: ${line}`);
-						return false;
-					}
-				} catch (error) {
-					settleFailed(`permission command failed: ${messageOf(error)}`);
-					return false;
-				}
-				return true;
-			}
-			/**
-			* Inspect a reloaded/background task that was left 'running' and emit a
-			* settled event when its session already finished.
-			*
-			* A session that was never opened keeps a cold conversation snapshot (the
-			* runtime only maintains the window for the staged/current session), so the
-			* settled outcome is decided by the strongest available signal, in order:
-			* 1. the list summary — missing session → cancelled; still running → pending;
-			* 2. a warm conversation snapshot → `lastAgentError` decides failed/succeeded;
-			* 3. the raw history tail (when a history face is wired) — a `turn/end`
-			*    error reason proves failure;
-			* 4. otherwise a finished session counts as succeeded.
-			*
-			* @param task - a task whose latest execution has no endedAt.
-			* @returns a settled event when the session state proves completion, else undefined.
-			*/
-			async reconcile(task) {
-				const execution = task.executions[task.executions.length - 1];
-				if (execution === void 0 || execution.sessionId === void 0 || execution.endedAt !== void 0) return void 0;
-				const list = this.env.sessions.list.getSnapshot();
-				if (list.phase !== "ready") return void 0;
-				const summary = list.byId[execution.sessionId];
-				if (summary === void 0) return {
-					kind: "settled",
-					taskId: task.id,
-					executionId: execution.id,
-					outcome: "cancelled",
-					error: "execution session no longer exists"
-				};
-				if (summary.running) return void 0;
-				const driver = this.driverOf(execution.sessionId);
-				if (driver !== void 0) {
-					const snapshot = driver.getSnapshot();
-					if (snapshot.turnEnds.size > 0) {
-						const outcome = snapshot.lastAgentError !== null ? "failed" : "succeeded";
-						return {
-							kind: "settled",
-							taskId: task.id,
-							executionId: execution.id,
-							outcome,
-							error: snapshot.lastAgentError ?? void 0
-						};
-					}
+					return await initialization;
+				} finally {
+					if (this.remoteInitialization === initialization) this.remoteInitialization = void 0;
 				}
-				if (await this.historyShowsFailure(execution.sessionId)) return {
-					kind: "settled",
-					taskId: task.id,
-					executionId: execution.id,
-					outcome: "failed",
-					error: "agent turn failed"
-				};
-				return {
-					kind: "settled",
-					taskId: task.id,
-					executionId: execution.id,
-					outcome: "succeeded"
-				};
 			}
-			/** Best-effort failure probe over the raw history tail (false when unavailable). */
-			async historyShowsFailure(sessionId) {
-				const history = this.env.history;
-				if (history === void 0) return false;
+			async doInitializeRemote() {
+				const transport = this.deps.transport;
+				if (transport === void 0) return true;
 				try {
-					const tail = await history.loadTail(sessionId);
-					if (tail === void 0) return false;
-					return tail.events.some((event) => event.type === "turn/end" && isErrorTurnEnd(event.data));
+					this.acceptRemote(await transport.bootstrap(this.tasks));
+					if (!this.remoteSubscribed) {
+						this.remoteSubscribed = true;
+						this.disposers.push(transport.subscribe(() => {
+							this.refreshRemote();
+						}));
+					}
+					return true;
 				} catch (error) {
-					console.error("[dsh-task-board] history failure probe failed", error);
+					this.transportError = messageOf(error);
+					this.notify();
 					return false;
 				}
 			}
-			async connectSession(taskWorkspaceId) {
-				const workspace = this.env.workspaces.list.getSnapshot();
-				if (taskWorkspaceId !== void 0 && taskWorkspaceId !== "") {
-					if (!workspace.items.some((item) => item.workspaceId === taskWorkspaceId)) throw new Error(`task workspace is not available: ${taskWorkspaceId}`);
-					return this.env.workspaces.connectWorkspace(taskWorkspaceId);
-				}
-				const workspaceId = workspace.recentWorkspaceId ?? workspace.items[0]?.workspaceId;
-				if (workspaceId === void 0) throw new Error("no workspace available to run the task in");
-				return this.env.workspaces.connectWorkspace(workspaceId);
-			}
-			driverOf(sessionId) {
-				return this.env.sessions.binding(sessionId)?.session;
-			}
-			async sendPrompt(driver, task) {
-				const text = task.prompt.trim() !== "" ? task.prompt : task.title;
+			async refreshRemote(preserveError) {
+				const transport = this.deps.transport;
+				if (transport === void 0) return true;
 				try {
-					return await driver.prompt([{
-						type: "text",
-						text
-					}], "queue");
+					this.acceptRemote(await transport.state());
+					if (preserveError !== void 0) {
+						this.transportError = preserveError;
+						this.notify();
+					}
+					return true;
 				} catch (error) {
-					return {
-						ok: false,
-						error
-					};
+					this.transportError = preserveError ?? messageOf(error);
+					this.notify();
+					return false;
 				}
 			}
-			/**
-			* Subscribe to the execution session and settle the run once the accepted
-			* turn completes (turn counter advanced past the acceptance baseline and
-			* the session is no longer running). Never settles while the session is
-			* still running; unsubscribes on settle.
-			*/
-			watchForSettlement(driver, taskId, executionId, onEvent, baseline) {
-				let settled = false;
-				let unsubscribe = () => {};
-				const check = () => {
-					if (settled) return;
-					const snapshot = driver.getSnapshot();
-					if (snapshot.running || snapshot.turnEnds.size <= baseline) return;
-					settled = true;
-					unsubscribe();
-					onEvent({
-						kind: "settled",
-						taskId,
-						executionId,
-						outcome: snapshot.lastAgentError !== null ? "failed" : "succeeded",
-						error: snapshot.lastAgentError ?? void 0
-					});
+			acceptRemote(snapshot) {
+				if (this.hostState?.scheduler.ledgerId === snapshot.scheduler.ledgerId && this.hostState !== void 0 && snapshot.revision < this.hostState.revision) return false;
+				this.tasks = [...snapshot.tasks];
+				this.hostState = {
+					revision: snapshot.revision,
+					scheduler: snapshot.scheduler,
+					power: snapshot.power
 				};
-				unsubscribe = driver.subscribe(check);
-				check();
-			}
-		};
-		//#endregion
-		//#region src/core/scheduler.ts
-		/**
-		* Browser-side scheduler: the heartbeat behind scheduled task runs.
-		*
-		* The board is a pure client plugin with no server channel, so "定时任务"
-		* lives in the tab: a timer ticks every minute (plus immediately on tab
-		* visibility recovery) and triggers any task whose `schedule.nextRunAt` is
-		* due, rolling the schedule forward to the next cron match before triggering
-		* so the same tick never double-fires. Missed runs are skipped, never queued:
-		* a task still running at its due instant is skipped by the controller's
-		* runTask guard and simply waits for the next cron match.
-		*
-		* A deleted task can never fire again from a stale in-memory copy: every
-		* tick first re-reads the persisted ledger through the optional `refresh`
-		* hook (the controller reloads its store), so the fire decision and the
-		* subsequent roll-forward both run on the freshest persisted truth.
-		*
-		* The ticker is controlled: `start` arms a single interval guarded by an
-		* idempotence check (a second start while running is a no-op, so wiring can
-		* never leak a duplicate timer), and `stop`/`dispose` clear the timer and
-		* drop the environment listeners. The board unmount path calls stop/dispose,
-		* so no interval or listener outlives the board.
-		*
-		* Framework-free: all runtime access flows through the injected deps
-		* (structural faces), so tests drive ticks directly without timers.
-		*/
-		/**
-		* The schedule heartbeat (see module doc). `tick` is public so tests and
-		* callers can drive a check without waiting for the interval.
-		*/
-		var SchedulerService = class {
-			deps;
-			timer;
-			environmentListener;
-			disposed = false;
-			started = false;
-			/** Cron expressions that matched no instant in the scan window, per task —
-			*  remembered so a never-matching rule is not re-scanned on every tick. */
-			unmatchableRepair = /* @__PURE__ */ new Map();
-			/** @param deps - tasks/clock/trigger/apply faces (see {@link SchedulerDeps}). */
-			constructor(deps) {
-				this.deps = deps;
-			}
-			/**
-			* Start ticking: one immediate check (catch-up after reload) + the interval.
-			* Single-instance: a second start while already armed is a no-op, so a
-			* re-entrant mount can never stack a duplicate timer.
-			*/
-			start() {
-				if (this.disposed) return;
-				if (this.started) return;
-				this.started = true;
-				this.tick();
-				this.timer = setInterval(() => {
-					this.tick();
-				}, this.deps.tickMs ?? 6e4);
-				if (this.deps.environment !== void 0) {
-					this.environmentListener = () => {
-						this.tick();
-					};
-					this.deps.environment.addEventListener("visibilitychange", this.environmentListener);
-				}
-			}
-			/**
-			* Stop ticking and drop listeners (idempotent). Preferred shutdown verb for
-			* callers that treat the scheduler as a controlled ticker; `dispose` is an
-			* alias.
-			*/
-			stop() {
-				this.dispose();
-			}
-			/** Stop ticking and drop listeners (idempotent). */
-			dispose() {
-				if (this.disposed && this.timer === void 0 && this.environmentListener === void 0) return;
-				this.disposed = true;
-				this.started = false;
-				if (this.timer !== void 0) {
-					clearInterval(this.timer);
-					this.timer = void 0;
-				}
-				if (this.environmentListener !== void 0 && this.deps.environment !== void 0) {
-					this.deps.environment.removeEventListener("visibilitychange", this.environmentListener);
-					this.environmentListener = void 0;
-				}
+				this.transportError = void 0;
+				if (this.selectedTaskId !== void 0 && !this.tasks.some((task) => task.id === this.selectedTaskId)) this.selectedTaskId = void 0;
+				if (!this.archiveView && this.selectedTaskId !== void 0 && this.tasks.find((task) => task.id === this.selectedTaskId)?.archivedAt !== void 0) this.selectedTaskId = void 0;
+				this.notify();
+				return true;
 			}
-			/**
-			* Check every enabled schedule and trigger the due ones. Idempotent per
-			* task per tick: the schedule is rolled forward only after runTask accepts
-			* the run, so a rejected run keeps its due slot and is retried on the next
-			* tick instead of being silently dropped.
-			*/
-			async tick() {
-				if (this.disposed) return;
-				if (this.deps.ready !== void 0 && !this.deps.ready()) return;
-				this.deps.refresh?.();
-				const now = this.deps.now();
-				for (const task of this.deps.tasks()) {
-					const schedule = task.schedule;
-					if (schedule === void 0 || !schedule.enabled) continue;
-					if (schedule.nextRunAt === void 0) {
-						if (this.unmatchableRepair.get(task.id) === schedule.cron) continue;
-						const repaired = nextRunAtMs(schedule.cron, now);
-						if (repaired === void 0) {
-							this.unmatchableRepair.set(task.id, schedule.cron);
-							continue;
-						}
-						this.unmatchableRepair.delete(task.id);
-						this.deps.applySchedule(task.id, repaired, void 0);
-						continue;
-					}
-					if (schedule.nextRunAt > now) continue;
-					const next = nextRunAtMs(schedule.cron, schedule.nextRunAt);
-					if (await this.deps.runTask(task.id)) this.deps.applySchedule(task.id, next, now);
-				}
+			notify() {
+				for (const fn of [...this.listeners]) fn();
 			}
 		};
+		/** Record which session ran an execution (once the execution service reports it). */
+		function attachSessionId(task, executionId, sessionId, now) {
+			return {
+				...task,
+				updatedAt: now,
+				executions: task.executions.map((execution) => execution.id === executionId ? {
+					...execution,
+					sessionId
+				} : execution)
+			};
+		}
 		//#endregion
 		//#region src/core/store.ts
 		/**
-		* Task persistence: a small storage seam with a localStorage backend.
+		* Legacy v1 browser persistence and the store seam used by pure client tests.
 		*
-		* The task-board client plugin runs in the browser, and dsh exposes no
-		* browser-writable file channel (same conclusion the skin-center research
-		* reached for cordis.patch.yml), so tasks persist in the browser's
-		* localStorage under a versioned key — the same persistence mechanism dsh's
-		* own client snapshot stores use (`createSnapshotStore` persist). Data
-		* survives page refreshes and dsh restarts (same origin), and survives
-		* plugin uninstall (the key is simply left in place).
+		* Production v2 state is Host-authoritative. This backend is retained only to
+		* read `dsh.taskBoard.v1` for one-time import; the old value is never removed,
+		* so it remains a read-only rollback copy after migration.
 		*
 		* The seam keeps the backend swappable (e.g. an IndexedDB or a host-file
 		* channel later); tests run against the in-memory backend and a jsdom
@@ -1402,8 +1206,12 @@ window.__ModuleLoader__.load({
 			"board.status.done": "已完成",
 			"board.status.failed": "已失败",
 			"board.runs": "次执行",
+			"board.pending": "正在提交",
 			"board.updated": "更新于",
 			"board.created": "创建于",
+			"board.hostError": "Host 操作失败：{error}",
+			"board.retryHost": "重试连接 Host",
+			"board.hostMeta": "Host 时区 {timeZone} · revision {revision}",
 			"new.title": "标题",
 			"new.titlePlaceholder": "一句话描述要做什么",
 			"new.description": "描述",
@@ -1472,11 +1280,17 @@ window.__ModuleLoader__.load({
 			"detail.executionSettings": "执行设置",
 			"exec.hint": "执行时生效：工作区决定执行会话落在哪个工作区；模式决定会话的 agent 预设；权限经 /permission 命令应用到会话。留空则使用运行时默认。",
 			"settings.title": "任务看板",
-			"settings.description": "控制看板在 agent 系统提示中的播报行为。",
+			"settings.description": "控制 Host 任务看板、agent 播报与运行期间的系统空闲睡眠保护。",
 			"settings.enabled": "启用任务看板",
 			"settings.enabledHint": "关闭后隐藏侧边栏入口与看板视图。",
 			"settings.announceToAgent": "向 agent 播报任务看板",
 			"settings.announceToAgentHint": "开启：每条 agent 系统提示都会包含本看板的说明；关闭：不播报，agent 仅在用户主动提及时了解看板。",
+			"settings.preventIdleSleep": "阻止系统空闲睡眠",
+			"settings.preventIdleSleepHint": "默认关闭。开启后，只要存在运行中的 DSH 会话、已启用的定时任务或会话状态尚未确认，Host 就阻止整机因空闲睡眠；屏幕仍可自动关闭。",
+			"settings.powerStatus": "平台：{platform}；保护状态：{phase}；运行会话：{running}；已启用计划：{schedules}",
+			"settings.powerBoundary": "这可能增加电池消耗。合盖、手动睡眠、休眠、关机、低电量或企业策略不在保证范围内，也不会唤醒已经睡眠的机器。",
+			"settings.powerUnknown": "未知",
+			"settings.powerError": "最近一次电源保护错误：{error}",
 			"settings.inherit": "继承",
 			"settings.on": "开",
 			"settings.off": "关",
@@ -1513,8 +1327,12 @@ window.__ModuleLoader__.load({
 			"board.status.done": "Done",
 			"board.status.failed": "Failed",
 			"board.runs": "runs",
+			"board.pending": "Submitting",
 			"board.updated": "Updated",
 			"board.created": "Created",
+			"board.hostError": "Host action failed: {error}",
+			"board.retryHost": "Retry Host connection",
+			"board.hostMeta": "Host time zone {timeZone} · revision {revision}",
 			"new.title": "Title",
 			"new.titlePlaceholder": "What should be done, in one line",
 			"new.description": "Description",
@@ -1583,11 +1401,17 @@ window.__ModuleLoader__.load({
 			"detail.executionSettings": "Execution Settings",
 			"exec.hint": "Applied when the task runs: the workspace decides where the execution session lands; the mode composes the session's agent preset; the permission is applied through the /permission command. Blank = runtime default.",
 			"settings.title": "Task Board",
-			"settings.description": "How the board announces itself in each agent system prompt.",
+			"settings.description": "Configure the Host task board, agent announcement, and idle-system-sleep protection while work is pending.",
 			"settings.enabled": "Enable the task board",
 			"settings.enabledHint": "When off, the sidebar entry and board view are hidden.",
 			"settings.announceToAgent": "Announce the task board to agents",
 			"settings.announceToAgentHint": "On: every agent system prompt includes a note about this board. Off: no announcement; agents learn about the board only when you mention it.",
+			"settings.preventIdleSleep": "Prevent idle system sleep",
+			"settings.preventIdleSleepHint": "Off by default. When enabled, the Host prevents idle system sleep while any DSH session runs, any schedule is enabled, or session state is not yet known. The display may still turn off.",
+			"settings.powerStatus": "Platform: {platform}; protection: {phase}; running sessions: {running}; enabled schedules: {schedules}",
+			"settings.powerBoundary": "This may use more battery. Lid close, manual sleep, hibernation, shutdown, low-battery actions, and enterprise policy are outside the guarantee; an already sleeping computer is not woken.",
+			"settings.powerUnknown": "unknown",
+			"settings.powerError": "Latest power-protection error: {error}",
 			"settings.inherit": "Inherit",
 			"settings.on": "On",
 			"settings.off": "Off",
@@ -1717,7 +1541,7 @@ window.__ModuleLoader__.load({
 		//#region src/client/board/NewTaskModal.tsx
 		/**
 		* New-task modal: title + description + the prompt that execution will send.
-		* Creates through the controller (which persists immediately).
+		* Creates through the Host and closes only after the Host confirms it.
 		*/
 		/** New-task form overlay. */
 		function NewTaskModal({ controller, onClose }) {
@@ -1731,9 +1555,10 @@ window.__ModuleLoader__.load({
 			const [scheduleCron, setScheduleCron] = (0, react.useState)("");
 			const [scheduleError, setScheduleError] = (0, react.useState)(void 0);
 			const [error, setError] = (0, react.useState)(void 0);
+			const [pending, setPending] = (0, react.useState)(false);
 			const [options, setOptions] = (0, react.useState)(controller.getSnapshot().executionOptions);
 			(0, react.useEffect)(() => controller.subscribe(() => setOptions(controller.getSnapshot().executionOptions)), [controller]);
-			const submit = () => {
+			const submit = async () => {
 				if (scheduleEnabled) {
 					const cron = scheduleCron.trim();
 					if (cron === "" || !isValidCron(cron)) {
@@ -1741,7 +1566,8 @@ window.__ModuleLoader__.load({
 						return;
 					}
 				}
-				if (controller.createTask({
+				setPending(true);
+				if (await controller.createTaskConfirmed({
 					title,
 					description,
 					prompt,
@@ -1753,7 +1579,8 @@ window.__ModuleLoader__.load({
 						cron: scheduleCron.trim()
 					} : void 0
 				}) === void 0) {
-					setError(t("new.required"));
+					setPending(false);
+					setError(controller.getSnapshot().transportError ?? t("new.required"));
 					return;
 				}
 				onClose();
@@ -1964,6 +1791,7 @@ window.__ModuleLoader__.load({
 							}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
 								type: "submit",
 								className: board_module_css_default.primaryButton,
+								disabled: pending,
 								children: t("new.submit")
 							})]
 						})
@@ -1993,22 +1821,36 @@ window.__ModuleLoader__.load({
 		* by the board, so the memo boundary is effective.
 		*/
 		/** Compact relative/absolute time label. */
-		function formatTime(ms) {
+		function formatHostTimestamp(ms, timeZone) {
+			try {
+				return new Intl.DateTimeFormat(void 0, {
+					dateStyle: "medium",
+					timeStyle: "medium",
+					...timeZone === void 0 ? {} : { timeZone }
+				}).format(new Date(ms));
+			} catch {
+				return new Date(ms).toISOString();
+			}
+		}
+		function formatTime(ms, timeZone) {
 			const date = new Date(ms);
 			const minutes = Math.floor((Date.now() - ms) / 6e4);
 			if (minutes < 1) return t("time.justNow");
 			if (minutes < 60) return `${minutes}m`;
 			if (minutes < 1440) return `${Math.floor(minutes / 60)}h`;
+			if (timeZone !== void 0) return formatHostTimestamp(ms, timeZone);
 			return `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, "0")}-${String(date.getDate()).padStart(2, "0")}`;
 		}
 		/** One card in a column. */
-		function TaskCardInner({ task, onClick }) {
+		function TaskCardInner({ task, pending, timeZone, onClick }) {
 			const latest = task.executions[task.executions.length - 1];
 			const runs = task.executions.length;
+			const archived = task.archivedAt !== void 0;
 			return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("button", {
 				type: "button",
 				className: board_module_css_default.card,
-				"data-status": task.status,
+				"data-status": archived ? "archived" : task.status,
+				"data-pending": pending || void 0,
 				onClick,
 				title: task.description !== "" ? task.description : task.title,
 				children: [
@@ -2031,14 +1873,14 @@ window.__ModuleLoader__.load({
 									formatTime(task.updatedAt)
 								]
 							}),
-							task.schedule?.enabled === true && /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+							!archived && task.schedule?.enabled === true && /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
 								className: board_module_css_default.cardSchedule,
-								title: task.schedule.nextRunAt !== void 0 ? `${t("card.scheduled")} · ${new Date(task.schedule.nextRunAt).toLocaleString()}` : t("card.scheduled"),
+								title: task.schedule.nextRunAt !== void 0 ? `${t("card.scheduled")} · ${formatHostTimestamp(task.schedule.nextRunAt, timeZone)}` : t("card.scheduled"),
 								children: t("card.scheduled")
 							}),
 							latest !== void 0 && /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("span", {
 								className: board_module_css_default.cardRun,
-								"data-result": latest.result,
+								"data-result": archived ? void 0 : latest.result,
 								children: [
 									runs,
 									" ",
@@ -2050,13 +1892,17 @@ window.__ModuleLoader__.load({
 								title: latest.sessionId,
 								children: "⌁"
 							}),
-							task.status === "running" && /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+							!archived && (task.status === "running" || pending) && /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
 								className: board_module_css_default.cardSpinner,
 								"aria-hidden": "true"
 							})
 						]
 					}),
-					latest !== void 0 && executionLabel(latest) === "running" && /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("span", {
+					!archived && pending && /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("span", {
+						className: board_module_css_default.cardRunningLabel,
+						children: [t("board.pending"), "…"]
+					}),
+					!archived && latest !== void 0 && executionLabel(latest) === "running" && /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("span", {
 						className: board_module_css_default.cardRunningLabel,
 						children: [t("detail.result.running"), "…"]
 					})
@@ -2123,7 +1969,7 @@ window.__ModuleLoader__.load({
 			cancelled: "detail.result.cancelled"
 		};
 		/** One execution-history row. */
-		function ExecutionRow({ execution, onOpen }) {
+		function ExecutionRow({ execution, timeZone, onOpen }) {
 			const result = execution.result;
 			return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("li", {
 				className: board_module_css_default.executionRow,
@@ -2139,8 +1985,8 @@ window.__ModuleLoader__.load({
 						children: [
 							t("detail.executionStarted"),
 							" ",
-							formatTime(execution.startedAt),
-							execution.endedAt !== void 0 && ` · ${t("detail.executionEnded")} ${formatTime(execution.endedAt)}`
+							formatTime(execution.startedAt, timeZone),
+							execution.endedAt !== void 0 && ` · ${t("detail.executionEnded")} ${formatTime(execution.endedAt, timeZone)}`
 						]
 					}),
 					execution.sessionId !== void 0 && /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("button", {
@@ -2160,7 +2006,7 @@ window.__ModuleLoader__.load({
 			});
 		}
 		/** The execution-target editor: workspace / mode / permission pickers. */
-		function ExecutionSettingsSection({ controller, task }) {
+		function ExecutionSettingsSection({ controller, task, pending }) {
 			const [options, setOptions] = (0, react.useState)(controller.getSnapshot().executionOptions);
 			(0, react.useEffect)(() => controller.subscribe(() => setOptions(controller.getSnapshot().executionOptions)), [controller]);
 			const workspaceId = task.workspaceId ?? "";
@@ -2184,6 +2030,7 @@ window.__ModuleLoader__.load({
 						}), /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("select", {
 							className: board_module_css_default.select,
 							value: workspaceId,
+							disabled: pending,
 							onChange: (event) => {
 								controller.updateTask(task.id, { workspaceId: event.target.value });
 							},
@@ -2211,6 +2058,7 @@ window.__ModuleLoader__.load({
 						}), /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("select", {
 							className: board_module_css_default.select,
 							value: mode,
+							disabled: pending,
 							onChange: (event) => {
 								controller.updateTask(task.id, { mode: event.target.value });
 							},
@@ -2243,6 +2091,7 @@ window.__ModuleLoader__.load({
 						}), /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("select", {
 							className: board_module_css_default.select,
 							value: permission,
+							disabled: pending,
 							onChange: (event) => {
 								controller.updateTask(task.id, { permission: event.target.value === "" ? void 0 : event.target.value });
 							},
@@ -2259,13 +2108,14 @@ window.__ModuleLoader__.load({
 			});
 		}
 		/** The scheduled-runs editor: enable toggle, cron input + presets, next-run info. */
-		function ScheduleSection({ controller, task }) {
+		function ScheduleSection({ controller, task, pending }) {
 			const schedule = task.schedule;
 			const [cron, setCron] = (0, react.useState)(schedule?.cron ?? "0 9 * * *");
 			const [enabled, setEnabled] = (0, react.useState)(schedule?.enabled ?? false);
 			const [nextRunAt, setNextRunAt] = (0, react.useState)(schedule?.nextRunAt);
 			const [lastTriggeredAt, setLastTriggeredAt] = (0, react.useState)(schedule?.lastTriggeredAt);
 			const [error, setError] = (0, react.useState)(void 0);
+			const timeZone = controller.getSnapshot().host?.scheduler.timeZone;
 			(0, react.useEffect)(() => {
 				setCron(schedule?.cron ?? "0 9 * * *");
 				setEnabled(schedule?.enabled ?? false);
@@ -2298,8 +2148,10 @@ window.__ModuleLoader__.load({
 					return;
 				}
 				setError(void 0);
-				if (next && trimmed !== schedule?.cron) controller.setSchedule(task.id, { cron: trimmed });
-				if (controller.setSchedule(task.id, { enabled: next })) setEnabled(next);
+				if (controller.setSchedule(task.id, {
+					enabled: next,
+					...next && trimmed !== schedule?.cron ? { cron: trimmed } : {}
+				}) && !controller.isHostBacked()) setEnabled(next);
 			};
 			const applyPreset = (preset) => {
 				if (preset === "") return;
@@ -2307,8 +2159,8 @@ window.__ModuleLoader__.load({
 				setError(void 0);
 				controller.setSchedule(task.id, { cron: preset });
 			};
-			const nextLabel = !enabled || nextRunAt === void 0 ? t("detail.schedule.notScheduled") : nextRunAt <= Date.now() ? t("detail.schedule.dueSoon") : new Date(nextRunAt).toLocaleString();
-			const lastLabel = lastTriggeredAt === void 0 ? "—" : new Date(lastTriggeredAt).toLocaleString();
+			const nextLabel = !enabled || nextRunAt === void 0 ? t("detail.schedule.notScheduled") : nextRunAt <= Date.now() ? t("detail.schedule.dueSoon") : formatHostTimestamp(nextRunAt, timeZone);
+			const lastLabel = lastTriggeredAt === void 0 ? "—" : formatHostTimestamp(lastTriggeredAt, timeZone);
 			return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("section", {
 				className: board_module_css_default.detailSection,
 				children: [
@@ -2318,6 +2170,7 @@ window.__ModuleLoader__.load({
 						children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("input", {
 							type: "checkbox",
 							checked: enabled,
+							disabled: pending,
 							onChange: (event) => {
 								toggleEnabled(event.target.checked);
 							}
@@ -2328,6 +2181,7 @@ window.__ModuleLoader__.load({
 						children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("input", {
 							className: `${board_module_css_default.input} ${board_module_css_default.scheduleInput}${error !== void 0 ? ` ${board_module_css_default.scheduleInputInvalid}` : ""}`,
 							value: cron,
+							disabled: pending,
 							placeholder: "0 9 * * *",
 							spellCheck: false,
 							"aria-label": t("detail.schedule.cron"),
@@ -2344,6 +2198,7 @@ window.__ModuleLoader__.load({
 						}), /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("select", {
 							className: board_module_css_default.schedulePreset,
 							value: "",
+							disabled: pending,
 							"aria-label": t("detail.schedule.presets"),
 							onChange: (event) => {
 								applyPreset(event.target.value);
@@ -2379,12 +2234,17 @@ window.__ModuleLoader__.load({
 		/** Task detail overlay. */
 		function TaskDetail({ controller, task }) {
 			const [confirmDelete, setConfirmDelete] = (0, react.useState)(false);
-			const running = task.status === "running";
 			const [latest, setLatest] = (0, react.useState)(task);
 			(0, react.useEffect)(() => {
 				setLatest(task);
 			}, [task]);
 			const current = latest;
+			const snapshot = controller.getSnapshot();
+			const running = current.status === "running";
+			const archived = current.archivedAt !== void 0;
+			const pending = snapshot.pendingTaskIds.includes(current.id);
+			const transportError = snapshot.transportError;
+			const timeZone = snapshot.host?.scheduler.timeZone;
 			return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
 				className: board_module_css_default.modalBackdrop,
 				onMouseDown: (event) => {
@@ -2404,8 +2264,8 @@ window.__ModuleLoader__.load({
 								}),
 								/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
 									className: board_module_css_default.statusBadge,
-									"data-status": current.status,
-									children: t(STATUS_KEY[current.status])
+									"data-status": archived ? "archived" : current.status,
+									children: archived ? t("board.archive") : t(STATUS_KEY[current.status])
 								}),
 								/* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
 									type: "button",
@@ -2421,6 +2281,21 @@ window.__ModuleLoader__.load({
 						/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
 							className: board_module_css_default.detailBody,
 							children: [
+								transportError !== void 0 && /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+									className: board_module_css_default.formError,
+									children: [
+										t("board.hostError", { error: transportError }),
+										" ",
+										/* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
+											type: "button",
+											className: board_module_css_default.linkButton,
+											onClick: () => {
+												controller.retryHostSync();
+											},
+											children: t("board.retryHost")
+										})
+									]
+								}),
 								/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("section", {
 									className: board_module_css_default.detailSection,
 									children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("h4", { children: t("detail.description") }), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
@@ -2435,14 +2310,15 @@ window.__ModuleLoader__.load({
 										children: current.prompt !== "" ? current.prompt : current.title
 									})]
 								}),
-								/* @__PURE__ */ (0, react_jsx_runtime.jsx)(ExecutionSettingsSection, {
+								!archived && /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(react_jsx_runtime.Fragment, { children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)(ExecutionSettingsSection, {
 									controller,
-									task: current
-								}),
-								/* @__PURE__ */ (0, react_jsx_runtime.jsx)(ScheduleSection, {
+									task: current,
+									pending
+								}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)(ScheduleSection, {
 									controller,
-									task: current
-								}),
+									task: current,
+									pending
+								})] }),
 								/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("section", {
 									className: board_module_css_default.detailSection,
 									children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("h4", { children: t("detail.execution") }), current.executions.length === 0 ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
@@ -2452,20 +2328,21 @@ window.__ModuleLoader__.load({
 										className: board_module_css_default.executionList,
 										children: [...current.executions].reverse().map((execution) => /* @__PURE__ */ (0, react_jsx_runtime.jsx)(ExecutionRow, {
 											execution,
+											timeZone,
 											onOpen: (sessionId) => {
 												controller.openSession(sessionId);
 											}
 										}, execution.id))
 									})]
 								}),
-								/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("section", {
+								!archived && /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("section", {
 									className: board_module_css_default.detailSection,
 									children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("h4", { children: t("board.status") }), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
 										className: board_module_css_default.moveRow,
 										children: MANUAL_STATUSES.map((status) => /* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
 											type: "button",
 											className: board_module_css_default.ghostButton,
-											disabled: current.status === status || running,
+											disabled: current.status === status || running || pending,
 											onClick: () => {
 												controller.moveTask(current.id, status);
 											},
@@ -2478,36 +2355,42 @@ window.__ModuleLoader__.load({
 						/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("footer", {
 							className: board_module_css_default.detailFooter,
 							children: [
-								/* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
+								!archived && pending && /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("span", {
+									className: board_module_css_default.detailMeta,
+									children: [t("board.pending"), "…"]
+								}),
+								!archived && /* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
 									type: "button",
 									className: board_module_css_default.primaryButton,
-									disabled: running,
+									disabled: running || pending,
 									onClick: () => {
-										controller.closeTask();
-										controller.rerunTask(current.id);
+										controller.rerunTask(current.id).then(() => {
+											if (controller.getSnapshot().transportError === void 0) controller.closeTask();
+										});
 									},
 									children: current.executions.length === 0 ? t("detail.run") : t("detail.rerun")
 								}),
-								current.archivedAt !== void 0 ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
+								archived ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
 									type: "button",
 									className: board_module_css_default.primaryButton,
+									disabled: pending,
 									onClick: () => {
 										controller.restoreTask(current.id);
-										controller.closeTask();
 									},
 									children: t("detail.restore")
 								}) : (current.status === "done" || current.status === "failed") && /* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
 									type: "button",
 									className: board_module_css_default.ghostButton,
+									disabled: pending,
 									onClick: () => {
 										controller.archiveTask(current.id);
-										controller.closeTask();
 									},
 									children: t("detail.archive")
 								}),
 								/* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
 									type: "button",
 									className: board_module_css_default.dangerButton,
+									disabled: pending,
 									onClick: () => {
 										setConfirmDelete(true);
 									},
@@ -2518,8 +2401,8 @@ window.__ModuleLoader__.load({
 									children: [
 										t("board.created"),
 										" ",
-										formatTime(current.createdAt),
-										current.archivedAt !== void 0 && ` · ${t("detail.archivedAt", { time: formatTime(current.archivedAt) })}`
+										formatTime(current.createdAt, timeZone),
+										archived && ` · ${t("detail.archivedAt", { time: formatTime(current.archivedAt, timeZone) })}`
 									]
 								})
 							]
@@ -2536,7 +2419,6 @@ window.__ModuleLoader__.load({
 					onConfirm: () => {
 						setConfirmDelete(false);
 						controller.deleteTask(current.id);
-						controller.closeTask();
 					}
 				})]
 			});
@@ -2560,9 +2442,11 @@ window.__ModuleLoader__.load({
 		* re-renders only when its own task changes — not when a sibling card status,
 		* the filter, or the selection moves.
 		*/
-		const MemoTaskCard = (0, react.memo)(function MemoTaskCard({ task, onOpen }) {
+		const MemoTaskCard = (0, react.memo)(function MemoTaskCard({ task, pending, timeZone, onOpen }) {
 			return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(TaskCard, {
 				task,
+				pending,
+				timeZone,
 				onClick: (0, react.useCallback)(() => {
 					onOpen(task.id);
 				}, [task.id, onOpen])
@@ -2603,6 +2487,13 @@ window.__ModuleLoader__.load({
 								className: board_module_css_default.boardTitle,
 								children: t("board.title")
 							}),
+							snapshot.host !== void 0 && /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+								className: board_module_css_default.detailMeta,
+								children: t("board.hostMeta", {
+									revision: String(snapshot.host.revision),
+									timeZone: snapshot.host.scheduler.timeZone
+								})
+							}),
 							/* @__PURE__ */ (0, react_jsx_runtime.jsx)("input", {
 								className: board_module_css_default.search,
 								type: "search",
@@ -2631,6 +2522,21 @@ window.__ModuleLoader__.load({
 							})
 						]
 					}),
+					snapshot.transportError !== void 0 && /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+						className: board_module_css_default.formError,
+						children: [
+							t("board.hostError", { error: snapshot.transportError }),
+							" ",
+							/* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
+								type: "button",
+								className: board_module_css_default.linkButton,
+								onClick: () => {
+									controller.retryHostSync();
+								},
+								children: t("board.retryHost")
+							})
+						]
+					}),
 					/* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
 						className: board_module_css_default.columns,
 						children: archiveView ? /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("section", {
@@ -2649,6 +2555,8 @@ window.__ModuleLoader__.load({
 								className: board_module_css_default.cards,
 								children: [visible.map((task) => /* @__PURE__ */ (0, react_jsx_runtime.jsx)(MemoTaskCard, {
 									task,
+									pending: snapshot.pendingTaskIds.includes(task.id),
+									timeZone: snapshot.host?.scheduler.timeZone,
 									onOpen: openTask
 								}, task.id)), visible.length === 0 && /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
 									className: board_module_css_default.columnEmpty,
@@ -2681,6 +2589,8 @@ window.__ModuleLoader__.load({
 									className: board_module_css_default.cards,
 									children: [tasks.map((task) => /* @__PURE__ */ (0, react_jsx_runtime.jsx)(MemoTaskCard, {
 										task,
+										pending: snapshot.pendingTaskIds.includes(task.id),
+										timeZone: snapshot.host?.scheduler.timeZone,
 										onOpen: openTask
 									}, task.id)), tasks.length === 0 && /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
 										className: board_module_css_default.columnEmpty,
@@ -3038,7 +2948,7 @@ window.__ModuleLoader__.load({
 							children: props.t("settings.readOnly")
 						}) : null,
 						props.children,
-						/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+						props.hideFooter === true ? null : /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
 							className: settings_card_module_css_default.footer,
 							children: [
 								state.failed ? /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("p", {
@@ -3384,14 +3294,19 @@ window.__ModuleLoader__.load({
 			store;
 			/** @param scope - the bound settings scope for the `task-board` namespace. */
 			constructor(scope) {
-				this.form = new CardForm(scope, [booleanField("enabled"), booleanField("announceToAgent")]);
+				this.form = new CardForm(scope, [
+					booleanField("enabled"),
+					booleanField("announceToAgent"),
+					booleanField("preventIdleSleep")
+				]);
 				this.store = this.form.bind(() => this.projection());
 			}
 			projection() {
 				return {
 					...this.form.shell(),
 					enabled: this.form.field("enabled"),
-					announceToAgent: this.form.field("announceToAgent")
+					announceToAgent: this.form.field("announceToAgent"),
+					preventIdleSleep: this.form.field("preventIdleSleep")
 				};
 			}
 			/**
@@ -3421,6 +3336,29 @@ window.__ModuleLoader__.load({
 			const { t } = props;
 			const state = props.useTaskBoardSettingsCard((snapshot) => snapshot);
 			const disabled = !state.writable;
+			const [power, setPower] = (0, react.useState)();
+			(0, react.useEffect)(() => {
+				let live = true;
+				const refresh = async () => {
+					try {
+						const response = await fetch("/api/task-board/state", {
+							cache: "no-store",
+							credentials: "same-origin"
+						});
+						if (!response.ok) return;
+						const snapshot = await response.json();
+						if (live) setPower(snapshot.power);
+					} catch {}
+				};
+				refresh();
+				const timer = setInterval(() => {
+					refresh();
+				}, 5e3);
+				return () => {
+					live = false;
+					clearInterval(timer);
+				};
+			}, []);
 			const fieldProps = {
 				overriddenLabel: t("settings.overridden"),
 				resetLabel: t("settings.reset"),
@@ -3431,43 +3369,166 @@ window.__ModuleLoader__.load({
 				t,
 				titleKey: "settings.title",
 				descriptionKey: "settings.description",
+				defaultOpen: false,
 				state,
 				onSave: props.save,
 				onDiscard: props.discard,
-				children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)(BooleanField, {
-					id: "settings-task-board-enabled",
-					label: t("settings.enabled"),
-					hint: t("settings.enabledHint"),
-					inheritLabel: t("settings.inherit"),
-					onLabel: t("settings.on"),
-					offLabel: t("settings.off"),
-					...fieldProps,
-					...state.enabled,
-					onEdit: (text) => {
-						props.edit("enabled", text);
-					},
-					onReset: () => {
-						props.resetField("enabled");
-					}
-				}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)(BooleanField, {
-					id: "settings-task-board-announce",
-					label: t("settings.announceToAgent"),
-					hint: t("settings.announceToAgentHint"),
-					inheritLabel: t("settings.inherit"),
-					onLabel: t("settings.on"),
-					offLabel: t("settings.off"),
-					...fieldProps,
-					...state.announceToAgent,
-					onEdit: (text) => {
-						props.edit("announceToAgent", text);
-					},
-					onReset: () => {
-						props.resetField("announceToAgent");
-					}
-				})]
+				children: [
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)(BooleanField, {
+						id: "settings-task-board-enabled",
+						label: t("settings.enabled"),
+						hint: t("settings.enabledHint"),
+						inheritLabel: t("settings.inherit"),
+						onLabel: t("settings.on"),
+						offLabel: t("settings.off"),
+						...fieldProps,
+						...state.enabled,
+						onEdit: (text) => {
+							props.edit("enabled", text);
+						},
+						onReset: () => {
+							props.resetField("enabled");
+						}
+					}),
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)(BooleanField, {
+						id: "settings-task-board-announce",
+						label: t("settings.announceToAgent"),
+						hint: t("settings.announceToAgentHint"),
+						inheritLabel: t("settings.inherit"),
+						onLabel: t("settings.on"),
+						offLabel: t("settings.off"),
+						...fieldProps,
+						...state.announceToAgent,
+						onEdit: (text) => {
+							props.edit("announceToAgent", text);
+						},
+						onReset: () => {
+							props.resetField("announceToAgent");
+						}
+					}),
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)(BooleanField, {
+						id: "settings-task-board-prevent-idle-sleep",
+						label: t("settings.preventIdleSleep"),
+						hint: t("settings.preventIdleSleepHint"),
+						inheritLabel: t("settings.inherit"),
+						onLabel: t("settings.on"),
+						offLabel: t("settings.off"),
+						...fieldProps,
+						...state.preventIdleSleep,
+						onEdit: (text) => {
+							props.edit("preventIdleSleep", text);
+						},
+						onReset: () => {
+							props.resetField("preventIdleSleep");
+						}
+					}),
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", { children: t("settings.powerStatus", {
+						platform: power?.platform ?? t("settings.powerUnknown"),
+						phase: power?.phase ?? t("settings.powerUnknown"),
+						running: String(power?.runningSessions ?? 0),
+						schedules: String(power?.armedSchedules ?? 0)
+					}) }),
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", { children: t("settings.powerBoundary") }),
+					power?.lastError !== void 0 && /* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", { children: t("settings.powerError", { error: power.lastError }) })
+				]
 			});
 		}
 		//#endregion
+		//#region src/protocol.ts
+		const TASK_BOARD_API_PREFIX = "/api/task-board";
+		//#endregion
+		//#region src/client/host-api.ts
+		const IMPORT_MARKER = "dsh.taskBoard.v2.hostImported";
+		const SOURCE_KEY = "dsh.taskBoard.v2.sourceId";
+		const IMPORT_REQUEST_KEY = "dsh.taskBoard.v2.importRequestId";
+		const REQUEST_TIMEOUT_MS = 15e3;
+		function uuid() {
+			return globalThis.crypto?.randomUUID?.() ?? `browser-${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
+		}
+		async function readJson(response) {
+			const body = await response.json();
+			if (!response.ok) throw new Error(body.error ?? `task-board request failed: ${response.status}`);
+			return body;
+		}
+		var HttpTaskBoardHostTransport = class {
+			storage;
+			constructor(storage = globalThis.localStorage) {
+				this.storage = storage;
+			}
+			async bootstrap(legacy) {
+				const initial = await this.state();
+				const ledgerId = initial.scheduler.ledgerId;
+				if (legacy.length > 0 && ledgerId !== void 0 && this.storage?.getItem(IMPORT_MARKER) !== ledgerId) {
+					let sourceId = this.storage?.getItem(SOURCE_KEY);
+					if (sourceId === null || sourceId === void 0 || sourceId === "") {
+						sourceId = uuid();
+						this.storage?.setItem(SOURCE_KEY, sourceId);
+					}
+					let requestId = this.storage?.getItem(IMPORT_REQUEST_KEY);
+					if (requestId === null || requestId === void 0 || requestId === "") {
+						requestId = uuid();
+						this.storage?.setItem(IMPORT_REQUEST_KEY, requestId);
+					}
+					const snapshot = await this.post(requestId, {
+						kind: "import",
+						sourceId,
+						tasks: [...legacy]
+					});
+					this.storage?.setItem(IMPORT_MARKER, snapshot.scheduler.ledgerId ?? ledgerId);
+					return snapshot;
+				}
+				return initial;
+			}
+			async state() {
+				return await this.request(`${TASK_BOARD_API_PREFIX}/state`, { cache: "no-store" });
+			}
+			async action(action) {
+				return await this.post(uuid(), action);
+			}
+			async post(requestId, action) {
+				const envelope = {
+					requestId,
+					action
+				};
+				return await this.request(`${TASK_BOARD_API_PREFIX}/action`, {
+					method: "POST",
+					headers: { "content-type": "application/json" },
+					body: JSON.stringify(envelope)
+				});
+			}
+			async request(url, init) {
+				const controller = new AbortController();
+				const timeout = globalThis.setTimeout(() => {
+					controller.abort();
+				}, REQUEST_TIMEOUT_MS);
+				try {
+					return await readJson(await fetch(url, {
+						...init,
+						signal: controller.signal
+					}));
+				} catch (error) {
+					if (controller.signal.aborted) throw new Error(`task-board Host request timed out after ${REQUEST_TIMEOUT_MS / 1e3}s`);
+					throw error;
+				} finally {
+					globalThis.clearTimeout(timeout);
+				}
+			}
+			subscribe(listener) {
+				const events = new EventSource(`${TASK_BOARD_API_PREFIX}/events`);
+				events.onmessage = () => {
+					listener();
+				};
+				const onVisible = () => {
+					if (document.visibilityState === "visible") listener();
+				};
+				document.addEventListener("visibilitychange", onVisible);
+				return () => {
+					document.removeEventListener("visibilitychange", onVisible);
+					events.close();
+				};
+			}
+		};
+		//#endregion
 		//#region src/client/index.ts
 		/** Locale namespace this plugin owns. */
 		const NS = "task-board";
@@ -3512,85 +3573,18 @@ window.__ModuleLoader__.load({
 			let uiDisposer;
 			const mountUi = () => {
 				if (uiDisposer !== void 0) return;
-				const sessions = ctx.sessions;
-				const workspaces = ctx.workspaces;
+				const sessions = ctx.get("sessions");
+				const workspaces = ctx.get("workspaces");
 				const connection = ctx.get("connection");
 				const controller = new BoardController({
 					store: new LocalStorageTaskStore(),
-					exec: new ExecutionService({
-						sessions: {
-							list: sessions.list,
-							binding: (id) => {
-								const binding = sessions.binding(id);
-								if (binding === void 0) return void 0;
-								const { session } = binding;
-								return { session: {
-									rename: (title) => session.rename(title),
-									prompt: (content, mode) => session.prompt(content, mode).then((result) => result.ok ? { ok: true } : {
-										ok: false,
-										error: result.error
-									}),
-									command: (line) => session.command(line).then((result) => result.ok ? {
-										ok: true,
-										matched: result.value.matched
-									} : {
-										ok: false,
-										error: result.error
-									}),
-									getSnapshot: () => session.getSnapshot(),
-									subscribe: (fn) => session.subscribe(fn)
-								} };
-							},
-							noteAgentPreset: (sessionId, agentPreset) => sessions.noteAgentPreset(sessionId, agentPreset)
-						},
-						workspaces: {
-							list: workspaces.list,
-							connectWorkspace: (id) => workspaces.connectWorkspace(id)
-						},
-						presets: { select: async (sessionId, agentPreset) => {
-							try {
-								const response = await connection.api.agentPresets.select({
-									sessionId,
-									agentPreset
-								});
-								return response.result.ok ? { ok: true } : {
-									ok: false,
-									error: response.result.error
-								};
-							} catch (error) {
-								return {
-									ok: false,
-									error
-								};
-							}
-						} },
-						history: { loadTail: async (sessionId) => {
-							const response = await connection.api.sessions.history({
-								sessionId,
-								maxMessages: 20
-							});
-							return response.result.ok ? { events: response.result.value.events.map((entry) => entry.event) } : void 0;
-						} }
-					}),
+					transport: new HttpTaskBoardHostTransport(),
 					sessions: {
 						list: sessions.list,
 						open: (id) => sessions.open(id)
 					}
 				});
 				controller.start();
-				const scheduler = new SchedulerService({
-					tasks: () => controller.getSnapshot().tasks,
-					refresh: () => controller.reloadFromStore(),
-					now: () => Date.now(),
-					runTask: (id) => controller.runTask(id),
-					applySchedule: (id, nextRunAt, lastTriggeredAt) => controller.applyScheduleNextRun(id, nextRunAt, lastTriggeredAt),
-					ready: () => sessions.list.getSnapshot().phase === "ready",
-					environment: {
-						addEventListener: (type, listener) => document.addEventListener(type, listener),
-						removeEventListener: (type, listener) => document.removeEventListener(type, listener)
-					}
-				});
-				scheduler.start();
 				const disposers = [];
 				const pushWorkspaceOptions = () => {
 					const snapshot = workspaces.list.getSnapshot();
@@ -3628,7 +3622,6 @@ window.__ModuleLoader__.load({
 				}
 				uiDisposer = () => {
 					for (const dispose of disposers.splice(0)) dispose();
-					scheduler.dispose();
 					controller.dispose();
 					uiDisposer = void 0;
 				};