@linxin666/dsh-client-ui-task-board 0.4.6 → 0.4.7

package/lib/index.js

@@ -5,9 +5,21 @@ import { chmodSync, closeSync, existsSync, fsyncSync, mkdirSync, openSync, readF
 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";
+import { Context } from "@deepseek-ai/cordis";
 import { ReasoningEffortId, createUserMessage } from "@deepseek-ai/dsh-llm";
 import { defineTool } from "@deepseek-ai/dsh-tools";
 /**
+* Clamp a configured width into the supported range. A value the schema would
+* refuse (non-finite, below the floor, above the ceiling) still leaves the
+* board launching: an out-of-range setting never stalls a run.
+* @param width - configured width, or undefined for the default.
+* @returns the effective width.
+*/
+function normalizeRunLaunchWidth(width) {
+	if (width === void 0 || !Number.isFinite(width)) return 3;
+	return Math.min(Math.max(Math.trunc(width), 1), 16);
+}
+/**
 * Clamp a configured cadence into the supported range. A value the schema
 * would refuse (non-finite, below the floor, above the ceiling) still leaves
 * the board polling: an out-of-range setting never disables the timer.
@@ -59,6 +71,92 @@ function reusableSessionId(task, idleSessionIds) {
 	return idleSessionIds.has(last.sessionId) ? last.sessionId : void 0;
 }
 //#endregion
+//#region src/host/launch-admission.ts
+var LaunchAdmissionQueue = class {
+	width;
+	/** Waiting launches per run group, in arrival order. */
+	waiting = /* @__PURE__ */ new Map();
+	/** Run groups in round-robin order. */
+	rotation = [];
+	/** Slot holders of the launches in flight, one per admitted launch. */
+	inFlight = /* @__PURE__ */ new Set();
+	/** Highest number of launches in flight at once; observability and tests. */
+	peakInFlight = 0;
+	/**
+	* @param width - live admission width (already normalized by the caller).
+	*/
+	constructor(width) {
+		this.width = width;
+	}
+	/** Launches the queue has not admitted yet. */
+	get pendingCount() {
+		let total = 0;
+		for (const queue of this.waiting.values()) total += queue.length;
+		return total;
+	}
+	/** Launches currently holding a slot. */
+	get inFlightCount() {
+		return this.inFlight.size;
+	}
+	/** Admit one launch, immediately if a slot is free. */
+	enqueue(launch) {
+		const queue = this.waiting.get(launch.groupId);
+		if (queue === void 0) {
+			this.waiting.set(launch.groupId, [launch]);
+			this.rotation.push(launch.groupId);
+		} else queue.push(launch);
+		this.pump();
+	}
+	/**
+	* Abandon every waiting launch: the queue is being torn down, so an entry
+	* that never started can never start. Launches already in flight are left
+	* alone — their session may already exist, and the callers that own them
+	* settle them through the normal path.
+	* @returns the abandoned launches, in abandonment order.
+	*/
+	drain() {
+		const abandoned = [];
+		for (const groupId of this.rotation) for (const launch of this.waiting.get(groupId) ?? []) abandoned.push(launch);
+		this.rotation = [];
+		this.waiting.clear();
+		for (const launch of abandoned) launch.abandon();
+		return abandoned;
+	}
+	pump() {
+		while (this.inFlight.size < this.width()) {
+			const launch = this.takeNext();
+			if (launch === void 0) return;
+			this.admit(launch);
+		}
+	}
+	/** The next launch by round-robin across groups and FIFO inside one. */
+	takeNext() {
+		while (this.rotation.length > 0) {
+			const groupId = this.rotation.shift();
+			if (groupId === void 0) return void 0;
+			const queue = this.waiting.get(groupId);
+			if (queue === void 0 || queue.length === 0) {
+				this.waiting.delete(groupId);
+				continue;
+			}
+			const launch = queue.shift();
+			if (launch === void 0) continue;
+			if (queue.length === 0) this.waiting.delete(groupId);
+			else this.rotation.push(groupId);
+			return launch;
+		}
+	}
+	admit(launch) {
+		const release = () => {
+			this.inFlight.delete(release);
+			this.pump();
+		};
+		this.inFlight.add(release);
+		if (this.inFlight.size > this.peakInFlight) this.peakInFlight = this.inFlight.size;
+		Promise.resolve().then(() => launch.start()).catch(() => {}).then(release);
+	}
+};
+//#endregion
 //#region src/dsh-home.ts
 /**
 * DSH_HOME resolution shared by the plugin family's Host halves: the
@@ -659,6 +757,7 @@ function createTask(input, now, id) {
 		mode: normalizeTargetId(input.mode),
 		permission: isTaskPermission(input.permission) ? input.permission : void 0,
 		model: normalizeTargetId(input.model),
+		reasoningEffort: normalizeTargetId(input.reasoningEffort),
 		reuseSession: input.reuseSession === true ? true : void 0,
 		teamRun: input.teamRun === true ? true : void 0,
 		goalRun: input.goalRun === true ? true : void 0,
@@ -921,15 +1020,38 @@ function checkParentLink(tasks, childId, parentId, maxSubtaskDepth, lineage) {
 }
 /**
 * The tasks one run request opens executions for: the requested task first,
-* then its on-board descendants within the configured depth. Archived tasks
-* never run; a participant that already has an open execution is skipped by
-* the caller, which cannot start it twice.
+* then its on-board descendants within the configured depth. This is the
+* SHAPE of a cascade — every walk that must see the whole tree (settlement,
+* archive/restore, the running lock) reads it. The run path filters it with
+* {@link joinsCascadeRun}: archived tasks never run, a participant that already
+* has an open execution is skipped by the caller, which cannot start it twice,
+* and a finished descendant is left alone.
 */
 function cascadeTargets(tasks, rootId, maxSubtaskDepth) {
 	const root = tasks.find((task) => task.id === rootId);
 	if (root === void 0) return [];
 	return [root, ...descendantTasks(tasks, rootId, maxSubtaskDepth)];
 }
+/**
+* Whether a cascade member takes part in a new run.
+*
+* The task the user ran is always a member: the request names that card, and
+* the operator asked for it to run whatever its column says. A descendant does
+* not join once it sits in the `done` column — its work is finished, so running
+* the parent again is a run of the parent, never a second execution of work
+* that is already done. The rule keys on the column alone, so it covers both a
+* subtask that ran and one an operator moved to done by hand, and it holds for
+* every trigger: a manual run, a re-run, and a due occurrence of a schedule.
+* A card whose own schedule is enabled settles back into `todo`, so a scheduled
+* subtask stays a participant; to make a finished one run again, move it back
+* to `todo` or run it on its own.
+* @param task - the candidate member.
+* @param rootId - the task the run request named.
+* @returns false when this member is left alone by the run.
+*/
+function joinsCascadeRun(task, rootId) {
+	return task.id === rootId || task.status !== "done";
+}
 /** The open execution of a task inside a run group, if it still exists. */
 function openGroupExecution(task, runGroupId) {
 	return task.executions.find((execution) => execution.runGroupId === runGroupId && execution.endedAt === void 0);
@@ -989,11 +1111,12 @@ function effectiveTaskPermission(task) {
 /**
 * Resolve the execution targets a (sub)task actually runs with: its own value
 * wins, and an unset target inherits the nearest ancestor up to the root.
-* Workspace, agent preset and model inherit the ancestor's PIN only — a
-* handover bundle is a per-card continuation artefact and is never inherited.
-* The permission inherits the ancestor's EFFECTIVE binding, and its human
-* confirmation travels with it, so a subtask of an already-confirmed elevated
-* card is runnable while a subtask's own unconfirmed binding stays gated.
+* Workspace, agent preset, model and reasoning effort inherit the ancestor's
+* PIN only — a handover bundle is a per-card continuation artefact and is never
+* inherited. The permission inherits the ancestor's EFFECTIVE binding, and its
+* human confirmation travels with it, so a subtask of an already-confirmed
+* elevated card is runnable while a subtask's own unconfirmed binding stays
+* gated.
 */
 /**
 * The immutable teammate name for one team-mode member. Teammate names are
@@ -1039,19 +1162,22 @@ function stableTag(value) {
 function resolveExecutionTargets(task, tasks, maxSubtaskDepth = 3) {
 	if (task.parentId === void 0) return task;
 	const chain = [task, ...ancestorChain(tasks, task).slice(0, maxSubtaskDepth)];
-	const first = (key) => {
-		for (const candidate of chain) {
+	const first = (key, candidates) => {
+		for (const candidate of candidates) {
 			const value = candidate[key];
 			if (value !== void 0) return value;
 		}
 	};
+	const boundary = chain.findIndex((candidate) => candidate.model !== void 0);
+	const effortChain = boundary === -1 ? chain : chain.slice(0, boundary + 1);
 	const own = effectiveTaskPermission(task);
 	const owner = own === void 0 ? chain.slice(1).find((candidate) => effectiveTaskPermission(candidate) !== void 0) : void 0;
 	return {
 		...task,
-		workspaceId: first("workspaceId"),
-		mode: first("mode"),
-		model: first("model"),
+		workspaceId: first("workspaceId", chain),
+		mode: first("mode", chain),
+		model: first("model", chain),
+		reasoningEffort: first("reasoningEffort", effortChain),
 		permission: own ?? (owner === void 0 ? void 0 : effectiveTaskPermission(owner)),
 		permissionConfirmedAt: own === void 0 ? owner?.permissionConfirmedAt : task.permissionConfirmedAt
 	};
@@ -2277,6 +2403,7 @@ function isTaskRecordShape(value) {
 	if (record.parentId !== void 0 && typeof record.parentId !== "string") return false;
 	if (record.workspaceId !== void 0 && typeof record.workspaceId !== "string") return false;
 	if (record.mode !== void 0 && typeof record.mode !== "string") return false;
+	if (record.reasoningEffort !== void 0 && typeof record.reasoningEffort !== "string") return false;
 	if (record.permission !== void 0 && typeof record.permission !== "string") return false;
 	if (record.integrations !== void 0 && (typeof record.integrations !== "object" || record.integrations === null || Array.isArray(record.integrations))) return false;
 	if (record.hidden !== void 0 && typeof record.hidden !== "boolean") return false;
@@ -2446,6 +2573,7 @@ function parseLedger(raw) {
 		}));
 		task.workspaceId = normalizeTargetId(row.workspaceId);
 		task.mode = normalizeTargetId(row.mode);
+		task.reasoningEffort = normalizeTargetId(row.reasoningEffort);
 		task.archivedAt = typeof row.archivedAt === "number" && Number.isFinite(row.archivedAt) ? row.archivedAt : void 0;
 		task.permission = isTaskPermission(row.permission) ? row.permission : void 0;
 		task.reuseSession = row.reuseSession === true ? true : void 0;
@@ -2546,6 +2674,57 @@ function applyRestoreTask(tasks, id, now, maxSubtaskDepth = 1) {
 	};
 }
 //#endregion
+//#region src/core/card-defaults.ts
+/** Trim one optional target: blank text means "not set", like every stored pin. */
+function textOf(value) {
+	return value?.trim() ?? "";
+}
+/**
+* Resolve the execution targets a new card starts from.
+* @param defaults - the board's configured new-card defaults, if any.
+* @param source - the card this one is created from (a duplicate or a parent), if any.
+* @param picked - what the caller chose explicitly; a non-blank value wins.
+* @returns the four targets, blank where nothing supplies a value.
+*/
+function resolveCardTargets(defaults, source, picked) {
+	const defaultMode = textOf(defaults?.mode);
+	const defaultPermission = textOf(defaults?.permission);
+	const defaultModel = textOf(defaults?.model);
+	const defaultEffort = defaultModel === "" ? "" : textOf(defaults?.reasoningEffort);
+	const chosen = {
+		mode: textOf(picked?.mode),
+		permission: textOf(picked?.permission),
+		model: textOf(picked?.model),
+		reasoningEffort: textOf(picked?.reasoningEffort)
+	};
+	const copied = source === void 0 ? void 0 : {
+		mode: textOf(source.task.mode),
+		permission: textOf(source.task.permission),
+		model: textOf(source.task.model),
+		reasoningEffort: textOf(source.task.reasoningEffort)
+	};
+	/** The value carried over from the source card, or the board default. */
+	const inherited = (key) => {
+		const fallback = key === "mode" ? defaultMode : key === "model" ? defaultModel : defaultPermission;
+		if (copied === void 0 || key === "permission" && source?.kind === "parent") return fallback;
+		return copied[key] === "" ? fallback : copied[key];
+	};
+	const mode = chosen.mode === "" ? inherited("mode") : chosen.mode;
+	const permission = chosen.permission === "" ? inherited("permission") : chosen.permission;
+	const model = chosen.model === "" ? inherited("model") : chosen.model;
+	let reasoningEffort = chosen.reasoningEffort;
+	if (reasoningEffort === "" && chosen.model === "") {
+		const sourced = copied === void 0 ? "" : copied.reasoningEffort;
+		reasoningEffort = sourced !== "" ? sourced : model !== "" && model === defaultModel ? defaultEffort : "";
+	}
+	return {
+		mode,
+		permission,
+		model,
+		reasoningEffort
+	};
+}
+//#endregion
 //#region src/core/use-cases/task-create.ts
 /**
 * Create-task use case: mint a new task from user input, rejecting a blank
@@ -2558,18 +2737,22 @@ function applyRestoreTask(tasks, id, now, maxSubtaskDepth = 1) {
 * appended ledger, or the unchanged ledger when the title is blank or the
 * requested parent link is refused.
 *
-* A subtask inherits the execution targets its parent already pins (workspace,
-* agent preset, permission, model) unless the form supplied its own; the
-* parent human permission confirmation travels with an inherited permission,
-* so a subtask of an already-confirmed elevated card is runnable at once.
+* The execution targets resolve through {@link resolveCardTargets}: what the
+* caller sent wins, then the parent's own pins, then - only when the caller
+* opted in with `applyCardDefaults` - the deployment's configured new-card
+* defaults. Without the flag the resolution sees no defaults at all, which is
+* exactly the inline parent inheritance this path has always applied. The
+* workspace is not part of that resolution: a subtask still takes the parent's
+* workspace, and the defaults never name one.
 * @param tasks - current ledger.
 * @param input - raw user input (title/description/prompt + optional schedule/parent).
 * @param now - clock instant (ms epoch).
 * @param id - minted task id.
 * @param maxSubtaskDepth - deployment subtask depth limit.
 * @param hostTimeZone - zone a rule that stores no zone of its own follows.
+* @param cardDefaults - the deployment's new-card defaults, read live at creation.
 */
-function applyCreateTask(tasks, input, now, id, maxSubtaskDepth = 1, hostTimeZone = resolveHostTimeZone()) {
+function applyCreateTask(tasks, input, now, id, maxSubtaskDepth = 1, hostTimeZone = resolveHostTimeZone(), cardDefaults) {
 	if (input.title.trim() === "") return {
 		task: void 0,
 		tasks,
@@ -2595,11 +2778,22 @@ function applyCreateTask(tasks, input, now, id, maxSubtaskDepth = 1, hostTimeZon
 			error: `subtask depth limit (${limit}) exceeded`
 		};
 	}
-	let task = createTask(parent === void 0 ? input : {
+	const seed = resolveCardTargets(input.applyCardDefaults === true ? cardDefaults : void 0, parent === void 0 ? void 0 : {
+		kind: "parent",
+		task: parent
+	}, {
+		mode: input.mode,
+		permission: input.permission,
+		model: input.model,
+		reasoningEffort: input.reasoningEffort
+	});
+	let task = createTask({
 		...input,
-		workspaceId: input.workspaceId ?? parent.workspaceId,
-		mode: input.mode ?? parent.mode,
-		model: input.model ?? parent.model
+		workspaceId: input.workspaceId ?? parent?.workspaceId,
+		mode: seed.mode,
+		permission: isTaskPermission(seed.permission) ? seed.permission : void 0,
+		model: seed.model,
+		reasoningEffort: seed.reasoningEffort
 	}, now, id);
 	const requested = input.schedule;
 	if (requested?.enabled === true) {
@@ -3119,6 +3313,7 @@ function applyUpdateTask(tasks, id, patch, now) {
 		const mode = "mode" in patch ? normalizeTargetId(patch.mode) : void 0;
 		const permission = "permission" in patch ? normalizePermission(task.permission, patch.permission) : void 0;
 		const model = "model" in patch ? normalizeTargetId(patch.model) : void 0;
+		const reasoningEffort = "reasoningEffort" in patch ? normalizeTargetId(patch.reasoningEffort) : void 0;
 		const next = {
 			...task,
 			...rest,
@@ -3144,6 +3339,7 @@ function applyUpdateTask(tasks, id, patch, now) {
 		if (mode !== void 0 || "mode" in patch) next.mode = mode;
 		if (permission !== void 0 || "permission" in patch) next.permission = permission;
 		if (model !== void 0 || "model" in patch) next.model = model;
+		if (reasoningEffort !== void 0 || "reasoningEffort" in patch) next.reasoningEffort = reasoningEffort;
 		return next;
 	});
 }
@@ -3229,6 +3425,7 @@ function validImportedSchedule(value) {
 }
 function validImportedKnownFields(value) {
 	if (value.tags !== void 0 && !isTaskTagList(value.tags)) return false;
+	if (value.model !== void 0 && typeof value.model !== "string") return false;
 	if (value.integrations !== void 0 && normalizeTaskIntegrations(value.integrations) === void 0) return false;
 	if (value.schedule !== void 0 && !validImportedSchedule(value.schedule)) return false;
 	if (value.executions !== void 0) {
@@ -3281,7 +3478,9 @@ function importedTask(value) {
 		...task.parentId === void 0 ? {} : { parentId: task.parentId },
 		...task.workspaceId === void 0 ? {} : { workspaceId: task.workspaceId },
 		...task.mode === void 0 ? {} : { mode: task.mode },
+		...typeof task.model !== "string" || task.model.trim() === "" ? {} : { model: task.model },
 		...task.permission === void 0 ? {} : { permission: task.permission },
+		...task.reasoningEffort === void 0 ? {} : { reasoningEffort: task.reasoningEffort },
 		...task.reuseSession === void 0 ? {} : { reuseSession: task.reuseSession },
 		...task.goalRun === void 0 ? {} : { goalRun: task.goalRun },
 		...task.skipVerification === void 0 ? {} : { skipVerification: task.skipVerification },
@@ -3330,6 +3529,8 @@ function createInput(value) {
 		"freeze",
 		"handover",
 		"model",
+		"reasoningEffort",
+		"applyCardDefaults",
 		"reuseSession",
 		"teamRun",
 		"goalRun",
@@ -3339,7 +3540,8 @@ function createInput(value) {
 	])) return false;
 	if (input.parentId !== void 0 && (typeof input.parentId !== "string" || input.parentId.trim() === "")) return false;
 	if (typeof input.title !== "string" || typeof input.description !== "string" || typeof input.prompt !== "string") return false;
-	if (!optionalString(input.workspaceId) || !optionalString(input.mode) || !optionalString(input.model)) return false;
+	if (!optionalString(input.workspaceId) || !optionalString(input.mode) || !optionalString(input.model) || !optionalString(input.reasoningEffort)) return false;
+	if (input.applyCardDefaults !== void 0 && typeof input.applyCardDefaults !== "boolean") return false;
 	if (input.reuseSession !== void 0 && typeof input.reuseSession !== "boolean") return false;
 	if (input.teamRun !== void 0 && typeof input.teamRun !== "boolean") return false;
 	if (input.goalRun !== void 0 && typeof input.goalRun !== "boolean") return false;
@@ -3380,6 +3582,7 @@ function updatePatch(value) {
 		"freeze",
 		"handover",
 		"model",
+		"reasoningEffort",
 		"reuseSession",
 		"teamRun",
 		"goalRun",
@@ -3396,7 +3599,8 @@ function updatePatch(value) {
 		"prompt",
 		"workspaceId",
 		"mode",
-		"model"
+		"model",
+		"reasoningEffort"
 	]) if (!optionalString(patch[key])) return false;
 	if (patch.permission !== void 0 && !isTaskPermission(patch.permission)) return false;
 	if (patch.tags !== void 0 && patch.tags !== null && !isTaskTagList(patch.tags)) return false;
@@ -3985,11 +4189,14 @@ var HostTaskLedger = class {
 	* instead of remounting the row.
 	*/
 	depthLimit;
+	/** Live reader of the deployment's new-card defaults (a volatile config read). */
+	cardDefaults;
 	constructor(dir = join(dshHome(), "task-board"), now = Date.now, options = {}) {
 		this.now = now;
 		const baseline = options.sessionDefaultPermission;
 		this.sessionDefault = typeof baseline === "function" ? baseline : () => baseline ?? "read-only";
 		this.depthLimit = normalizeSubtaskDepth(options.maxSubtaskDepth ?? 1);
+		this.cardDefaults = options.cardDefaults ?? (() => ({}));
 		mkdirSync(dir, { recursive: true });
 		this.file = join(dir, "ledger-v2.json");
 		this.lockFile = join(dir, "ledger-v2.lock");
@@ -4409,7 +4616,7 @@ var HostTaskLedger = class {
 						frozenBy: initiator
 					}
 				};
-				const result = applyCreateTask(this.document.tasks, input, now, action.id, this.maxSubtaskDepth, timeZone());
+				const result = applyCreateTask(this.document.tasks, input, now, action.id, this.maxSubtaskDepth, timeZone(), this.cardDefaults());
 				if (result.task === void 0) throw new Error(result.error ?? "invalid task");
 				this.document.tasks = [...result.tasks];
 				break;
@@ -4639,10 +4846,11 @@ var HostTaskLedger = class {
 		return cascadeTargets(this.document.tasks, id, this.maxSubtaskDepth).some((task) => hasOpenExecution(task));
 	}
 	/**
-	* Open one execution per cascade participant (the requested task and its
-	* on-board descendants, within the depth limit) under a single run group, and
-	* commit the ledger once. The returned runs are ordered root-first, so the
-	* Host launches the parent before its subtasks.
+	* Open one execution per cascade participant that still has work (the
+	* requested task and its on-board descendants, within the depth limit) under
+	* a single run group, and commit the ledger once. A descendant in 'done' is
+	* not a participant ({@link joinsCascadeRun}). The returned runs are ordered
+	* root-first, so the Host launches the parent before its subtasks.
 	* @param root - the task the user ran.
 	* @param now - clock instant (ms epoch).
 	* @param initiator - the DSH session that asked for the run (audit only).
@@ -4659,6 +4867,7 @@ var HostTaskLedger = class {
 		const runs = [];
 		for (const task of cascadeTargets(before, root.id, this.maxSubtaskDepth)) {
 			if (task.archivedAt !== void 0) continue;
+			if (!joinsCascadeRun(task, root.id)) continue;
 			if (hasOpenExecution(task)) continue;
 			const opened = startExecution(rerun && task.id === root.id ? withStatus(task, "todo", now) : task, now, crypto.randomUUID(), initiator, groupId);
 			started.set(task.id, opened.task);
@@ -5212,7 +5421,96 @@ function mostRecentWorkspaceId(items) {
 	return best?.id ?? items[0]?.id;
 }
 //#endregion
+//#region src/core/reasoning-effort.ts
+/** Trim one optional effort: blank text means "not set", like every other pinned target. */
+function normalizeReasoningEffort(value) {
+	const trimmed = value?.trim();
+	return trimmed === void 0 || trimmed === "" ? void 0 : trimmed;
+}
+/**
+* Complete one route through the host catalog: a qualified route must match its
+* provider group, and a bare model id matches the first group carrying it —
+* which is the provider the request then names.
+* @param catalog - the host model catalog, when this deployment serves one.
+* @param route - the route as the card pins it.
+* @returns the completed route with its reasoning metadata, or undefined when
+*   the catalog declares no such model.
+*/
+function declaredRoute(catalog, route) {
+	const groups = catalog?.groups ?? [];
+	const matched = route.provider === void 0 || route.provider === "" ? groups.find((group) => group.models.some((model) => model.id === route.model)) : groups.find((group) => group.id === route.provider);
+	const model = matched?.models.find((candidate) => candidate.id === route.model);
+	if (matched === void 0 || model === void 0) return void 0;
+	return {
+		provider: matched.id,
+		model: model.id,
+		...model.reasoning === void 0 ? {} : { reasoning: model.reasoning }
+	};
+}
+/**
+* Resolve the effort one execution sends.
+* @param requested - the card's stored effort (absent or blank = inherit).
+* @param catalog - the host model catalog, when this deployment serves one.
+* @param route - the route the execution will actually run at.
+* @returns the effort to send, or the dropped value that will not be sent.
+*/
+function resolveReasoningEffort(requested, catalog, route) {
+	const effort = normalizeReasoningEffort(requested);
+	if (effort === void 0) return {};
+	if (route === void 0) return { dropped: effort };
+	return declaredRoute(catalog, route)?.reasoning?.efforts.some((option) => option.id === effort) === true ? { effort } : { dropped: effort };
+}
+//#endregion
 //#region src/host-runner.ts
+/**
+* Mint the in-process owner peer this plugin's Host calls speak for.
+*
+* The 0.2.1 gateway made `peer` mandatory on every request, and the
+* authorization layer reads only `peer.principal`: a principal of
+* `{ kind: 'owner' }` is how host-local code states that the call IS the local
+* user driving their own Host, so the gateway answers it directly instead of
+* running a remote-access decision (only non-owner principals are judged).
+* That is exactly the task board's position — it creates, renames, prompts,
+* and reads sessions as the Host itself, which before 0.2.1 was the implicit
+* privilege of every in-process caller. The board claims owner explicitly, and
+* only ever inside its own Host process: no wire field can set a principal,
+* and this plugin never forwards a browser-supplied one.
+*
+* `interactions` stays `'none'`: the board only invokes methods and opens the
+* short `session/follow` stream. The gateway's interactions check gates
+* exactly the forwarded-event endpoints (opening an event stream, answering a
+* waterfall), which this caller never touches; an `'answer'` peer would
+* additionally receive forwarded Host events, a capability the board neither
+* needs nor wants.
+*
+* The peer's signal aborts once `ctx` disposes, so streams opened for it end
+* with the plugin fiber, and `dispose()` is idempotent with racing calls
+* sharing one completion. The id carries no credential — the protocol fixes
+* `principal` as the only identity persisted in a session log — so a fresh
+* unique id per mount is sufficient.
+*/
+function createOwnerPeer(ctx) {
+	const controller = new AbortController();
+	let completion;
+	const peer = {
+		id: `task-board-owner:${crypto.randomUUID()}`,
+		ctx,
+		principal: { kind: "owner" },
+		signal: controller.signal,
+		interactions: "none",
+		dispose() {
+			if (completion === void 0) {
+				controller.abort();
+				completion = Promise.resolve();
+			}
+			return completion;
+		}
+	};
+	ctx.effect(() => () => {
+		peer.dispose();
+	}, "task-board owner peer");
+	return peer;
+}
 function sessionAddress(sessionId) {
 	return {
 		kind: "session",
@@ -5413,27 +5711,39 @@ function invokeWireArgs(namespace, method, request) {
 	if (namespace === "session" && method === "list") return { _request: request };
 	return { request };
 }
-var HostExecutionRunner = class {
+var HostExecutionRunner = class HostExecutionRunner {
 	gateway;
 	commands;
 	workspaceRegistry;
-	/** Newest scanned event sequence per session with no matching execution end. */
+	/**
+	* Newest event sequence per session whose COMPLETE history walk (reaching
+	* the execution boundary) found no matching execution end. A later walk may
+	* trust everything at or below it and examine only newer records.
+	*/
 	scanMemos = /* @__PURE__ */ new Map();
 	unavailableAttempts;
 	unavailableBackoffMs;
+	/**
+	* The peer every request speaks for. Production passes the peer bound to the
+	* plugin fiber; a bare runner (unit tests around fake gateways) gets one
+	* bound to a fresh root context instead.
+	*/
+	ownerPeer;
 	unsupportedSessionListWarned = false;
-	constructor(gateway, commands, workspaceRegistry, unavailableRetry) {
+	constructor(gateway, commands, workspaceRegistry, unavailableRetry, ownerPeer) {
 		this.gateway = gateway;
 		this.commands = commands;
 		this.workspaceRegistry = workspaceRegistry;
 		this.unavailableAttempts = unavailableRetry?.attempts ?? SERVICE_UNAVAILABLE_ATTEMPTS;
 		this.unavailableBackoffMs = unavailableRetry?.backoffMs ?? SERVICE_UNAVAILABLE_BACKOFF_MS;
+		this.ownerPeer = ownerPeer ?? createOwnerPeer(new Context());
 	}
 	invoke(namespace, method, request, signal) {
 		return this.gateway.invoke({
 			namespace,
 			method,
 			args: invokeWireArgs(namespace, method, request),
+			peer: this.ownerPeer,
 			...signal === void 0 ? {} : { signal }
 		});
 	}
@@ -5443,6 +5753,7 @@ var HostExecutionRunner = class {
 			namespace,
 			method,
 			args: { request },
+			peer: this.ownerPeer,
 			...signal === void 0 ? {} : { signal }
 		});
 	}
@@ -5484,7 +5795,7 @@ var HostExecutionRunner = class {
 			try {
 				options.onSession?.(reused);
 				await this.assertReusedPreset(reused, mode);
-				await this.pinAndPrompt(reused, task, permission, options.promptContext, options.onGoalArmed, options.goalEnabled === true);
+				await this.pinAndPrompt(reused, task, permission, options.promptContext, options.onGoalArmed, options.goalEnabled === true, options.catalog);
 			} catch (error) {
 				throw new SessionLaunchError(reused, error);
 			}
@@ -5500,7 +5811,7 @@ var HostExecutionRunner = class {
 				sessionId,
 				title: task.title
 			});
-			await this.pinAndPrompt(sessionId, task, permission, options.promptContext, options.onGoalArmed, options.goalEnabled === true);
+			await this.pinAndPrompt(sessionId, task, permission, options.promptContext, options.onGoalArmed, options.goalEnabled === true, options.catalog);
 		} catch (error) {
 			throw new SessionLaunchError(sessionId, error);
 		}
@@ -5527,30 +5838,85 @@ var HostExecutionRunner = class {
 		throw new Error("reused session " + sessionId + " was composed from agent preset " + (typeof recorded === "string" ? "\"" + recorded + "\"" : "an unreadable value") + ", but the task pins \"" + pinned + "\"");
 	}
 	/**
+	* Split a `provider/model` pin. A pin without a provider keeps only the model
+	* id: the provider is the one the host catalog declares for it, resolved at
+	* launch because the session wire contract requires a provider.
+	*/
+	static pinnedRoute(model) {
+		const raw = model?.trim();
+		if (raw === void 0 || raw === "") return void 0;
+		const slash = raw.indexOf("/");
+		if (slash < 0) return { model: raw };
+		const provider = raw.slice(0, slash).trim();
+		const modelId = raw.slice(slash + 1).trim();
+		if (provider === "" || modelId === "") return void 0;
+		return {
+			provider,
+			model: modelId
+		};
+	}
+	/**
+	* The route a card that pins no model actually runs at: the session's own
+	* recorded selection (the durable fold the GUI reads; `next` is the pending
+	* user choice, `lastUsed` what the last request consumed), or — for a session
+	* that has selected none yet, which is exactly a session that would start at
+	* the deployment default — the host default from the catalog.
+	*
+	* A route that cannot be READ is undefined and the effort is not sent:
+	* falling back to the host default there would silently switch the model of a
+	* session this run only meant to continue.
+	*/
+	async sessionRoute(sessionId, catalog) {
+		let selection;
+		try {
+			const projections = await this.invoke("session", "projections", { sessionId });
+			selection = projections?.values?.modelSelection?.next ?? projections?.values?.modelSelection?.lastUsed;
+		} catch (error) {
+			console.warn("[dsh-task-board] session/projections failed while resolving the execution model route", error);
+			return;
+		}
+		if (typeof selection?.provider === "string" && selection.provider !== "" && typeof selection.model === "string" && selection.model !== "") return {
+			provider: selection.provider,
+			model: selection.model
+		};
+		return catalog?.default === void 0 ? void 0 : {
+			provider: catalog.default.provider,
+			model: catalog.default.model
+		};
+	}
+	/**
 	* Re-assert the pinned execution contract on a session and queue the task
 	* prompt. Shared by the fresh-session and reuse paths so both apply exactly
-	* the same permission/model pins before the prompt.
+	* the same permission/model/effort pins before the prompt. A session that
+	* refuses a selection carrying a catalog-confirmed effort throws here, so the
+	* prompt is never queued behind a run at the wrong level.
 	*/
-	async pinAndPrompt(sessionId, task, permission, context = {}, onGoalArmed, goalEnabled = false) {
+	async pinAndPrompt(sessionId, task, permission, context = {}, onGoalArmed, goalEnabled = false, catalog) {
 		if (permission !== void 0) {
 			if (this.commands === void 0) throw new Error("permission command dispatcher is unavailable");
 			const command = await this.commands.execute(sessionId, "/permission " + permission, AbortSignal.timeout(3e4));
 			if (command === void 0) throw new Error("permission command was not acknowledged");
 			if (command.kind !== "success") throw new Error(command.text ?? "permission command failed");
 		}
-		if (task.model !== void 0 && task.model.trim() !== "") {
-			const rawModel = task.model.trim();
-			const slashIdx = rawModel.indexOf("/");
-			const provider = slashIdx >= 0 ? rawModel.slice(0, slashIdx).trim() : void 0;
-			const modelId = slashIdx >= 0 ? rawModel.slice(slashIdx + 1).trim() : rawModel;
+		const requestedEffort = normalizeReasoningEffort(task.reasoningEffort);
+		const route = HostExecutionRunner.pinnedRoute(task.model) ?? (requestedEffort === void 0 ? void 0 : await this.sessionRoute(sessionId, catalog));
+		if (route !== void 0) {
+			const routeLabel = `${route.provider === void 0 ? "" : route.provider + "/"}${route.model}`;
+			const decision = resolveReasoningEffort(requestedEffort, catalog, route);
+			if (decision.dropped !== void 0) console.warn(`[dsh-task-board] model route ${routeLabel} does not declare reasoning effort "${decision.dropped}"; session ${sessionId} runs at the model default`);
+			const declared = declaredRoute(catalog, route);
+			const provider = declared?.provider ?? route.provider;
+			const modelId = declared?.model ?? route.model;
 			try {
 				await this.invoke("session", "selectModel", {
 					sessionId,
-					...provider ? { provider } : {},
-					model: modelId
+					...provider === void 0 ? {} : { provider },
+					model: modelId,
+					...decision.effort === void 0 ? {} : { reasoningEffort: decision.effort }
 				});
 			} catch (modelError) {
-				console.warn(`[dsh-task-board] failed to select model "${task.model}" for session ${sessionId}, falling back to default:`, modelError);
+				if (decision.effort !== void 0) throw new Error(`session ${sessionId} refused the model selection "${provider === void 0 ? modelId : provider + "/" + modelId}" with reasoning effort "${decision.effort}": ` + (modelError instanceof Error ? modelError.message : String(modelError)));
+				console.warn(`[dsh-task-board] failed to select model "${provider === void 0 ? modelId : provider + "/" + modelId}" for session ${sessionId}, falling back to default:`, modelError);
 			}
 		}
 		await this.invoke("session", "prompt", {
@@ -5765,10 +6131,13 @@ var HostExecutionRunner = class {
 		}
 		const openingEvents = opening.records.map((record) => ({ event: recordEvent(record) }));
 		const newestSeq = openingEvents.reduce((newest, entry) => newest === void 0 ? entry.event.seq : Math.max(newest, entry.event.seq), void 0);
-		if (newestSeq !== void 0 && this.scanMemos.get(sessionId) === newestSeq) return { outcome: "pending" };
+		const scannedThrough = this.scanMemos.get(sessionId);
+		if (newestSeq !== void 0 && scannedThrough === newestSeq) return { outcome: "pending" };
+		const oldestOpeningSeq = openingEvents.reduce((oldest, entry) => oldest === void 0 ? entry.event.seq : Math.min(oldest, entry.event.seq), void 0);
+		const coveredThrough = scannedThrough !== void 0 && oldestOpeningSeq !== void 0 && oldestOpeningSeq <= scannedThrough;
 		const events = [...openingEvents];
 		let beforeSeq;
-		let reachedExecutionBoundary = !opening.hasMore;
+		let reachedExecutionBoundary = !opening.hasMore || coveredThrough;
 		for (let page = 0; page < HISTORY_PAGE_LIMIT && !reachedExecutionBoundary; page += 1) {
 			let history;
 			try {
@@ -5789,11 +6158,11 @@ var HostExecutionRunner = class {
 			const pageEntries = pageEvents(history);
 			events.push(...pageEntries);
 			const oldestTime = pageEntries.reduce((oldest, entry) => oldest === void 0 ? entry.event.time : Math.min(oldest, entry.event.time), void 0);
-			if (!history.hasMore || oldestTime !== void 0 && oldestTime <= startedAt) {
+			const oldestSeq = pageEntries.reduce((oldest, entry) => oldest === void 0 ? entry.event.seq : Math.min(oldest, entry.event.seq), void 0);
+			if (!history.hasMore || oldestTime !== void 0 && oldestTime <= startedAt || scannedThrough !== void 0 && oldestSeq !== void 0 && oldestSeq <= scannedThrough) {
 				reachedExecutionBoundary = true;
 				break;
 			}
-			const oldestSeq = pageEntries.reduce((oldest, entry) => oldest === void 0 ? entry.event.seq : Math.min(oldest, entry.event.seq), void 0);
 			if (oldestSeq === void 0 || oldestSeq === beforeSeq) return { outcome: "pending" };
 			beforeSeq = oldestSeq;
 		}
@@ -6550,6 +6919,13 @@ const MAX_TIMER_DELAY_MS = 2147483647;
 */
 const UNREADABLE_SETTLE_POLLS = 24;
 /**
+* Why a member of a run never started: the Host stopped while its launch was
+* still waiting for an admission slot. Recorded rather than left open, so the
+* card leaves the running column instead of waiting for the next Host start's
+* interrupted-start recovery.
+*/
+const ABANDONED_LAUNCH_REASON = "host stopped before this execution started";
+/**
 * Why an enforced goal execution settled failed while its acceptance DID run:
 * attempts were recorded and none of them passed. The judge answered about the
 * work and the work did not pass.
@@ -6574,10 +6950,20 @@ const NEVER_INVOKED_VERIFICATION_REASON = "goal 验收未触发：本次执行
 */
 const INVALID_ONLY_VERIFICATION_REASON = "goal 验收无效：本次执行只记录了无效验收（裁判未能给出与任务要求对应、且可定位到本次证据的否决依据），看板已停止调用裁判。这**不是**有证据的质量判负：验收本身不可用，本次运行因没有匹配的通过记录而结束。请检查验收环境与证据可见性，或用 task_board_manage(action=reset-verification) 清除记录的无效验收后重新完成目标。";
 /**
-* Actions that can move an armed trigger. Only these re-arm the native timer;
-* an unrelated card edit leaves the pending fire untouched.
+* Actions that can change the instant the schedule timer is armed at. Only
+* these re-arm the native timer; an unrelated card edit leaves the pending fire
+* untouched.
+*
+* The set is the write surface of a rule itself rather than a guess at the UI
+* flows that reach it: `create` and `import` land a card that already carries
+* an enabled rule (the new-task dialog and the one-time browser import),
+* `set-schedule` edits one, and `delete`/`archive` drop one. `update` is
+* deliberately absent — the update patch cannot carry a schedule — and neither
+* can the run, move, lineage, permission, verification or label actions.
 */
 const SCHEDULE_WRITE_ACTIONS = /* @__PURE__ */ new Set([
+	"create",
+	"import",
 	"set-schedule",
 	"delete",
 	"archive"
@@ -6597,6 +6983,26 @@ const PROCESS_TIMERS = {
 		};
 	}
 };
+/**
+* The new-card defaults a snapshot publishes, or undefined when this
+* deployment configures none. A target the board configures nothing for is
+* omitted instead of published blank, so the browser can tell "no default
+* model" from "a blank one" (only a hand-edited settings document can express
+* the latter).
+*/
+function cardDefaultsOf(defaults) {
+	const mode = normalizeTargetId(defaults.mode);
+	const permission = normalizeTargetId(defaults.permission);
+	const model = normalizeTargetId(defaults.model);
+	const reasoningEffort = normalizeTargetId(defaults.reasoningEffort);
+	const published = {
+		...mode === void 0 ? {} : { mode },
+		...isTaskPermission(permission) ? { permission } : {},
+		...model === void 0 ? {} : { model },
+		...reasoningEffort === void 0 ? {} : { reasoningEffort }
+	};
+	return Object.keys(published).length === 0 ? void 0 : published;
+}
 var TaskBoardHostService = class {
 	ledger;
 	runner;
@@ -6618,6 +7024,12 @@ var TaskBoardHostService = class {
 	pollInFlight = false;
 	active = true;
 	/**
+	* Admission control for the session-creating half of a run: one board action
+	* opens a whole subtree, and this is what keeps the Host from asking DSH for
+	* every member's session at once (see {@link LaunchAdmissionQueue}).
+	*/
+	launches;
+	/**
 	* Consecutive unreadable-history polls per open execution (see
 	* {@link noteUnreadableInspection}). Cleared as soon as an inspection
 	* resolves, so a transient reader failure never fails a card.
@@ -6630,6 +7042,14 @@ var TaskBoardHostService = class {
 	timers;
 	/** Live reader of the global native-/goal switch; frozen per execution. */
 	goalRunEnabled;
+	/** Live reader of the deployment's new-card defaults (published and applied per create). */
+	cardDefaults;
+	/**
+	* Live reader of the run-launch admission width: how many launches may be in
+	* flight at once. Read at every admission, so a settings edit bounds the next
+	* launch without remounting the row. Absent means the default.
+	*/
+	runLaunchWidth;
 	lastPowerJson = "";
 	now;
 	/** The deployment's workspaces, consulted to resolve a card that pins none. */
@@ -6643,15 +7063,19 @@ var TaskBoardHostService = class {
 	constructor(gateway, options = {}) {
 		this.ledger = options.ledger ?? new HostTaskLedger(void 0, void 0, {
 			sessionDefaultPermission: options.sessionDefaultPermission,
-			maxSubtaskDepth: options.maxSubtaskDepth
+			maxSubtaskDepth: options.maxSubtaskDepth,
+			cardDefaults: options.cardDefaults
 		});
-		this.runner = new HostExecutionRunner(gateway, options.commandDispatcher, options.workspaceRegistry);
+		this.runner = new HostExecutionRunner(gateway, options.commandDispatcher, options.workspaceRegistry, void 0, options.ownerPeer);
 		this.workspaceRegistry = options.workspaceRegistry;
 		this.team = options.team;
 		this.timers = options.timers ?? PROCESS_TIMERS;
 		this.power = options.power ?? new PowerInhibitor();
 		this.now = options.now ?? Date.now;
 		this.goalRunEnabled = options.goalRunEnabled ?? (() => false);
+		this.cardDefaults = options.cardDefaults ?? (() => ({}));
+		this.runLaunchWidth = options.runLaunchWidth ?? (() => 3);
+		this.launches = new LaunchAdmissionQueue(() => normalizeRunLaunchWidth(this.runLaunchWidth()));
 		this.verificationSettings = options.verificationSettings ?? (() => ({
 			enabled: false,
 			model: "",
@@ -6728,6 +7152,7 @@ var TaskBoardHostService = class {
 	snapshot() {
 		const state = this.ledger.state();
 		const published = this.extensions.published();
+		const cardDefaults = cardDefaultsOf(this.cardDefaults());
 		return {
 			schemaVersion: 6,
 			revision: state.revision,
@@ -6738,6 +7163,7 @@ var TaskBoardHostService = class {
 			maxSubtaskDepth: this.ledger.maxSubtaskDepth,
 			teamRunAvailable: this.team !== void 0,
 			goalRunEnabled: this.goalRunEnabled(),
+			...cardDefaults === void 0 ? {} : { cardDefaults },
 			...Object.keys(published).length === 0 ? {} : { extensions: published }
 		};
 	}
@@ -6870,6 +7296,8 @@ var TaskBoardHostService = class {
 	}
 	dispose() {
 		this.disposed = true;
+		const abandoned = this.launches.drain();
+		if (abandoned.length > 0) safeConsoleError(`[dsh-task-board] ${abandoned.length} run member(s) were still waiting for a launch slot when the Host stopped; each is settled as cancelled`);
 		this.extensions.dispose();
 		this.clearScheduleTimer();
 		this.clearPollBackoff();
@@ -6879,7 +7307,7 @@ var TaskBoardHostService = class {
 		this.ledger.dispose();
 		this.listeners.clear();
 	}
-	async launch(opened, others = [], schedule) {
+	async launch(opened, others = [], schedule, freezeContract) {
 		/** The session this launch attached to the execution, once it exists. */
 		let attached;
 		try {
@@ -6895,14 +7323,13 @@ var TaskBoardHostService = class {
 				...team ? { team: true } : {},
 				...schedule === void 0 ? {} : { schedule }
 			};
-			const settings = this.verificationSettings();
-			const globalGoalEnabled = this.goalRunEnabled() === true;
+			const { settings, globalGoalEnabled, catalog } = await (freezeContract ?? (() => this.freezeRunContract()))();
 			const goalEnabled = globalGoalEnabled && opened.task.goalRun === true;
 			const skippedBy = opened.task.skipVerification === true ? "skipped" : "disabled";
 			const contract = resolveContract({
 				...settings,
 				enabled: settings.enabled && opened.task.skipVerification !== true
-			}, await this.verificationCatalog());
+			}, catalog);
 			const notArmed = globalGoalEnabled ? "goal-unavailable" : "goal-disabled";
 			const initial = {
 				contract,
@@ -6914,6 +7341,7 @@ var TaskBoardHostService = class {
 				...reuseSessionId === void 0 ? {} : { reuseSessionId },
 				...promptContext === void 0 ? {} : { promptContext },
 				goalEnabled,
+				catalog,
 				onSession: (id) => {
 					attached = id;
 					this.ledger.attachSession(opened.task.id, opened.execution.id, id);
@@ -6927,14 +7355,52 @@ var TaskBoardHostService = class {
 		} catch (error) {
 			const launchedSession = error instanceof SessionLaunchError ? error.sessionId : void 0;
 			if (launchedSession !== void 0) this.ledger.attachSession(opened.task.id, opened.execution.id, launchedSession);
-			if (schedule !== void 0 && attached === void 0 && launchedSession === void 0) this.ledger.refundScheduledOccurrence(opened.task.id, this.now());
+			if (schedule !== void 0 && attached === void 0 && launchedSession === void 0) this.refundUnstartedSchedule(opened.task.id);
 			this.settleAndNotify(opened.task.id, opened.execution.id, "failed", error instanceof Error ? error.message : String(error));
 		}
 	}
+	/**
+	* Read the acceptance contract one run group freezes, in the order the board
+	* has always read it: the acceptance settings, then the global native-/goal
+	* switch, then the model catalog that both resolves the contract's route and
+	* decides the reasoning effort the session may be given.
+	*/
+	async freezeRunContract() {
+		return {
+			settings: this.verificationSettings(),
+			globalGoalEnabled: this.goalRunEnabled() === true,
+			catalog: await this.verificationCatalog()
+		};
+	}
+	/**
+	* A {@link RunContractFreezer} that reads once and hands the SAME value to
+	* every later caller of one run group. A read that fails is not cached: the
+	* next member reads again, exactly as a per-execution read would have.
+	*/
+	contractFreezerForRunGroup() {
+		let pending;
+		return () => {
+			pending ??= this.freezeRunContract().catch((error) => {
+				pending = void 0;
+				throw error;
+			});
+			return pending;
+		};
+	}
+	/**
+	* Give back the occurrence a launch consumed, for a launch that never reached
+	* a session: a failed launch, or one the Host abandoned while it was still
+	* waiting for an admission slot. A manual run, and a launch that DID reach a
+	* session, are never refunded.
+	*/
+	refundUnstartedSchedule(taskId) {
+		this.ledger.refundScheduledOccurrence(taskId, this.now());
+		this.refreshSchedule();
+	}
 	scheduleTeammate(opened, leadSessionId) {
-		this.spawnTeammate(opened, leadSessionId).catch((error) => {
+		this.enqueueLaunch(opened, () => this.spawnTeammate(opened, leadSessionId).catch((error) => {
 			safeConsoleError("[dsh-task-board] teammate spawn settlement failed", error);
-		});
+		}));
 	}
 	/**
 	* Spawn one teammate inside the Lead session and attach the teammate's
@@ -7224,13 +7690,21 @@ var TaskBoardHostService = class {
 	* member then launches on its own so one refused participant cannot hold the
 	* others back. A team run's members are spawned inside the root's Lead
 	* session instead, once that session exists.
+	*
+	* Every launch of one run set goes through the admission queue, which admits
+	* at most `runLaunchWidth` of them at a time — the whole subtree still opens,
+	* members just enter the running column in batches. Order inside the group is
+	* the order they are enqueued here, so the root's session always exists before
+	* any member's, and one member's launch settling (or failing) is what admits
+	* the next. All members share the one contract this group freezes.
 	*/
 	dispatchRuns(runs, schedule) {
 		if (runs.length === 0) return;
 		const root = runs.find((run) => run.dispatch !== "teammate") ?? runs[0];
 		const others = runs.filter((run) => run !== root);
-		this.scheduleLaunch(root, others, schedule);
-		for (const run of others) if (run.dispatch !== "teammate") this.scheduleLaunch(run, [], schedule);
+		const freezeContract = this.contractFreezerForRunGroup();
+		this.scheduleLaunch(root, others, schedule, freezeContract);
+		for (const run of others) if (run.dispatch !== "teammate") this.scheduleLaunch(run, [], schedule, freezeContract);
 	}
 	/**
 	* Move one execution's applicability without touching its frozen contract or
@@ -7244,10 +7718,50 @@ var TaskBoardHostService = class {
 			applicability
 		});
 	}
-	scheduleLaunch(opened, others = [], schedule) {
-		this.launch(opened, others, schedule).catch((error) => {
+	scheduleLaunch(opened, others = [], schedule, freezeContract) {
+		this.enqueueLaunch(opened, () => this.launch(opened, others, schedule, freezeContract).catch((error) => {
 			safeConsoleError("[dsh-task-board] execution launch settlement failed", error);
-		});
+		}), schedule);
+	}
+	/**
+	* Hand one launch to the admission queue, or abandon it on the spot when the
+	* Host is already stopping: a queue entry created after {@link dispose} would
+	* otherwise never be drained, and its card would sit in the running column
+	* until the next Host start recovered it.
+	*/
+	enqueueLaunch(opened, start, schedule) {
+		const launch = {
+			groupId: opened.execution.runGroupId ?? opened.task.id,
+			start: async () => {
+				if (!this.isExecutionOpen(opened)) return;
+				await start();
+			},
+			abandon: () => this.abandonQueuedRun(opened, schedule)
+		};
+		if (this.disposed) {
+			launch.abandon();
+			return;
+		}
+		this.launches.enqueue(launch);
+	}
+	/** Whether one opened execution is still open in the ledger. */
+	isExecutionOpen(opened) {
+		const execution = this.ledger.getTask(opened.task.id)?.executions.find((entry) => entry.id === opened.execution.id);
+		return execution !== void 0 && execution.endedAt === void 0;
+	}
+	/**
+	* Take one launch that never started out of the running column.
+	*
+	* Settled as CANCELLED, not failed: nothing about the run's work went wrong —
+	* the Host stopped before the launch got a slot, which is exactly what the
+	* next start's interrupted-start recovery records for an execution that never
+	* reached a session. A scheduled occurrence that never reached a session is
+	* refunded on the same terms as any other pre-session failure, so a run the
+	* Host never started cannot silently spend the user's run budget.
+	*/
+	abandonQueuedRun(opened, schedule) {
+		if (schedule !== void 0) this.refundUnstartedSchedule(opened.task.id);
+		this.settleAndNotify(opened.task.id, opened.execution.id, "cancelled", ABANDONED_LAUNCH_REASON);
 	}
 	schedulePoll() {
 		if (this.pollInFlight || this.disposed) return;
@@ -7712,6 +8226,7 @@ function taskSummary(task, tasks, sessionDefault) {
 		...task.mode === void 0 ? {} : { mode: task.mode },
 		...task.permission === void 0 ? {} : { permission: task.permission },
 		...task.model === void 0 ? {} : { model: task.model },
+		...task.reasoningEffort === void 0 ? {} : { reasoningEffort: task.reasoningEffort },
 		...task.reuseSession === true ? { reuseSession: true } : {},
 		...task.teamRun === true ? { teamRun: true } : {},
 		...task.goalRun === true ? { goalRun: true } : {},
@@ -7809,7 +8324,7 @@ function buildSetParentTool(host) {
 			"Attach an existing task under a parent (making it a subtask) or detach it back to the root board by setting its parentId.",
 			"Pass an empty parentId to detach.",
 			"The Host refuses the link when the parent is unknown or archived, when the moved task is one of its own descendants, when the resulting depth exceeds the deployment subtask limit (default one level, maximum three), or while the task has an unsettled execution (its link may still be a running cascade parent pointer).",
-			"Running a task runs its whole subtree concurrently; a parent card settles only after its own turn and every direct subtask settle."
+			"Running a task opens one run group over its subtree concurrently and leaves a subtask that already sits in the done column alone; a parent card settles only after its own turn and every direct subtask it opened have settled."
 		].join(" "),
 		parameters: {
 			taskId: {
@@ -7861,7 +8376,7 @@ function buildRunTool(host) {
 			taskId: {
 				type: "string",
 				required: true,
-				description: "The task to run; running a root task runs its whole subtree."
+				description: "The task to run; running a root task runs its whole subtree, minus the subtasks that are already in the done column."
 			},
 			rerun: {
 				type: "boolean",
@@ -8060,7 +8575,7 @@ function buildScheduleTool(host) {
 			"Arm, change, or disarm a task scheduled runs. Two kinds of plan exist: a recurring 5-field cron rule (day-of-month and day-of-week follow Vixie semantics: both restricted means OR, otherwise AND), and a one-shot that runs once at a future instant.",
 			"For a one-shot pass mode \"once\" with at (the planned instant, ms since epoch UTC). For a recurring rule pass mode \"cron\" (or omit mode) with a cron expression, optionally capped by maxRuns (a positive whole number of scheduled executions; omit for unlimited, pass 0 to clear a cap).",
 			"The wall clock is read in the rule stored IANA time zone; omit timeZone to use the Host zone reported by task_board_list/task_board_get. DST gaps are skipped and an ambiguous fall-back time fires once, at the earlier instant.",
-			"A due scheduled task runs the same cascade a manual run does, so a root task runs its whole subtask tree.",
+			"A due scheduled task runs the same cascade a manual run does, so a root task runs its whole subtask tree minus the subtasks already in the done column.",
 			"The scheduler counts executions it actually starts; once a rule reaches its run budget it stops itself in the ledger, and a manual run never consumes the budget. A schedule whose tree contains an unconfirmed above-default permission is refused and does not consume the budget; the reason is reported in the list board summary as schedulerError.",
 			"Missed occurrences during Host downtime are skipped, never queued (a one-shot whose instant passed while the Host was down is stopped as missed); a task that is already running skips its occurrence without consuming the budget."
 		].join(" "),
@@ -8241,7 +8756,7 @@ function buildCreateTool(host) {
 		name: "task_board_create",
 		description: [
 			"Create a task on the DSH task board, or a subtask by passing parentId.",
-			"A subtask inherits every execution target it does not override (workspace, agent preset, permission, model) from its parent, and inherits the parent human permission confirmation together with an inherited binding.",
+			"A subtask inherits every execution target it does not override (workspace, agent preset, permission, model, reasoning effort) from its parent, and inherits the parent human permission confirmation together with an inherited binding.",
 			"The deployment caps subtask depth (default one level, maximum three): a subtask of a subtask is refused unless the board is configured deeper.",
 			"The task lands in the todo column and does NOT run; call task_board_run to execute it."
 		].join(" "),
@@ -8269,16 +8784,20 @@ function buildCreateTool(host) {
 			},
 			mode: {
 				type: "string",
-				description: "Agent preset id the execution session is composed from; omit for the deployment default or the parent value."
+				description: "Agent preset id the execution session is composed from; omit to adopt the board new-card default, and the deployment default when none is configured."
 			},
 			permission: {
 				type: "string",
 				enum: [...TASK_PERMISSIONS],
-				description: "Permission preset for the execution session. Omit to inherit the parent binding; a value above the session default needs a human confirmation in the board UI before the card can run."
+				description: "Permission preset for the execution session; omit to adopt the board new-card default. An omitted permission is never taken from a parent: the launch resolves the parent binding instead. A value above the session default needs a human confirmation in the board UI before the card can run."
 			},
 			model: {
 				type: "string",
-				description: "Pinned model as provider/model (or a model id); omit for the host default or the parent value."
+				description: "Pinned model as provider/model (or a model id); omit to adopt the board new-card default, and the host default when none is configured."
+			},
+			reasoningEffort: {
+				type: "string",
+				description: "Reasoning effort id for that model (an adapter-owned level such as \"high\"); omit to adopt the board new-card default for that model, and the model own default when none applies. Only an effort the target model declares is sent; an empty string clears it back to the default."
 			},
 			reuseSession: {
 				type: "boolean",
@@ -8365,6 +8884,8 @@ function buildCreateTool(host) {
 				...args.mode === void 0 || args.mode === "" ? {} : { mode: args.mode },
 				...args.permission === void 0 ? {} : { permission: args.permission },
 				...args.model === void 0 || args.model === "" ? {} : { model: args.model },
+				...args.reasoningEffort === void 0 || args.reasoningEffort === "" ? {} : { reasoningEffort: args.reasoningEffort },
+				applyCardDefaults: true,
 				...args.reuseSession === true ? { reuseSession: true } : {},
 				...args.teamRun === true ? { teamRun: true } : {},
 				...args.goalRun === true ? { goalRun: true } : {},
@@ -8400,7 +8921,7 @@ function buildUpdateTool(host) {
 	return defineTool({
 		name: "task_board_update",
 		description: [
-			"Edit a task board card: title, description, prompt, labels, and the execution targets (workspace, agent preset, permission, model, session reuse).",
+			"Edit a task board card: title, description, prompt, labels, and the execution targets (workspace, agent preset, permission, model, reasoning effort, session reuse).",
 			"Only the fields you pass change; pass an empty string to clear a target, or an empty labels array to clear the labels.",
 			"Title, description and prompt freeze once the task has started executing; the execution targets stay editable because they only affect future runs.",
 			"Changing the pinned permission re-arms the permission confirmation gate."
@@ -8445,6 +8966,10 @@ function buildUpdateTool(host) {
 				type: "string",
 				description: "New pinned model; an empty string clears it."
 			},
+			reasoningEffort: {
+				type: "string",
+				description: "New reasoning effort id for the pinned model; an empty string clears it back to the model own default. Only an effort the target model declares is sent at run time."
+			},
 			reuseSession: {
 				type: "boolean",
 				description: "Continue later runs in the previous execution session."
@@ -8493,6 +9018,7 @@ function buildUpdateTool(host) {
 			if (has(args, "workspaceId") && typeof args.workspaceId === "string") patch.workspaceId = args.workspaceId;
 			if (has(args, "mode") && typeof args.mode === "string") patch.mode = args.mode;
 			if (has(args, "model") && typeof args.model === "string") patch.model = args.model;
+			if (has(args, "reasoningEffort") && typeof args.reasoningEffort === "string") patch.reasoningEffort = args.reasoningEffort;
 			if (has(args, "permission") && typeof args.permission === "string") patch.permission = args.permission === "" ? void 0 : args.permission;
 			if (has(args, "reuseSession")) patch.reuseSession = args.reuseSession === true;
 			if (has(args, "teamRun")) patch.teamRun = args.teamRun === true;
@@ -10080,8 +10606,13 @@ const Config = z.object({
 	sessionDefaultPermission: z.union(TASK_PERMISSIONS),
 	maxSubtaskDepth: z.number().min(1).max(3).default(1).volatile(),
 	sessionPollSeconds: z.number().min(1).max(300).default(5).volatile(),
+	runLaunchWidth: z.number().min(1).max(16).default(3).volatile(),
 	teamProvider: z.string().min(1).default(DEFAULT_TEAM_PROVIDER),
 	goalRunEnabled: z.boolean().default(false).volatile(),
+	cardDefaultMode: z.string().default("").volatile(),
+	cardDefaultPermission: z.union([...TASK_PERMISSIONS, ""]).default("").volatile(),
+	cardDefaultModel: z.string().default("").volatile(),
+	cardDefaultReasoningEffort: z.string().default("").volatile(),
 	goalVerification: z.boolean().default(true).volatile(),
 	goalVerificationModel: z.string().default("").volatile(),
 	goalVerificationReasoningEffort: z.string().default("").volatile(),
@@ -10264,6 +10795,50 @@ function resolveLlmRuntime(ctx) {
 	}
 }
 /**
+* Resolve the optional `sessionController` service. Like the tool registry and
+* the llm runtime, it is read dynamically so capture-only test contexts that do
+* not mount the full session controller still activate the board.
+* @param ctx - the plugin context.
+* @returns the session controller face, or undefined when unavailable.
+*/
+function resolveSessionController(ctx) {
+	try {
+		const controller = ctx.get?.("sessionController");
+		return controller !== void 0 && typeof controller.resolveAgent === "function" ? controller : void 0;
+	} catch {
+		return;
+	}
+}
+/**
+* Resolve the live Agent for an execution session, resuming a cold persisted
+* session through `sessionController.resolveAgent` when it is not yet in
+* `ctx.agents` (issue #1861).
+*
+* A fresh run (`session/create`) or a session the browser is currently
+* following is already in `ctx.agents`, so the fast path returns immediately.
+* A scheduled or manual reuse of a cold session — one that `session/list`
+* reports as idle from disk without activating its Agent — is not in
+* `ctx.agents` when `pinAndPrompt` runs `/permission` ahead of
+* `session/selectModel` and `session/prompt`; delegating to
+* `sessionController.resolveAgent` resumes it with its recorded preset and
+* model-selection state, matching what those gateway endpoints do next.
+* @param ctx - the plugin context.
+* @param sessionId - the target execution session id.
+* @returns the live Agent for `sessionId`.
+*/
+async function resolveExecutionAgent(ctx, sessionId) {
+	const live = ctx.agents.get(sessionId);
+	if (live !== void 0) return live;
+	const controller = resolveSessionController(ctx);
+	if (controller !== void 0) {
+		const resolved = await controller.resolveAgent(sessionId);
+		if ("agent" in resolved && resolved.agent !== void 0) return resolved.agent;
+		const detail = "error" in resolved && typeof resolved.error?.message === "string" && resolved.error.message !== "" ? `: ${resolved.error.message}` : "";
+		throw new Error(`execution session ${sessionId} is not available${detail}`);
+	}
+	throw new Error(`execution session ${sessionId} is not available`);
+}
+/**
 * Activate the board's host half: ledger, routes, cron scheduler, power
 * inhibitor, and the model-facing announcement.
 *
@@ -10289,6 +10864,12 @@ function applyImpl(ctx, config) {
 	/** Current roster-poll cadence in seconds (read live: the settings card edits it in place). */
 	const sessionPollSeconds = () => readConfigField(config?.sessionPollSeconds, 5);
 	/**
+	* Current run-launch admission width. Read live on every admission, so the
+	* settings card bounds the next launch of a run that is still queueing without
+	* remounting the row; the Host clamps a hand-edited value into the schema range.
+	*/
+	const runLaunchWidth = () => readConfigField(config?.runLaunchWidth, 3);
+	/**
 	* The baseline the permission confirmation gate judges against: the row's own
 	* `sessionDefaultPermission` when the deployment pins one, otherwise the Host's
 	* default preset. Read per call through the ledger, so a Host Settings change
@@ -10320,18 +10901,36 @@ function applyImpl(ctx, config) {
 	* executions that start afterwards.
 	*/
 	const goalRunEnabled = () => readConfigField(config?.goalRunEnabled, false);
+	/**
+	* Live reader of the new-card defaults, read at every use like the switch
+	* above: the create dialog prefills from the published snapshot, and each
+	* creating session re-reads them when it submits the create. A blank value
+	* means "not set" and reaches the resolver as an absent target.
+	*/
+	const cardDefaults = () => {
+		const permission = readConfigField(config?.cardDefaultPermission, "");
+		return {
+			mode: readConfigField(config?.cardDefaultMode, "").trim() || void 0,
+			permission: isTaskPermission(permission) ? permission : void 0,
+			model: readConfigField(config?.cardDefaultModel, "").trim() || void 0,
+			reasoningEffort: readConfigField(config?.cardDefaultReasoningEffort, "").trim() || void 0
+		};
+	};
+	const ownerPeer = createOwnerPeer(ctx);
 	const host = new TaskBoardHostService(ctx.typertGateway, {
 		workspaceRegistry: ctx.workspaceRegistry,
+		ownerPeer,
 		sessionDefaultPermission,
 		maxSubtaskDepth: maxSubtaskDepth(),
 		goalRunEnabled,
+		runLaunchWidth,
+		cardDefaults,
 		verificationSettings,
 		verificationCatalog,
 		timers: resolveHostTimers(ctx),
 		team: buildTeamDispatcher(ctx, config?.teamProvider ?? "spawn"),
 		commandDispatcher: { async execute(sessionId, line, signal) {
-			const agent = ctx.agents.get(sessionId);
-			if (agent === void 0) throw new Error(`execution session ${sessionId} is not available`);
+			const agent = await resolveExecutionAgent(ctx, sessionId);
 			return (await ctx.commands.execute(agent, line, [], signal))?.result;
 		} }
 	});
@@ -10455,4 +11054,4 @@ function applyImpl(ctx, config) {
 	sync();
 }
 //#endregion
-export { Config, DEFAULT_GOAL_RUN, DEFAULT_GOAL_VERIFICATION, DEFAULT_PROXY_TOKEN_ENV, DEFAULT_TEAM_PROVIDER, TASK_BOARD_GUIDANCE, apply, buildTeamDispatcher, inject, readConfigField, resolveAgentTeams, resolveHostDefaultPermission, resolveHostTimers, resolveLlmRuntime, resolveProxyAccess, resolveToolRegistry };
+export { Config, DEFAULT_GOAL_RUN, DEFAULT_GOAL_VERIFICATION, DEFAULT_PROXY_TOKEN_ENV, DEFAULT_TEAM_PROVIDER, TASK_BOARD_GUIDANCE, apply, buildTeamDispatcher, inject, readConfigField, resolveAgentTeams, resolveExecutionAgent, resolveHostDefaultPermission, resolveHostTimers, resolveLlmRuntime, resolveProxyAccess, resolveSessionController, resolveToolRegistry };