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

package/lib/index.js

@@ -5,8 +5,193 @@ 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.
+* @param seconds - configured cadence in seconds, or undefined for the default.
+* @returns the effective cadence in seconds.
+*/
+function normalizeSessionPollSeconds(seconds) {
+	if (seconds === void 0 || !Number.isFinite(seconds)) return 5;
+	return Math.min(Math.max(Math.trunc(seconds), 1), 300);
+}
+/**
+* The cadence in the milliseconds the Host timer face takes.
+* @param seconds - configured cadence in seconds, or undefined for the default.
+* @returns the effective cadence in milliseconds.
+*/
+function sessionPollMs(seconds) {
+	return normalizeSessionPollSeconds(seconds) * 1e3;
+}
+//#endregion
+//#region src/core/session-reuse.ts
+/**
+* Pick the session a new execution of this task may continue in, or undefined
+* to mint a fresh conversation. Reuse requires ALL of:
+* - the task opted in (`reuseSession === true`);
+* - the task's newest SETTLED execution carries a session id (issue #1587: the
+*   launch path calls this after `startExecution` appended this run's own open
+*   record, so reading the array tail always found an unsettled row and reuse
+*   never happened);
+* - the roster is known and that session is present and idle.
+*
+* An unknown roster (session/list unavailable) never reuses: minting a fresh
+* conversation is always safe, prompting into a session we cannot see is not.
+* @param task - the task about to run.
+* @param idleSessionIds - ids the last roster saw as present and not running;
+*   undefined when that roster is unknown.
+* @returns the session id to continue in, or undefined for a fresh session.
+*/
+function reusableSessionId(task, idleSessionIds) {
+	if (task.reuseSession !== true || idleSessionIds === void 0) return void 0;
+	let last;
+	for (let index = task.executions.length - 1; index >= 0; index -= 1) {
+		const candidate = task.executions[index];
+		if (candidate.sessionId !== void 0 && candidate.endedAt !== void 0) {
+			last = candidate;
+			break;
+		}
+	}
+	if (last === void 0 || last.sessionId === void 0) return void 0;
+	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
+* environment override wins, the platform home fallback follows. Mirrors
+* what dsh-pet and dsh-liangshen each used to implement locally.
+*/
+/** Expand a leading ~ (or ~user) in a path, platform-style. */
+function expandHome(path, home = homedir()) {
+	const j = home.startsWith("/") ? join$1 : join;
+	if (path === "~") return home;
+	if (path.startsWith("~/") || path.startsWith("~\\")) return j(home, path.slice(2));
+	return path;
+}
+/**
+* Resolve the DSH home directory.
+* @param env - process environment to read DSH_HOME from.
+* @param home - platform home directory fallback (test seam).
+* @returns the absolute DSH home path.
+*/
+function resolveDshHome(env = process.env, home = homedir()) {
+	const isPosix = home.startsWith("/");
+	const j = isPosix ? join$1 : join;
+	const isAbs = isPosix ? isAbsolute$1 : isAbsolute;
+	const raw = env.DSH_HOME;
+	if (raw !== void 0 && raw.trim() !== "") {
+		const expanded = expandHome(raw.trim(), home);
+		return isAbs(expanded) ? expanded : j(process.cwd(), expanded);
+	}
+	return j(home, ".dsh");
+}
+/** Resolve the DSH home directory from the live environment. */
+function dshHome() {
+	return resolveDshHome();
+}
+//#endregion
 //#region src/core/schedule.ts
 /** Inclusive ranges per field, in cron order. */
 const FIELD_RANGES = [
@@ -283,73 +468,6 @@ function isDigits(value) {
 	return /^\d+$/.test(value);
 }
 //#endregion
-//#region src/core/session-reuse.ts
-/**
-* Pick the session a new execution of this task may continue in, or undefined
-* to mint a fresh conversation. Reuse requires ALL of:
-* - the task opted in (`reuseSession === true`);
-* - the task's newest SETTLED execution carries a session id (issue #1587: the
-*   launch path calls this after `startExecution` appended this run's own open
-*   record, so reading the array tail always found an unsettled row and reuse
-*   never happened);
-* - the roster is known and that session is present and idle.
-*
-* An unknown roster (session/list unavailable) never reuses: minting a fresh
-* conversation is always safe, prompting into a session we cannot see is not.
-* @param task - the task about to run.
-* @param idleSessionIds - ids the last roster saw as present and not running;
-*   undefined when that roster is unknown.
-* @returns the session id to continue in, or undefined for a fresh session.
-*/
-function reusableSessionId(task, idleSessionIds) {
-	if (task.reuseSession !== true || idleSessionIds === void 0) return void 0;
-	let last;
-	for (let index = task.executions.length - 1; index >= 0; index -= 1) {
-		const candidate = task.executions[index];
-		if (candidate.sessionId !== void 0 && candidate.endedAt !== void 0) {
-			last = candidate;
-			break;
-		}
-	}
-	if (last === void 0 || last.sessionId === void 0) return void 0;
-	return idleSessionIds.has(last.sessionId) ? last.sessionId : void 0;
-}
-//#endregion
-//#region src/dsh-home.ts
-/**
-* DSH_HOME resolution shared by the plugin family's Host halves: the
-* environment override wins, the platform home fallback follows. Mirrors
-* what dsh-pet and dsh-liangshen each used to implement locally.
-*/
-/** Expand a leading ~ (or ~user) in a path, platform-style. */
-function expandHome(path, home = homedir()) {
-	const j = home.startsWith("/") ? join$1 : join;
-	if (path === "~") return home;
-	if (path.startsWith("~/") || path.startsWith("~\\")) return j(home, path.slice(2));
-	return path;
-}
-/**
-* Resolve the DSH home directory.
-* @param env - process environment to read DSH_HOME from.
-* @param home - platform home directory fallback (test seam).
-* @returns the absolute DSH home path.
-*/
-function resolveDshHome(env = process.env, home = homedir()) {
-	const isPosix = home.startsWith("/");
-	const j = isPosix ? join$1 : join;
-	const isAbs = isPosix ? isAbsolute$1 : isAbsolute;
-	const raw = env.DSH_HOME;
-	if (raw !== void 0 && raw.trim() !== "") {
-		const expanded = expandHome(raw.trim(), home);
-		return isAbs(expanded) ? expanded : j(process.cwd(), expanded);
-	}
-	return j(home, ".dsh");
-}
-/** Resolve the DSH home directory from the live environment. */
-function dshHome() {
-	return resolveDshHome();
-}
-//#endregion
 //#region src/core/extension.ts
 /** Cordis service name the host and browser halves each publish. */
 const TASK_BOARD_SERVICE_NAME = "taskBoard";
@@ -437,6 +555,37 @@ function retainRecentExecutions(executions) {
 	const keepSettled = Math.max(20 - open.length, 0);
 	return [...settled.slice(Math.max(settled.length - keepSettled, 0)), ...open];
 }
+/** Every stop reason this build understands; the repair and wire gates share it. */
+const SCHEDULE_STOP_REASONS = [
+	"fired",
+	"limit",
+	"no-target",
+	"missed",
+	"busy",
+	"permission",
+	"launch-failed"
+];
+/**
+* The rule's total run budget: one for a one-shot, the stored cap for a
+* recurring rule, and undefined when the rule is unlimited.
+* @param rule - the schedule rule.
+* @returns the budget, or undefined for an uncapped rule.
+*/
+function scheduleRunBudget(rule) {
+	if (rule.mode === "once") return 1;
+	return rule.maxRuns;
+}
+/**
+* Whether a rule has no runs left. The scheduler refuses to open another
+* execution for an exhausted rule, which is what makes the budget terminal
+* regardless of restarts or repeated timer fires.
+* @param rule - the schedule rule.
+* @returns true when the run budget is spent.
+*/
+function scheduleExhausted(rule) {
+	const budget = scheduleRunBudget(rule);
+	return budget !== void 0 && rule.runCount >= budget;
+}
 /** Whether an unknown value is a well-formed tag (strict: the wire gate). */
 function isTaskTag(value) {
 	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
@@ -608,9 +757,10 @@ 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 === false ? false : void 0,
+		goalRun: input.goalRun === true ? true : void 0,
 		skipVerification: input.skipVerification === true ? true : void 0,
 		...input.freeze === void 0 ? {} : { freeze: freezeOf(input.freeze, now) },
 		...input.handover === void 0 ? {} : { handover: {
@@ -630,27 +780,47 @@ function withStatus(task, status, now) {
 		updatedAt: now
 	};
 }
+/** Every field a schedule patch may carry; the rest of the rule is carried over. */
+const SCHEDULE_PATCH_KEYS = [
+	"enabled",
+	"mode",
+	"cron",
+	"at",
+	"timeZone",
+	"nextRunAt",
+	"lastTriggeredAt",
+	"runCount",
+	"maxRuns",
+	"endedAt",
+	"endedReason",
+	"skippedAt",
+	"skippedReason"
+];
 /**
 * Merge a schedule patch into a task's schedule rule (creating it when
 * absent), with a fresh updatedAt. Keys present in the patch overwrite the
 * current value — including explicit `undefined`, which clears a field (used
-* to disarm `nextRunAt`); absent keys keep their current value.
+* to disarm `nextRunAt` or to drop an ended/skip record); absent keys keep
+* their current value.
 */
 function withSchedule(task, patch, now) {
-	const current = task.schedule;
-	const schedule = {
-		enabled: current?.enabled ?? false,
-		cron: current?.cron ?? "",
-		...current?.timeZone === void 0 ? {} : { timeZone: current.timeZone },
-		nextRunAt: current?.nextRunAt,
-		lastTriggeredAt: current?.lastTriggeredAt
-	};
-	if ("enabled" in patch) schedule.enabled = patch.enabled ?? false;
-	if ("cron" in patch) schedule.cron = patch.cron ?? "";
-	if ("timeZone" in patch) if (patch.timeZone === void 0) delete schedule.timeZone;
-	else schedule.timeZone = patch.timeZone;
-	if ("nextRunAt" in patch) schedule.nextRunAt = patch.nextRunAt;
-	if ("lastTriggeredAt" in patch) schedule.lastTriggeredAt = patch.lastTriggeredAt;
+	const schedule = task.schedule === void 0 ? {
+		enabled: false,
+		mode: "cron",
+		nextRunAt: void 0,
+		lastTriggeredAt: void 0,
+		runCount: 0
+	} : { ...task.schedule };
+	const fields = schedule;
+	const next = patch;
+	for (const key of SCHEDULE_PATCH_KEYS) {
+		if (!(key in patch)) continue;
+		if (next[key] === void 0) delete fields[key];
+		else fields[key] = next[key];
+	}
+	if (schedule.enabled !== true) schedule.enabled = false;
+	if (schedule.mode !== "once") schedule.mode = "cron";
+	if (!Number.isFinite(schedule.runCount) || schedule.runCount < 0) schedule.runCount = 0;
 	return {
 		...task,
 		updatedAt: now,
@@ -689,6 +859,20 @@ function startExecution(task, now, executionId, initiatedBy, runGroupId) {
 	};
 }
 /**
+* The column a settled outcome puts a card in. The ONE derivation shared by
+* every settlement path (issue #1826): a Host-run execution and an outcome an
+* outside agent reported both land in the same column from the same rule, so
+* the column never becomes a second, independent piece of state.
+@param task - the card being settled.
+@param outcome - the settled outcome.
+@returns the status the card shows afterwards.
+*/
+function settledStatus(task, outcome) {
+	if (outcome === "succeeded") return task.schedule?.enabled === true ? "todo" : "done";
+	if (outcome === "failed") return "failed";
+	return task.status === "running" ? "todo" : task.status;
+}
+/**
 * Settle a running execution: record the outcome and move the task into the
 * matching column. No-op (returns the input task) when the execution is not
 * the task's latest or is already settled.
@@ -706,10 +890,9 @@ function settleExecution(task, executionId, outcome, now, error) {
 	};
 	const executions = [...task.executions];
 	executions[index] = settled;
-	const status = outcome === "succeeded" ? task.schedule?.enabled ? "todo" : "done" : outcome === "failed" ? "failed" : task.status === "running" ? "todo" : task.status;
 	return {
 		...task,
-		status,
+		status: settledStatus(task, outcome),
 		updatedAt: now,
 		executions
 	};
@@ -837,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);
@@ -905,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
@@ -955,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
 	};
@@ -1205,6 +1415,20 @@ const SCALE_DESCRIPTION = [
 	"  Q-S = failed with some partial progress",
 	"  T = clearly and completely failed (worst)"
 ].join("\n");
+/**
+* Which trajectory slot holds the WORK during one round.
+*
+* The even round (0) puts the work in slot A and the empty-work baseline in
+* slot B; the odd round (1) swaps them, which is how the acceptance cancels
+* position bias. The judge prompt ALWAYS introduces the work as
+* `location="TRAJECTORY_B"`, because that is the slot the work occupies in the
+* prompt's own framing; the parser maps the cited slot back through this table.
+* @param round - the round index (0-based).
+* @returns the slot letter the work occupies in that round.
+*/
+function workSlotOfRound(round) {
+	return round % 2 === 1 ? "B" : "A";
+}
 Array.from({ length: 20 }, (_, index) => String.fromCharCode(65 + index));
 /**
 * Normalize one score token to an A-T letter.
@@ -1286,8 +1510,9 @@ function evidenceNonce(...parts) {
 *   byte-identical for a deployment that serves no change service.
 * @returns the rendered prompt.
 */
-function buildAcceptancePrompt(problem, traceA, traceB, criterion, groundTruthNote = DEFAULT_GROUND_TRUTH_NOTE, context) {
+function buildAcceptancePrompt(problem, traceA, traceB, criterion, groundTruthNote = DEFAULT_GROUND_TRUTH_NOTE, context, workSlot = "A") {
 	const reference = context?.trim() ?? "";
+	const workSlotTag = workSlot === "A" ? "Trajectory A" : "Trajectory B";
 	const token = reference === "" ? evidenceNonce(problem, traceA, traceB) : evidenceNonce(problem, reference, traceA, traceB);
 	return [
 		EVALUATOR_ROLE,
@@ -1300,6 +1525,10 @@ function buildAcceptancePrompt(problem, traceA, traceB, criterion, groundTruthNo
 		"**Rating Scale:**\n" + SCALE_DESCRIPTION,
 		"**Evaluation Guideline — " + criterion.name + ":**\n" + criterion.description,
 		"Score each trajectory ONLY on this specific criterion (\"" + criterion.name + "\"). Ignore other aspects that are not relevant to it.",
+		"If and only if the score you give the WORK under this criterion makes it fail the criterion, you MUST justify it with one finding element per failing observation, in exactly this form (replace the placeholders, keep the attribute names and the quoting):",
+		"<finding criterion=\"" + criterion.name + "\" location=\"" + workSlot + "\" requirement=\"the task requirement this criterion demands\" observation=\"what you actually observed\" gap=\"why the observation does not satisfy the requirement\" quote=\"a verbatim passage copied exactly from the block named by location\">optional suggested action</finding>",
+		"Before citing the task you MUST name the failing criterion, restate the requirement it imposes, describe the observation that falls short, explain the difference, and cite a verbatim passage that occurs in the evidence. " + workSlotTag + " is the WORK under review and is the only trajectory a veto may cite: a passage quoted from the other trajectory, which is the empty-work baseline (No useful work or verification was performed.), is not evidence about the work and must never be used.",
+		"A failure with no such citation is not a usable verdict: if the evidence you were given is truncated, incomplete, or simply does not contain the output needed to judge this criterion, say so in your prose and cite nothing rather than inventing a basis to veto.",
 		"Reason it through first, then END your reply with exactly these two lines and nothing after them. Replace each placeholder with a single letter A-T, keeping the spaces around the letter exactly as shown:\n<score_A> LETTER_A_TO_T </score_A>\n<score_B> LETTER_A_TO_T </score_B>",
 		"Begin your analysis now."
 	].join("\n\n");
@@ -1312,6 +1541,116 @@ function qualityAttempts(verification) {
 function exceptionAttempts(verification) {
 	return verification === void 0 ? [] : verification.attempts.filter((attempt) => attempt.stage === "exception");
 }
+/**
+* Invalid acceptances spent by this cycle: a veto whose required evidence was
+* missing, unlocatable, or aimed at the empty-work baseline. They are NOT
+* quality verdicts, so they never close the cycle and never fail the card; the
+* bound is what keeps an evidence-free judge from re-running forever.
+*/
+function invalidAttempts(verification) {
+	return verification === void 0 ? [] : verification.attempts.filter((attempt) => attempt.stage === "invalid");
+}
+/** Whether this cycle still has invalid-acceptance budget left. */
+function hasInvalidBudget(verification) {
+	return invalidAttempts(verification).length < 2;
+}
+/**
+* The acceptance block with every non-quality attempt dropped: the explicit
+* reset a user performs after fixing the environment (issue #1828).
+*
+* Only attempts that are not a quality verdict are dropped. A quality verdict
+* is the board's own judgement of the work and survives every reset, so this
+* can never buy an extra acceptance or re-open a judged failure; it only lets
+* the environment be judged again.
+* @param verification - the persisted acceptance state.
+* @returns the cleared block, or undefined when there is nothing to clear.
+*/
+function withoutAcceptanceAnomalies(verification) {
+	const kept = verification.attempts.filter((attempt) => attempt.stage === "quality");
+	if (kept.length === verification.attempts.length) return void 0;
+	const cleared = {
+		...verification,
+		attempts: kept
+	};
+	delete cleared.inFlight;
+	delete cleared.failedReason;
+	delete cleared.failedAt;
+	delete cleared.cleanup;
+	return cleared;
+}
+/**
+* The one-line problem summary a cleaned execution keeps: the failing criteria
+* with their scores, plus how many locatable findings were removed. This is the
+* lightweight audit material that survives the detail cleanup.
+* @param attempt - the attempt whose detail is being removed.
+* @returns the bounded summary line.
+*/
+function findingSummaryOf(attempt) {
+	const failed = attempt.criteria.filter((criterion) => !criterion.passed);
+	const parts = [];
+	if (failed.length > 0) parts.push("未达标判据：" + failed.map((criterion) => criterion.name + " " + percent(criterion.score)).join("、"));
+	const located = (attempt.criterionFindings ?? []).length;
+	if (located > 0) parts.push("已移除的可定位问题 " + located + " 条");
+	if (attempt.error !== void 0 && attempt.error !== "") parts.push(attempt.error);
+	if (parts.length === 0) return void 0;
+	return parts.join("；");
+}
+/**
+* The audit credential of one attempt: everything the completion gate, the
+* report and a later review need, and nothing that makes the ledger heavy.
+* @param attempt - the attempt being condensed.
+* @returns the lightweight audit record.
+*/
+function auditOf(attempt) {
+	const summary = findingSummaryOf(attempt);
+	return {
+		stage: attempt.stage,
+		passed: attempt.passed,
+		at: attempt.at,
+		score: attempt.score,
+		baseline: attempt.baseline,
+		criteria: attempt.criteria.map((criterion) => ({ ...criterion })),
+		evidenceHash: attempt.evidence.hash,
+		route: { ...attempt.route },
+		...attempt.error === void 0 ? {} : { error: attempt.error },
+		...summary === void 0 ? {} : { findingSummary: summary },
+		usage: { ...attempt.usage }
+	};
+}
+/**
+* Remove this execution's OWN acceptance-only detail while keeping the light
+* audit record — the acceptance mechanism's side of requirement 2.
+*
+* Only material the acceptance mechanism itself created is removed: the
+* per-attempt findings, the invalid diagnostics and the token/evidence detail
+* beyond the summary. Everything a human needs to see the verdict survives
+* (stage, pass flag, time, scores, evidence hash, judge route, usage totals),
+* so the completion gate's pass record and a later review are unaffected, and
+* NO user file, task artifact, raw session history or other execution's record
+* is ever touched by this function.
+* @param verification - the execution's acceptance block.
+* @param now - cleanup instant (ms epoch).
+* @returns the cleaned block, or undefined when there is nothing to remove.
+*/
+function withAcceptanceDetailCleared(verification, now) {
+	if (verification.cleanup?.state === "cleaned") return void 0;
+	const audit = verification.attempts.map(auditOf);
+	return {
+		...verification,
+		attempts: verification.attempts.map((attempt) => ({
+			...attempt,
+			findings: [],
+			criterionFindings: []
+		})),
+		cleanup: {
+			state: "cleaned",
+			attempts: (verification.cleanup?.attempts ?? 0) + 1,
+			startedAt: verification.cleanup?.startedAt ?? now,
+			cleanedAt: now,
+			audit
+		}
+	};
+}
 /** The quality attempt that passed, when one did. */
 function passedAttempt(verification) {
 	return qualityAttempts(verification).find((attempt) => attempt.passed);
@@ -1328,6 +1667,33 @@ function passedAttempt(verification) {
 function verificationRequired(verification) {
 	return verification !== void 0 && verification.applicability === "enforced";
 }
+/**
+* Whether this execution's acceptance gate was never opened: acceptance was
+* enforced, the judge recorded nothing at all, and no cycle ever closed. Zero
+* attempts is therefore a fact about the RUN, not a verdict about the work — a
+* session that narrated completion instead of calling
+* `update_goal(action: complete)` produces exactly this shape, and its failure
+* reason must stay distinguishable from a quality verdict (issue #1837).
+* @param verification - the execution's persisted acceptance state.
+* @returns true when no acceptance attempt ever ran.
+*/
+function verificationNeverInvoked(verification) {
+	return verification !== void 0 && verification.applicability === "enforced" && verification.attempts.length === 0 && verification.failedReason === void 0;
+}
+/**
+* Whether this execution's acceptance produced no usable veto at all: it was
+* enforced, the judge recorded attempts, and every one of them is INVALID.
+*
+* Such a run must never be described as an evidence-backed quality veto (issue
+* #1837's sibling): the judge could not locate its own rejection, so the run
+* ended for lack of a matching pass rather than because the work was judged
+* and rejected. The settlement reason names that difference.
+* @param verification - the execution's persisted acceptance state.
+* @returns true when nothing but invalid acceptances were recorded.
+*/
+function verificationOnlyInvalid(verification) {
+	return verification !== void 0 && verification.applicability === "enforced" && verification.failedReason === void 0 && passedAttempt(verification) === void 0 && verification.attempts.length > 0 && invalidAttempts(verification).length === verification.attempts.length;
+}
 /** Whether this cycle still has quality budget left. */
 function hasQualityBudget(verification) {
 	return qualityAttempts(verification).length < 2;
@@ -1336,6 +1702,99 @@ function hasQualityBudget(verification) {
 function hasExceptionBudget(verification) {
 	return exceptionAttempts(verification).length < 2;
 }
+/** Whether a text carries a real statement rather than filler. */
+function substantive(text) {
+	return text.trim().length >= 4;
+}
+/**
+* Program-level validity of a REJECTING acceptance, decided before any quality
+* verdict is booked (requirement 1: the rule cannot live in a prompt alone).
+*
+* A veto is only usable when every criterion that failed has its own structured
+* finding carrying the requirement, the observation, the difference and a
+* citation that really occurs in the evidence the judge saw. A citation aimed at
+* the empty-work baseline, a citation that is not in the reviewed evidence, an
+* empty or generic statement, and a truncated review that cannot substantiate
+* the veto are all invalid acceptances: no quality verdict, no quality budget,
+* and no card failure.
+* @param input - the attempt's scores, findings and the evidence it judged.
+* @returns valid, or the reason and detail of the invalidity.
+*/
+function assessAcceptanceValidity(input) {
+	const failed = input.criteria.filter((criterion) => !criterion.passed);
+	const truncated = input.omittedCharacters > 0;
+	if (failed.length === 0) {
+		if (input.findings.filter((finding) => validFinding(finding, input.evidence) === void 0).length > 0) return { valid: true };
+		return truncated ? {
+			valid: false,
+			reason: "insufficient-evidence",
+			detail: "the review was truncated and no verifiable citation supports the total-score veto"
+		} : {
+			valid: false,
+			reason: "missing-finding",
+			detail: "the total score was rejected without any locatable finding"
+		};
+	}
+	for (const criterion of failed) {
+		const own = input.findings.filter((finding) => finding.criterionId === criterion.id);
+		if (own.length === 0) return truncated ? {
+			valid: false,
+			reason: "insufficient-evidence",
+			detail: criterion.name + ": the evidence was truncated and the judge reported no citation of its own, so this criterion cannot be judged"
+		} : {
+			valid: false,
+			reason: "missing-finding",
+			detail: criterion.name + ": the criterion failed with no structured finding of its own"
+		};
+		let usable = false;
+		let lastReason;
+		for (const finding of own) {
+			const problem = validFinding(finding, input.evidence);
+			if (problem === void 0) {
+				usable = true;
+				break;
+			}
+			lastReason = problem;
+		}
+		if (!usable) {
+			const detail = (lastReason?.detail ?? criterion.name) + " (" + criterion.name + ")";
+			return {
+				valid: false,
+				reason: lastReason?.reason ?? "vacuous-finding",
+				detail
+			};
+		}
+	}
+	return { valid: true };
+}
+/**
+* Why one finding cannot support a veto, or undefined when it can.
+*
+* The citation is checked against the evidence text of the LOCATION the finding
+* names, so a quote invented by the judge, a quote taken from an A/B slot that
+* held the empty-work baseline, and a quote the reviewed window never contained
+* are all rejected.
+*/
+function validFinding(finding, evidence) {
+	if (!substantive(finding.requirement) || !substantive(finding.observation) || !substantive(finding.gap)) return {
+		reason: "vacuous-finding",
+		detail: "the finding states no requirement, observation or difference"
+	};
+	if (finding.location === "baseline") return {
+		reason: "baseline-finding",
+		detail: "the citation is taken from the empty-work baseline, which is not the work under review"
+	};
+	const quote = finding.quote.trim();
+	if (quote.length < 12) return {
+		reason: "unlocatable-quote",
+		detail: "the citation is too short to locate anything in the evidence"
+	};
+	const haystack = finding.location === "task" ? evidence.task : finding.location === "workspace" ? evidence.workspace : finding.location === "trajectory" ? evidence.trajectory : "";
+	if (haystack === "" || !haystack.includes(quote)) return {
+		reason: "unlocatable-quote",
+		detail: "the citation does not occur in the evidence the judge reviewed"
+	};
+}
 /**
 * The acceptance rule, mirrored from the verifier's `sessionAccepted`:
 * the work must BEAT the empty-work baseline, reach the total threshold, and
@@ -1357,7 +1816,7 @@ function readAttempt(value) {
 	if (typeof value !== "object" || value === null) return void 0;
 	const row = value;
 	if (typeof row.index !== "number" || typeof row.at !== "number") return void 0;
-	if (row.stage !== "quality" && row.stage !== "exception") return void 0;
+	if (row.stage !== "quality" && row.stage !== "exception" && row.stage !== "budget" && row.stage !== "invalid") return void 0;
 	if (typeof row.passed !== "boolean") return void 0;
 	if (typeof row.score !== "number" || !Number.isFinite(row.score)) return void 0;
 	if (typeof row.baseline !== "number" || !Number.isFinite(row.baseline)) return void 0;
@@ -1392,7 +1851,18 @@ function readAttempt(value) {
 	const routeRow = route;
 	if (typeof routeRow.provider !== "string" || typeof routeRow.model !== "string") return void 0;
 	if (routeRow.reasoningEffort !== void 0 && typeof routeRow.reasoningEffort !== "string") return void 0;
-	const findings = Array.isArray(row.findings) ? row.findings.filter((item) => typeof item === "string") : [];
+	const findings = (Array.isArray(row.findings) ? row.findings : []).filter((item) => typeof item === "string").slice(0, 12).map((item) => clipRead(item, 400));
+	const criterionFindings = [];
+	if (Array.isArray(row.criterionFindings)) {
+		if (row.criterionFindings.length > 12) return void 0;
+		for (const entry of row.criterionFindings) {
+			const finding = readCriterionFinding(entry);
+			if (finding === void 0) return void 0;
+			criterionFindings.push(finding);
+		}
+	}
+	const invalidReason = row.invalidReason;
+	if (invalidReason !== void 0 && invalidReason !== "missing-finding" && invalidReason !== "unlocatable-quote" && invalidReason !== "baseline-finding" && invalidReason !== "vacuous-finding" && invalidReason !== "insufficient-evidence") return void 0;
 	return {
 		index: row.index,
 		at: row.at,
@@ -1425,7 +1895,51 @@ function readAttempt(value) {
 		},
 		channel: "explicit-tag",
 		rounds: typeof row.rounds === "number" ? row.rounds : 2,
-		...typeof row.error === "string" ? { error: row.error } : {}
+		...typeof row.error === "string" ? { error: row.error } : {},
+		...criterionFindings.length === 0 ? {} : { criterionFindings },
+		...typeof invalidReason === "string" ? { invalidReason } : {}
+	};
+}
+/**
+* Bound one persisted finding's text to what the acceptance itself would have
+* written.
+*
+* The reader is the only other door into the ledger: a hand-edited or
+* corrupted document could otherwise carry a megabyte of prose in a field the
+* writer caps at a few hundred characters, and every later render, audit
+* summary and cleanup pass would pay for it. Clipping on READ (never rejecting)
+* keeps the block usable and its capacity bounded: the acceptance-only material
+* the cleanup removes is bounded by construction on both sides.
+* @param value - the raw persisted text.
+* @param max - the cap the writer applies to that field.
+* @returns the bounded text.
+*/
+function clipRead(value, max) {
+	return value.length <= max ? value : value.slice(0, max);
+}
+/**
+* Repair one persisted structured finding, or undefined when it is unusable.
+* A malformed finding drops the WHOLE acceptance block (fail closed): a
+* persisted veto that cannot be read back could otherwise be counted as
+* evidence it no longer holds.
+*/
+function readCriterionFinding(value) {
+	if (typeof value !== "object" || value === null) return void 0;
+	const row = value;
+	if (typeof row.criterionId !== "string" || row.criterionId === "") return void 0;
+	if (typeof row.requirement !== "string" || typeof row.observation !== "string" || typeof row.gap !== "string") return void 0;
+	if (typeof row.quote !== "string") return void 0;
+	if (row.criterionId.length > 64) return void 0;
+	const location = row.location;
+	if (location !== "task" && location !== "trajectory" && location !== "workspace" && location !== "baseline" && location !== "unknown") return void 0;
+	return {
+		criterionId: row.criterionId,
+		requirement: clipRead(row.requirement, 400),
+		observation: clipRead(row.observation, 400),
+		gap: clipRead(row.gap, 400),
+		quote: clipRead(row.quote, 600),
+		location,
+		...typeof row.action === "string" ? { action: clipRead(row.action, 400) } : {}
 	};
 }
 /**
@@ -1473,7 +1987,7 @@ function normalizeVerification(value) {
 		};
 	}
 	const applicability = row.applicability;
-	if (applicability !== "enforced" && applicability !== "disabled" && applicability !== "skipped" && applicability !== "goal-unavailable" && applicability !== "team-member") return void 0;
+	if (applicability !== "enforced" && applicability !== "disabled" && applicability !== "skipped" && applicability !== "goal-unavailable" && applicability !== "team-member" && applicability !== "goal-disabled") return void 0;
 	const attempts = [];
 	if (!Array.isArray(row.attempts)) return void 0;
 	for (const entry of row.attempts) {
@@ -1482,6 +1996,8 @@ function normalizeVerification(value) {
 		attempts.push(attempt);
 	}
 	if (typeof row.failedReason === "string" && row.failedReason === "") return void 0;
+	const cleanup = readCleanupRecord(row.cleanup);
+	if (row.cleanup !== void 0 && cleanup === void 0) return void 0;
 	return {
 		contract: {
 			enabled: contractRow.enabled,
@@ -1496,7 +2012,98 @@ function normalizeVerification(value) {
 		...row.inFlight === true ? { inFlight: true } : {},
 		applicability,
 		...typeof row.failedReason === "string" ? { failedReason: row.failedReason } : {},
-		...typeof row.failedAt === "number" && Number.isFinite(row.failedAt) ? { failedAt: row.failedAt } : {}
+		...typeof row.failedAt === "number" && Number.isFinite(row.failedAt) ? { failedAt: row.failedAt } : {},
+		...cleanup === void 0 ? {} : { cleanup }
+	};
+}
+/**
+* Repair the persisted cleanup record, or undefined when it is unusable. The
+* record is the audit trail the UI reads to tell "the judge gave its evidence
+* and it was cleaned up" apart from "the judge produced no evidence at all",
+* so a malformed one drops the whole block (fail closed).
+*/
+function readCleanupRecord(value) {
+	if (typeof value !== "object" || value === null) return void 0;
+	const row = value;
+	if (row.state !== "pending" && row.state !== "cleaned" && row.state !== "failed") return void 0;
+	if (typeof row.attempts !== "number" || !Number.isInteger(row.attempts) || row.attempts < 0) return void 0;
+	if (typeof row.startedAt !== "number" || !Number.isFinite(row.startedAt)) return void 0;
+	if (row.cleanedAt !== void 0 && (typeof row.cleanedAt !== "number" || !Number.isFinite(row.cleanedAt))) return void 0;
+	if (row.lastError !== void 0 && typeof row.lastError !== "string") return void 0;
+	if (!Array.isArray(row.audit)) return void 0;
+	const audit = [];
+	for (const entry of row.audit) {
+		const parsed = readAuditRecord(entry);
+		if (parsed === void 0) return void 0;
+		audit.push(parsed);
+	}
+	return {
+		state: row.state,
+		attempts: row.attempts,
+		startedAt: row.startedAt,
+		...typeof row.cleanedAt === "number" ? { cleanedAt: row.cleanedAt } : {},
+		...typeof row.lastError === "string" ? { lastError: row.lastError } : {},
+		audit
+	};
+}
+/** Repair one persisted audit credential, or undefined when it is unusable. */
+function readAuditRecord(value) {
+	if (typeof value !== "object" || value === null) return void 0;
+	const row = value;
+	if (row.stage !== "quality" && row.stage !== "exception" && row.stage !== "budget" && row.stage !== "invalid") return void 0;
+	if (typeof row.passed !== "boolean") return void 0;
+	if (typeof row.at !== "number" || !Number.isFinite(row.at)) return void 0;
+	if (typeof row.score !== "number" || !Number.isFinite(row.score)) return void 0;
+	if (typeof row.baseline !== "number" || !Number.isFinite(row.baseline)) return void 0;
+	if (!Array.isArray(row.criteria)) return void 0;
+	const criteria = [];
+	for (const entry of row.criteria) {
+		if (typeof entry !== "object" || entry === null) return void 0;
+		const criterion = entry;
+		if (typeof criterion.id !== "string" || typeof criterion.name !== "string") return void 0;
+		if (typeof criterion.score !== "number" || !Number.isFinite(criterion.score)) return void 0;
+		if (typeof criterion.baseline !== "number" || !Number.isFinite(criterion.baseline)) return void 0;
+		if (typeof criterion.threshold !== "number" || !Number.isFinite(criterion.threshold)) return void 0;
+		criteria.push({
+			id: criterion.id,
+			name: criterion.name,
+			score: criterion.score,
+			baseline: criterion.baseline,
+			threshold: criterion.threshold,
+			passed: criterion.passed === true
+		});
+	}
+	if (typeof row.evidenceHash !== "string") return void 0;
+	const route = row.route;
+	if (typeof route !== "object" || route === null) return void 0;
+	const routeRow = route;
+	if (typeof routeRow.provider !== "string" || typeof routeRow.model !== "string") return void 0;
+	const usage = row.usage;
+	if (typeof usage !== "object" || usage === null) return void 0;
+	const usageRow = usage;
+	if (typeof usageRow.calls !== "number" || typeof usageRow.inputTokens !== "number" || typeof usageRow.outputTokens !== "number" || typeof usageRow.reasoningTokens !== "number") return void 0;
+	return {
+		stage: row.stage,
+		passed: row.passed,
+		at: row.at,
+		score: row.score,
+		baseline: row.baseline,
+		criteria,
+		evidenceHash: row.evidenceHash,
+		route: {
+			provider: routeRow.provider,
+			model: routeRow.model,
+			...typeof routeRow.reasoningEffort === "string" ? { reasoningEffort: routeRow.reasoningEffort } : {}
+		},
+		...typeof row.error === "string" ? { error: row.error } : {},
+		...typeof row.findingSummary === "string" ? { findingSummary: row.findingSummary } : {},
+		usage: {
+			calls: usageRow.calls,
+			inputTokens: usageRow.inputTokens,
+			outputTokens: usageRow.outputTokens,
+			reasoningTokens: usageRow.reasoningTokens,
+			...usageRow.usageIncomplete === true ? { usageIncomplete: true } : {}
+		}
 	};
 }
 /**
@@ -1515,14 +2122,68 @@ function qualityFeedback(attempt, remaining) {
 		"总分 " + percent(attempt.score) + "（阈值 " + percent(attempt.criteria[0]?.threshold ?? .65) + "），空工作基线 " + percent(attempt.baseline) + "。",
 		"未达标判据：" + (failed.length === 0 ? "无（总分或基线比较未通过）" : failed.map((criterion) => criterion.name + " " + percent(criterion.score)).join("、"))
 	];
-	if (attempt.findings.length > 0) {
+	const located = locatedFindingLines(attempt);
+	if (located.length > 0) {
 		lines.push("可定位问题：");
-		for (const finding of attempt.findings) lines.push("- " + finding);
+		for (const line of located) lines.push("- " + line);
 	} else lines.push("本次裁判没有报告可定位的问题；请直接对照任务要求核对证据中的真实输出。");
 	lines.push("请按上述问题修复，然后再次调用 update_goal(action: complete) 触发第 " + (attempt.index + 1) + " 次验收；本执行周期的验收额度还剩 " + remaining + " 次。");
 	return lines.join("\n");
 }
 /**
+* The feedback one INVALID acceptance returns.
+*
+* The claim is refused (the board still has no pass record, so completion may
+* not take effect) but the agent is NOT handed a repair instruction: there is
+* no located problem to repair, and telling it to "fix" an evidence-free veto
+* would be exactly the blind repair the requirement forbids. The text says what
+* was missing, what happens next, and what the agent should do instead (make
+* the missing output itself observable, or let a human look).
+* @param attempt - the invalid attempt.
+* @param remaining - invalid-acceptance attempts left after this one.
+* @returns the model-facing text.
+*/
+function invalidAcceptanceFeedback(attempt, remaining) {
+	const lines = [
+		"[任务看板 · 验收无效] 第 " + attempt.index + " 次验收没有产生可用的质量判定。",
+		"原因：" + invalidReasonText(attempt.invalidReason) + (attempt.error === void 0 || attempt.error === "" ? "" : "（" + attempt.error + "）"),
+		"本次未消耗质量验收额度，也不把本次执行判为失败。"
+	];
+	if (attempt.invalidReason === "insufficient-evidence") {
+		lines.push("裁判看到的证据不完整（本次轨迹被截断 " + attempt.evidence.omittedCharacters + " 字符），无法据此否决；这属于验收无效，不代表执行者没有完成工作。");
+		lines.push("请把关键结论的证据直接放进你能控制的输出里（例如把最终验证命令的输出贴出来），或说明还需要哪些证据；再次调用 update_goal(action: complete) 会重新验收。");
+	} else {
+		lines.push("验收没有拿到任务要求、实际观测、差异与可定位引用俱全的证据，因此本次否决无效。");
+		lines.push("请不要据此盲目修改：先确认你的交付是否真的满足了任务要求，并确保关键产物/输出可见；再次调用 update_goal(action: complete) 会重新验收。");
+	}
+	if (remaining > 0) lines.push("无效验收重试额度还剩 " + remaining + " 次；用尽后看板会停止调用裁判并等待人工处理。");
+	else lines.push("无效验收重试额度已用尽：看板将停止调用裁判并把本次执行留在等待人工处理的状态。");
+	return lines.join("\n");
+}
+/**
+* The reason one execution records when its invalid-acceptance budget is spent.
+*
+* Deliberately NOT a quality failure: no veto was ever substantiated, so the
+* card stays open for a human and the reason says the acceptance is INVALID
+* rather than rejected.
+* @param used - invalid attempts spent.
+* @returns the user- and model-facing text.
+*/
+function invalidHoldReason(used) {
+	return "goal 验收无效（连续 " + used + " 次未产生可用判定）：验收没有给出与任务要求对应、且可定位到本次证据的否决依据，本次执行未判失败、未消耗质量验收额度。看板已停止调用裁判，等待人工处理：修复验收环境或证据可见性后，用 task_board_manage(action=reset-verification) 清除记录的无效验收，再重新完成目标；也可以直接重跑该卡片。";
+}
+/** Human-readable text of one invalid reason. */
+function invalidReasonText(reason) {
+	switch (reason) {
+		case "missing-finding": return "未达标的判据没有对应的结构化问题反馈";
+		case "unlocatable-quote": return "问题反馈引用的位置不存在于本次裁判所见的证据中";
+		case "baseline-finding": return "问题反馈指向空工作基线，而不是本次执行的工作";
+		case "vacuous-finding": return "问题反馈为空或空泛评价，没有说明实际观测与差异";
+		case "insufficient-evidence": return "裁判看到的证据不足（例如轨迹被截断），无法支撑否决";
+		default: return "未产生可用的质量判定";
+	}
+}
+/**
 * The reason one exhausted acceptance cycle records as the execution's final
 * failure. Unlike {@link qualityFeedback} — which the fixing agent reads while
 * budget remains — this reason is also persisted on the ledger, echoed on every
@@ -1538,12 +2199,36 @@ function qualityFeedback(attempt, remaining) {
 function finalFailureReason(attempt, used, threshold) {
 	const failed = attempt.criteria.filter((criterion) => !criterion.passed);
 	const lines = ["goal 验收第 " + used + " 次仍未通过（总分 " + percent(attempt.score) + "，阈值 " + percent(threshold) + "，空工作基线 " + percent(attempt.baseline) + "；未达标判据：" + (failed.length === 0 ? "总分或基线比较未通过" : failed.map((criterion) => criterion.name + " " + percent(criterion.score)).join("、")) + "），本次 execution 判失败。"];
-	if (attempt.findings.length > 0) {
+	const located = locatedFindingLines(attempt);
+	if (located.length > 0) {
 		lines.push("验收报告记录的可定位问题：");
-		for (const finding of attempt.findings) lines.push("- " + finding);
+		for (const line of located) lines.push("- " + line);
 	} else lines.push("本次验收没有记录可定位的问题；请对照任务要求与验收面板中的判据得分核对证据中的真实输出。");
 	return lines.join("\n");
 }
+/**
+* The locatable problem lines of one attempt, structured findings first.
+*
+* A structured finding renders the requirement, the observed fact, the gap and
+* the citation in a fixed order, so the fixing agent reads WHAT was required,
+* WHAT was seen, WHY it falls short and WHERE to look — never a bare complaint.
+* @param attempt - the attempt whose findings are rendered.
+* @returns one line per finding, bounded.
+*/
+function locatedFindingLines(attempt) {
+	const structured = attempt.criterionFindings ?? [];
+	if (structured.length > 0) return structured.map((finding) => {
+		const locator = "[" + finding.criterionId + " " + finding.location + "] \"" + clip(finding.quote, 200) + "\"";
+		const action = finding.action === void 0 || finding.action === "" ? "" : " → 建议核实：" + finding.action;
+		return locator + " 要求：" + finding.requirement + " 观测：" + finding.observation + " 差异：" + finding.gap + action;
+	});
+	return [...attempt.findings];
+}
+/** Bound one text for a single-line rendering. */
+function clip(text, max) {
+	const value = text.replace(/s+/g, " ").trim();
+	return value.length <= max ? value : value.slice(0, max) + "…";
+}
 /** `0.42` style percentage. */
 function percent(value) {
 	return (value * 100).toFixed(1) + "%";
@@ -1718,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;
@@ -1737,6 +2423,7 @@ function isTaskRecordShape(value) {
 		if (entry.initiatedBy !== void 0 && typeof entry.initiatedBy !== "string") return false;
 		if (entry.frozenBy !== void 0 && typeof entry.frozenBy !== "string") return false;
 		if (entry.frozenAt !== void 0 && typeof entry.frozenAt !== "number") return false;
+		if (entry.external !== void 0 && typeof entry.external !== "boolean") return false;
 		if (entry.verification !== void 0 && normalizeVerification(entry.verification) === void 0) return false;
 	}
 	return true;
@@ -1749,23 +2436,62 @@ function isTaskRecord(value) {
 function normalizeStatus(status) {
 	return isTaskStatus(status) ? status : "todo";
 }
+/** A persisted ms timestamp, kept only when it is a usable finite number. */
+function optionalInstant(value) {
+	return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+/** A persisted positive-integer run cap, or undefined for unlimited/repair. */
+function optionalRunCap(value) {
+	return typeof value === "number" && Number.isInteger(value) && value >= 1 ? value : void 0;
+}
+/** A persisted stop reason, kept only when it names a reason this build knows. */
+function optionalStopReason(value) {
+	return typeof value === "string" && SCHEDULE_STOP_REASONS.includes(value) ? value : void 0;
+}
 /**
-* Repair a persisted schedule rule: drop rules without a usable cron string,
-* coerce booleans/numbers, and leave `nextRunAt`/`lastTriggeredAt` undefined
-* when missing (a fresh recompute or the next tick fixes them).
+* Repair a persisted schedule rule. Both modes are repaired field by field and
+* a rule that carries no usable plan is dropped (the task row survives):
+* a recurring rule without a well-formed 5-field cron, or a one-shot without a
+* finite planned instant. A rule written before `mode` existed is a cron rule.
 */
 function normalizeSchedule(schedule) {
 	if (typeof schedule !== "object" || schedule === null) return void 0;
 	const rule = schedule;
+	const timeZone = typeof rule.timeZone === "string" && isValidTimeZone(rule.timeZone) ? rule.timeZone : void 0;
+	const runCountValue = rule.runCount;
+	const runCount = typeof runCountValue === "number" && Number.isInteger(runCountValue) && runCountValue >= 0 ? runCountValue : 0;
+	const endedAt = optionalInstant(rule.endedAt);
+	const endedReason = optionalStopReason(rule.endedReason);
+	const skippedAt = optionalInstant(rule.skippedAt);
+	const skippedReason = optionalStopReason(rule.skippedReason);
+	const common = {
+		enabled: rule.enabled === true,
+		...timeZone === void 0 ? {} : { timeZone },
+		nextRunAt: optionalInstant(rule.nextRunAt),
+		lastTriggeredAt: optionalInstant(rule.lastTriggeredAt),
+		runCount,
+		...endedAt === void 0 ? {} : { endedAt },
+		...endedReason === void 0 ? {} : { endedReason },
+		...skippedAt === void 0 ? {} : { skippedAt },
+		...skippedReason === void 0 ? {} : { skippedReason }
+	};
+	if (rule.mode === "once") {
+		const at = optionalInstant(rule.at);
+		if (at === void 0) return void 0;
+		return {
+			...common,
+			mode: "once",
+			at
+		};
+	}
 	if (typeof rule.cron !== "string") return void 0;
 	if (rule.cron.trim() === "" || !isValidCron(rule.cron)) return void 0;
-	const timeZone = typeof rule.timeZone === "string" && isValidTimeZone(rule.timeZone) ? rule.timeZone : void 0;
+	const maxRuns = optionalRunCap(rule.maxRuns);
 	return {
-		enabled: rule.enabled === true,
+		...common,
+		mode: "cron",
 		cron: rule.cron,
-		...timeZone === void 0 ? {} : { timeZone },
-		nextRunAt: typeof rule.nextRunAt === "number" ? rule.nextRunAt : void 0,
-		lastTriggeredAt: typeof rule.lastTriggeredAt === "number" ? rule.lastTriggeredAt : void 0
+		...maxRuns === void 0 ? {} : { maxRuns }
 	};
 }
 /**
@@ -1842,14 +2568,16 @@ function parseLedger(raw) {
 			runGroupId: normalizeTargetId(execution.runGroupId),
 			ownResult: isExecutionOutcome(execution.ownResult) ? execution.ownResult : void 0,
 			ownError: typeof execution.ownError === "string" ? execution.ownError : void 0,
-			verification: normalizeVerification(execution.verification)
+			verification: normalizeVerification(execution.verification),
+			external: execution.external === true ? true : void 0
 		}));
 		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;
-		task.goalRun = row.goalRun === false ? false : void 0;
+		task.goalRun = row.goalRun === true ? true : void 0;
 		task.skipVerification = row.skipVerification === true ? true : void 0;
 		task.freeze = normalizeFreeze(row.freeze);
 		task.handover = normalizeHandover(row.handover);
@@ -1946,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
@@ -1958,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,
@@ -1995,28 +2778,67 @@ 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 && requested.cron.trim() !== "" && isValidCron(requested.cron)) {
-		const cron = requested.cron.trim();
+	if (requested?.enabled === true) {
 		const requestedZone = requested.timeZone;
 		if (requestedZone !== void 0 && !isValidTimeZone(requestedZone)) return {
 			task: void 0,
 			tasks,
 			error: "invalid schedule time zone"
 		};
-		const nextRunAt = nextRunAtMs(cron, now, requestedZone ?? hostTimeZone);
-		if (nextRunAt !== void 0) task = withSchedule(task, {
-			enabled: true,
-			cron,
-			timeZone: requestedZone,
-			nextRunAt
-		}, now);
+		if (requested.mode === "once") {
+			const at = requested.at;
+			if (at === void 0 || !Number.isInteger(at) || at <= now) return {
+				task: void 0,
+				tasks,
+				error: "invalid schedule instant"
+			};
+			task = withSchedule(task, {
+				enabled: true,
+				mode: "once",
+				at,
+				timeZone: requestedZone,
+				nextRunAt: at,
+				runCount: 0
+			}, now);
+		} else {
+			const cron = (requested.cron ?? "").trim();
+			if (cron !== "" && isValidCron(cron)) {
+				const maxRuns = requested.maxRuns;
+				if (maxRuns !== void 0 && (!Number.isInteger(maxRuns) || maxRuns < 1)) return {
+					task: void 0,
+					tasks,
+					error: "invalid schedule run cap"
+				};
+				const nextRunAt = nextRunAtMs(cron, now, requestedZone ?? hostTimeZone);
+				if (nextRunAt !== void 0) task = withSchedule(task, {
+					enabled: true,
+					mode: "cron",
+					cron,
+					maxRuns,
+					timeZone: requestedZone,
+					nextRunAt,
+					runCount: 0
+				}, now);
+			}
+		}
 	}
 	return {
 		task,
@@ -2047,16 +2869,30 @@ function applyDeleteTask(tasks, selectedTaskId, id) {
 //#endregion
 //#region src/core/use-cases/task-schedule.ts
 /**
-* Schedule use case: arm/disarm a task's cron rule and roll a rule forward.
-* Pure ledger transitions (no persistence or notify — the controller
-* orchestrates those). Validation and next-run computation live here, sharing
-* the core cron parser (schedule.ts) and the withSchedule transition.
-*/
-/**
-* Set an on-board task's schedule rule. A blank or invalid cron, an unknown or
-* archived task, or an unusable zone is rejected (state untouched); an enabled
-* rule computes the next run instant immediately in the rule's own zone, a
-* disabled one carries no next-run instant.
+* Schedule use cases: arm/disarm a task's scheduling rule, and record what a
+* due occurrence did to it. Pure ledger transitions (no persistence or notify
+* — the controller orchestrates those). Validation and next-run computation
+* live here, sharing the core cron parser (schedule.ts) and the withSchedule
+* transition.
+*
+* A rule is either a recurring cron rule or a single planned instant, and
+* either kind may be capped by a run budget. The counter (`runCount`) moves
+* only when the Host actually opened an execution; a skipped occurrence
+* (busy, unconfirmed permission, missed instant, unreachable plan) moves the
+* rule without consuming its budget.
+*/
+/**
+* Set an on-board task's scheduling rule. An unknown or archived task, an
+* unusable zone, a blank or invalid cron, a one-shot with no usable instant,
+* a one-shot armed in the past, and a run cap that is not a positive integer
+* are all rejected (state untouched). An enabled rule computes its next run
+* instant immediately — a one-shot's next instant IS its planned instant — and
+* a disabled rule carries none.
+*
+* Arming a rule that was not enabled, or switching its kind, starts a fresh
+* budget: the run counter and any previous stop/skip record are cleared. Edits
+* to a live rule (expression, zone, cap) keep the consumed count, so an
+* already-spent budget can never silently reset and overrun.
 * @param tasks - current ledger.
 * @param id - the task to schedule.
 * @param patch - rule fields to change (absent fields keep their current value).
@@ -2070,47 +2906,168 @@ function applySetSchedule(tasks, id, patch, now, hostTimeZone) {
 		applied: false
 	};
 	const current = task.schedule;
+	const mode = patch.mode ?? current?.mode ?? "cron";
+	const timeZone = patch.timeZone === void 0 ? current?.timeZone : patch.timeZone ?? void 0;
+	if (timeZone !== void 0 && !isValidTimeZone(timeZone)) return {
+		tasks,
+		applied: false
+	};
+	const enabled = patch.enabled ?? current?.enabled ?? false;
+	const restart = enabled && current?.enabled !== true || (current?.mode ?? "cron") !== mode;
+	const runCount = restart ? 0 : current?.runCount ?? 0;
+	const effectiveZone = timeZone ?? hostTimeZone;
+	const cleared = restart ? {
+		endedAt: void 0,
+		endedReason: void 0,
+		skippedAt: void 0,
+		skippedReason: void 0
+	} : {
+		endedAt: current?.endedAt,
+		endedReason: current?.endedReason,
+		skippedAt: current?.skippedAt,
+		skippedReason: current?.skippedReason
+	};
+	if (mode === "once") {
+		const at = patch.at ?? current?.at;
+		if (at === void 0 || !Number.isInteger(at)) return {
+			tasks,
+			applied: false
+		};
+		if (enabled && at <= now) return {
+			tasks,
+			applied: false
+		};
+		return {
+			tasks: tasks.map((candidate) => candidate.id !== id ? candidate : withSchedule(candidate, {
+				enabled,
+				mode: "once",
+				at,
+				cron: void 0,
+				maxRuns: void 0,
+				timeZone: timeZone ?? void 0,
+				nextRunAt: enabled ? at : void 0,
+				runCount,
+				...cleared
+			}, now)),
+			applied: true
+		};
+	}
 	const cron = (patch.cron ?? current?.cron ?? "").trim();
 	if (cron === "" || !isValidCron(cron)) return {
 		tasks,
 		applied: false
 	};
-	const requestedZone = patch.timeZone === void 0 ? current?.timeZone : patch.timeZone ?? void 0;
-	if (requestedZone !== void 0 && !isValidTimeZone(requestedZone)) return {
+	const maxRuns = ("maxRuns" in patch ? patch.maxRuns : current?.maxRuns) ?? void 0;
+	if (maxRuns !== void 0 && (!Number.isInteger(maxRuns) || maxRuns < 1)) return {
 		tasks,
 		applied: false
 	};
-	const enabled = patch.enabled ?? current?.enabled ?? false;
-	const nextRunAt = enabled ? nextRunAtMs(cron, now, requestedZone ?? hostTimeZone) : void 0;
-	if (enabled && nextRunAt === void 0) return {
+	const spent = maxRuns !== void 0 && runCount >= maxRuns;
+	const armed = enabled && !spent;
+	const nextRunAt = armed ? nextRunAtMs(cron, now, effectiveZone) : void 0;
+	if (armed && nextRunAt === void 0) return {
 		tasks,
 		applied: false
 	};
+	const exhausted = enabled && spent;
 	return {
-		tasks: tasks.map((candidate) => candidate.id === id ? withSchedule(candidate, {
-			enabled,
+		tasks: tasks.map((candidate) => candidate.id !== id ? candidate : withSchedule(candidate, {
+			enabled: armed,
+			mode: "cron",
 			cron,
-			timeZone: requestedZone ?? void 0,
-			nextRunAt
-		}, now) : candidate),
+			at: void 0,
+			maxRuns,
+			timeZone: timeZone ?? void 0,
+			nextRunAt,
+			runCount,
+			...exhausted ? {
+				endedAt: now,
+				endedReason: "limit"
+			} : cleared
+		}, now)),
 		applied: true
 	};
 }
 /**
-* Roll a task's schedule rule forward (scheduler callback): persist the next
-* due instant and the trigger instant. No-op for tasks without a rule (deleted
-* mid-tick, for example).
+* Refund the one scheduled run an occurrence consumed before its launch failed
+* without ever creating a session. Nothing ran, so the run budget is restored
+* and the rule is left able to serve its next occurrence — a launch failure
+* must never silently spend the user's limited budget.
+*
+* A recurring rule keeps its already-rolled-forward target; a fire that ended
+* the rule at its cap (no target left) is restored and re-armed at the next
+* occurrence, so a failed launch consumes nothing. A one-shot has no later
+* occurrence, so it is left stopped with `launch-failed` and its run returned.
+* A rule the user disabled in the meantime is not resurrected.
+* @param tasks - current ledger.
+* @param id - the task whose occurrence is being refunded.
+* @param now - clock instant (ms epoch).
+* @param hostTimeZone - zone a rule with no stored zone follows.
+* @returns the next ledger.
+*/
+function applyScheduleRefund(tasks, id, now, hostTimeZone) {
+	return tasks.map((task) => {
+		if (task.id !== id || task.archivedAt !== void 0 || task.schedule === void 0) return task;
+		const rule = task.schedule;
+		const runCount = Math.max(rule.runCount - 1, 0);
+		if (rule.mode === "once") return withSchedule(task, {
+			enabled: false,
+			runCount,
+			nextRunAt: void 0,
+			endedAt: now,
+			endedReason: "launch-failed",
+			skippedAt: void 0,
+			skippedReason: void 0
+		}, now);
+		const refunded = withSchedule(task, {
+			runCount,
+			skippedAt: now,
+			skippedReason: "launch-failed"
+		}, now);
+		if (rule.nextRunAt !== void 0 || rule.endedReason !== "limit") return refunded;
+		const cron = rule.cron ?? "";
+		const next = cron === "" ? void 0 : nextRunAtMs(cron, now, rule.timeZone ?? hostTimeZone);
+		return withSchedule(refunded, next === void 0 ? {
+			enabled: false,
+			endedAt: now,
+			endedReason: "no-target"
+		} : {
+			enabled: true,
+			nextRunAt: next,
+			endedAt: void 0,
+			endedReason: void 0
+		}, now);
+	});
+}
+/**
+* Record what a due occurrence did to a task's rule: advance the run counter
+* by the executions it opened, set the next target (or stop the rule), and
+* note a terminal reason or a skipped occurrence. Nothing is written for a
+* task that has no rule or has been archived mid-tick.
 * @param tasks - current ledger.
-* @param id - the task to roll forward.
-* @param nextRunAt - next due instant (may be undefined to clear).
-* @param lastTriggeredAt - the trigger instant of this run.
+* @param id - the task whose rule fired.
+* @param progress - the occurrence's effect.
 * @param now - clock instant (ms epoch).
+* @returns the next ledger.
 */
-function applyScheduleNextRun(tasks, id, nextRunAt, lastTriggeredAt, now) {
-	return tasks.map((task) => task.id === id && task.archivedAt === void 0 && task.schedule !== void 0 ? withSchedule(task, {
-		nextRunAt,
-		lastTriggeredAt
-	}, now) : task);
+function applyScheduleProgress(tasks, id, progress, now) {
+	return tasks.map((task) => {
+		if (task.id !== id || task.archivedAt !== void 0 || task.schedule === void 0) return task;
+		return withSchedule(task, {
+			runCount: task.schedule.runCount + progress.consumed,
+			nextRunAt: progress.nextRunAt,
+			...progress.lastTriggeredAt === void 0 ? {} : { lastTriggeredAt: progress.lastTriggeredAt },
+			...progress.endedReason === void 0 ? {} : {
+				enabled: false,
+				endedAt: now,
+				endedReason: progress.endedReason
+			},
+			...progress.skippedReason === void 0 ? {} : {
+				skippedAt: now,
+				skippedReason: progress.skippedReason
+			}
+		}, now);
+	});
 }
 //#endregion
 //#region src/core/use-cases/task-parent.ts
@@ -2356,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,
@@ -2375,27 +3333,31 @@ function applyUpdateTask(tasks, id, patch, now) {
 		if ("permission" in patch && patch.permission !== void 0 && patch.permission !== task.permission || "handover" in patch) next.permissionConfirmedAt = void 0;
 		if ("reuseSession" in patch) next.reuseSession = patch.reuseSession === true ? true : void 0;
 		if ("teamRun" in patch) next.teamRun = patch.teamRun === true ? true : void 0;
-		if ("goalRun" in patch) next.goalRun = patch.goalRun === false ? false : void 0;
+		if ("goalRun" in patch) next.goalRun = patch.goalRun === true ? true : void 0;
 		if ("skipVerification" in patch) next.skipVerification = patch.skipVerification === true ? true : void 0;
 		if (workspaceId !== void 0 || "workspaceId" in patch) next.workspaceId = workspaceId;
 		if (mode !== void 0 || "mode" in patch) next.mode = mode;
 		if (permission !== void 0 || "permission" in patch) next.permission = permission;
 		if (model !== void 0 || "model" in patch) next.model = model;
+		if (reasoningEffort !== void 0 || "reasoningEffort" in patch) next.reasoningEffort = reasoningEffort;
 		return next;
 	});
 }
 /**
-* Every older generation the loader migrates in place. v5 only ADDS the
-* per-execution acceptance block, so the migration is the normalization pass
-* that re-validates each row; a document from any listed generation upgrades
-* losslessly.
+* Every older generation the loader migrates in place. v5 only added the
+* per-execution acceptance block and v6 only added the scheduling mode and run
+* budget, so the migration is the normalization pass that re-validates each
+* row; a document from any listed generation upgrades losslessly.
 */
 const TASK_BOARD_MIGRATABLE_SCHEMA_VERSIONS = [
+	5,
 	4,
 	3,
 	2
 ];
 const TASK_BOARD_API_PREFIX = "/api/task-board";
+/** Longest accepted free-text summary on an external outcome record. */
+const EXTERNAL_SUMMARY_MAX_LENGTH = 1e3;
 /** Strict parse of a `/parse` request body; undefined rejects the request. */
 function parseTaskParseRequest(value) {
 	if (typeof value !== "object" || value === null) return void 0;
@@ -2433,15 +3395,39 @@ function hasForbiddenImportField(value) {
 function optionalFiniteNumber(value) {
 	return value === void 0 || typeof value === "number" && Number.isFinite(value);
 }
+/** Whether a stop-reason field names a reason this build understands. */
+function validStopReason(value) {
+	return value === void 0 || typeof value === "string" && SCHEDULE_STOP_REASONS.includes(value);
+}
+/**
+* Whether an imported schedule rule is structurally usable. A one-shot must
+* carry its planned instant and a recurring rule its cron expression; the
+* counter and stop record are optional (a rule written before them simply has
+* none), but a value that IS present must be usable so the import cannot smuggle
+* a rule the scheduler would misread.
+*/
+function validImportedSchedule(value) {
+	const schedule = record(value);
+	if (schedule === void 0 || typeof schedule.enabled !== "boolean") return false;
+	if (schedule.mode !== void 0 && schedule.mode !== "cron" && schedule.mode !== "once") return false;
+	if (schedule.mode === "once") {
+		if (typeof schedule.at !== "number" || !Number.isFinite(schedule.at)) return false;
+	} else if (typeof schedule.cron !== "string") return false;
+	if (schedule.cron !== void 0 && typeof schedule.cron !== "string") return false;
+	if (schedule.at !== void 0 && (typeof schedule.at !== "number" || !Number.isFinite(schedule.at))) return false;
+	if (schedule.maxRuns !== void 0 && (typeof schedule.maxRuns !== "number" || !Number.isInteger(schedule.maxRuns) || schedule.maxRuns < 1)) return false;
+	if (schedule.runCount !== void 0 && (typeof schedule.runCount !== "number" || !Number.isInteger(schedule.runCount) || schedule.runCount < 0)) return false;
+	if (!optionalFiniteNumber(schedule.nextRunAt) || !optionalFiniteNumber(schedule.lastTriggeredAt)) return false;
+	if (!optionalFiniteNumber(schedule.endedAt) || !optionalFiniteNumber(schedule.skippedAt)) return false;
+	if (!validStopReason(schedule.endedReason) || !validStopReason(schedule.skippedReason)) return false;
+	if (schedule.timeZone !== void 0 && (typeof schedule.timeZone !== "string" || !isValidTimeZone(schedule.timeZone))) return false;
+	return true;
+}
 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) {
-		const schedule = record(value.schedule);
-		if (schedule === void 0 || typeof schedule.enabled !== "boolean" || typeof schedule.cron !== "string") return false;
-		if (!optionalFiniteNumber(schedule.nextRunAt) || !optionalFiniteNumber(schedule.lastTriggeredAt)) return false;
-		if (schedule.timeZone !== void 0 && (typeof schedule.timeZone !== "string" || !isValidTimeZone(schedule.timeZone))) return false;
-	}
+	if (value.schedule !== void 0 && !validImportedSchedule(value.schedule)) return false;
 	if (value.executions !== void 0) {
 		if (!Array.isArray(value.executions)) return false;
 		for (const item of value.executions) {
@@ -2455,6 +3441,7 @@ function validImportedKnownFields(value) {
 				"cancelled"
 			].includes(String(execution.result))) return false;
 			if (execution.initiatedBy !== void 0 && typeof execution.initiatedBy !== "string") return false;
+			if (execution.external !== void 0 && typeof execution.external !== "boolean") return false;
 			if (execution.frozenBy !== void 0 && typeof execution.frozenBy !== "string") return false;
 			if (execution.frozenAt !== void 0 && typeof execution.frozenAt !== "number") return false;
 			if (execution.verification !== void 0 && normalizeVerification(execution.verification) === void 0) return false;
@@ -2483,20 +3470,17 @@ function importedTask(value) {
 			result: execution.result,
 			error: execution.error,
 			...execution.initiatedBy === void 0 ? {} : { initiatedBy: execution.initiatedBy },
+			...execution.external === true ? { external: true } : {},
 			...execution.frozenAt === void 0 ? {} : { frozenAt: execution.frozenAt },
 			...execution.frozenBy === void 0 ? {} : { frozenBy: execution.frozenBy }
 		})),
-		...task.schedule === void 0 ? {} : { schedule: {
-			enabled: task.schedule.enabled,
-			cron: task.schedule.cron,
-			...task.schedule.timeZone === void 0 ? {} : { timeZone: task.schedule.timeZone },
-			nextRunAt: task.schedule.nextRunAt,
-			lastTriggeredAt: task.schedule.lastTriggeredAt
-		} },
+		...task.schedule === void 0 ? {} : { schedule: { ...task.schedule } },
 		...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 },
@@ -2545,6 +3529,8 @@ function createInput(value) {
 		"freeze",
 		"handover",
 		"model",
+		"reasoningEffort",
+		"applyCardDefaults",
 		"reuseSession",
 		"teamRun",
 		"goalRun",
@@ -2554,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;
@@ -2568,10 +3555,17 @@ function createInput(value) {
 		const schedule = record(input.schedule);
 		if (schedule === void 0 || !exactKeys(schedule, [
 			"enabled",
+			"mode",
 			"cron",
-			"timeZone"
+			"at",
+			"timeZone",
+			"maxRuns"
 		])) return false;
-		if (typeof schedule.enabled !== "boolean" || typeof schedule.cron !== "string") return false;
+		if (typeof schedule.enabled !== "boolean") return false;
+		if (schedule.mode !== void 0 && schedule.mode !== "cron" && schedule.mode !== "once") return false;
+		if (schedule.cron !== void 0 && typeof schedule.cron !== "string") return false;
+		if (schedule.at !== void 0 && (typeof schedule.at !== "number" || !Number.isInteger(schedule.at))) return false;
+		if (schedule.maxRuns !== void 0 && (typeof schedule.maxRuns !== "number" || !Number.isInteger(schedule.maxRuns) || schedule.maxRuns < 1)) return false;
 		if (schedule.timeZone !== void 0 && (typeof schedule.timeZone !== "string" || !isValidTimeZone(schedule.timeZone))) return false;
 	}
 	return true;
@@ -2588,6 +3582,7 @@ function updatePatch(value) {
 		"freeze",
 		"handover",
 		"model",
+		"reasoningEffort",
 		"reuseSession",
 		"teamRun",
 		"goalRun",
@@ -2604,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;
@@ -2623,9 +3619,12 @@ function schedulePatch(value) {
 	const patch = record(value);
 	return patch !== void 0 && exactKeys(patch, [
 		"enabled",
+		"mode",
 		"cron",
-		"timeZone"
-	]) && (patch.enabled === void 0 || typeof patch.enabled === "boolean") && (patch.cron === void 0 || typeof patch.cron === "string") && (patch.timeZone === void 0 || patch.timeZone === null || typeof patch.timeZone === "string" && isValidTimeZone(patch.timeZone));
+		"at",
+		"timeZone",
+		"maxRuns"
+	]) && (patch.enabled === void 0 || typeof patch.enabled === "boolean") && (patch.mode === void 0 || patch.mode === "cron" || patch.mode === "once") && (patch.cron === void 0 || typeof patch.cron === "string") && (patch.at === void 0 || typeof patch.at === "number" && Number.isInteger(patch.at)) && (patch.timeZone === void 0 || patch.timeZone === null || typeof patch.timeZone === "string" && isValidTimeZone(patch.timeZone)) && (patch.maxRuns === void 0 || patch.maxRuns === null || typeof patch.maxRuns === "number" && Number.isInteger(patch.maxRuns) && patch.maxRuns >= 1);
 }
 function parseActionEnvelope(value) {
 	const parsed = parseEnvelopeAction(value);
@@ -2804,11 +3803,38 @@ function parseEnvelopeAction(value) {
 					...action.payload === void 0 ? {} : { payload: action.payload }
 				}
 			};
+		case "record-external-outcome": {
+			if (!exactKeys(action, [
+				"kind",
+				"taskId",
+				"result",
+				"initiatedBy",
+				"summary"
+			])) return void 0;
+			if (taskId === void 0) return void 0;
+			if (action.result !== "succeeded" && action.result !== "failed") return void 0;
+			if (typeof action.initiatedBy !== "string") return void 0;
+			const initiatedBy = action.initiatedBy.trim();
+			if (initiatedBy === "" || initiatedBy.length > 200) return void 0;
+			if (action.summary !== void 0 && typeof action.summary !== "string") return void 0;
+			const summary = typeof action.summary === "string" ? action.summary.trim().slice(0, EXTERNAL_SUMMARY_MAX_LENGTH) : "";
+			return {
+				requestId: envelope.requestId,
+				action: {
+					kind: "record-external-outcome",
+					taskId,
+					result: action.result,
+					initiatedBy,
+					...summary === "" ? {} : { summary }
+				}
+			};
+		}
 		case "confirm-permission":
 		case "delete":
 		case "archive":
 		case "restore":
 		case "settle":
+		case "reset-verification":
 		case "run":
 		case "rerun":
 			if (!exactKeys(action, ["kind", "taskId"])) return void 0;
@@ -2836,8 +3862,25 @@ function timeZone() {
 function scheduleZone(schedule) {
 	return schedule.timeZone ?? timeZone();
 }
-function cloneTasks(tasks) {
-	return JSON.parse(JSON.stringify(tasks));
+/**
+* The task collection one board read hands out.
+*
+* A read must not hand a consumer the ledger's own array: the state route, every
+* action response and the agent tools all receive this value in-process, so an
+* in-place rewrite of that array (splice, sort, push, `length = 0`) would edit
+* the authoritative document from outside the write path. One level of copying
+* is what that contract needs, and it is all it needs: every write in this class
+* replaces the document's array (`this.document.tasks = ...`) and replaces the
+* records it changes rather than mutating them, so the records a caller receives
+* are stable values. Copying them as well only rebuilt the entire document on
+* every board read - measured at 0.43 ms per read for 400 cards with 2
+* executions each and 2.72 ms for 400 cards with 20 - and bought nothing a
+* consumer relies on. Callers still must not mutate a record in place; that is
+* what the shared record objects now make possible, and no consumer in this
+* package does it.
+*/
+function tasksForRead(tasks) {
+	return [...tasks];
 }
 /**
 * Process states that are dead but still occupy the PID table: `Z` (zombie)
@@ -3103,15 +4146,18 @@ function parseHostTasks(values) {
 		const rawSchedule = rawById.get(task.id)?.schedule;
 		if (typeof rawSchedule !== "object" || rawSchedule === null) return task;
 		const schedule = rawSchedule;
+		if (schedule.mode === "once") return task;
 		if (typeof schedule.cron !== "string" || isValidCron(schedule.cron)) return task;
 		return {
 			...task,
 			schedule: {
 				enabled: false,
+				mode: "cron",
 				cron: schedule.cron,
 				...typeof schedule.timeZone === "string" && isValidTimeZone(schedule.timeZone) ? { timeZone: schedule.timeZone } : {},
 				nextRunAt: void 0,
-				lastTriggeredAt: typeof schedule.lastTriggeredAt === "number" && Number.isFinite(schedule.lastTriggeredAt) ? schedule.lastTriggeredAt : void 0
+				lastTriggeredAt: typeof schedule.lastTriggeredAt === "number" && Number.isFinite(schedule.lastTriggeredAt) ? schedule.lastTriggeredAt : void 0,
+				runCount: typeof schedule.runCount === "number" && Number.isInteger(schedule.runCount) && schedule.runCount >= 0 ? schedule.runCount : 0
 			}
 		};
 	});
@@ -3143,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");
@@ -3202,27 +4251,31 @@ var HostTaskLedger = class {
 		const { revision, scheduler } = this.summary();
 		return {
 			revision,
-			tasks: cloneTasks(this.document.tasks),
+			tasks: tasksForRead(this.document.tasks),
 			scheduler
 		};
 	}
 	/**
-	* Runtime-only projection for the 5 s Host poll. It copies just primitive
+	* Runtime-only projection for the Host poll. It copies just primitive
 	* identifiers and timestamps, never the complete task/execution history or
 	* an authoritative mutable object from the ledger.
 	*/
 	runtimeView() {
 		let armedSchedules = 0;
+		let runningCards = 0;
 		const teamGroups = /* @__PURE__ */ new Set();
 		for (const task of this.document.tasks) {
 			if (task.teamRun !== true) continue;
 			for (const execution of task.executions) if (execution.runGroupId !== void 0) teamGroups.add(execution.runGroupId);
 		}
 		const openExecutions = [];
+		const openSessionIds = [];
 		for (const task of this.document.tasks) {
 			if (task.archivedAt === void 0 && task.schedule?.enabled === true) armedSchedules += 1;
+			if (task.status === "running") runningCards += 1;
 			for (const execution of task.executions) {
 				if (execution.endedAt !== void 0) continue;
+				if (execution.sessionId !== void 0) openSessionIds.push(execution.sessionId);
 				if (execution.ownResult !== void 0) continue;
 				openExecutions.push({
 					taskId: task.id,
@@ -3235,7 +4288,9 @@ var HostTaskLedger = class {
 		}
 		return {
 			armedSchedules,
-			openExecutions
+			openExecutions,
+			openSessionIds,
+			needsSessionState: openExecutions.length > 0 || runningCards > 0
 		};
 	}
 	/** Count armed, non-archived schedules without cloning task histories. */
@@ -3272,7 +4327,8 @@ var HostTaskLedger = class {
 			if (schedule === void 0 || !schedule.enabled || schedule.nextRunAt === void 0 || schedule.nextRunAt > now) continue;
 			due.push({
 				taskId: task.id,
-				cron: schedule.cron,
+				mode: schedule.mode,
+				...schedule.cron === void 0 ? {} : { cron: schedule.cron },
 				timeZone: scheduleZone(schedule),
 				nextRunAt: schedule.nextRunAt
 			});
@@ -3315,41 +4371,144 @@ var HostTaskLedger = class {
 	/**
 	* Open the cascade one due schedule triggers: an empty array means nothing
 	* ran (already running, or a participant whose elevated permission is still
-	* unconfirmed), and the rule rolls to its next occurrence either way.
+	* unconfirmed, a one-shot whose instant was missed, or an exhausted budget),
+	* and the rule's own state says which.
+	*
+	* The run budget is enforced HERE, inside the single ledger writer: a rule
+	* whose counter already reached its cap is stopped instead of opened, so no
+	* restart, repeated timer fire or re-arm can overrun it.
+	* @param taskId - the task whose rule came due.
+	* @param triggeredAt - the instant the occurrence came due.
+	* @returns the executions this occurrence opened.
 	*/
-	openScheduled(taskId, nextRunAt, triggeredAt) {
+	openScheduled(taskId, triggeredAt) {
 		const task = this.document.tasks.find((item) => item.id === taskId);
 		if (task === void 0 || task.archivedAt !== void 0) return [];
-		const rollForward = () => {
-			this.document.tasks = [...applyScheduleNextRun(this.document.tasks, taskId, nextRunAt, task.schedule?.lastTriggeredAt, triggeredAt)];
-			this.commit();
-		};
+		const schedule = task.schedule;
+		if (schedule === void 0 || !schedule.enabled) return [];
+		if (scheduleExhausted(schedule)) {
+			this.progressSchedule(taskId, {
+				consumed: 0,
+				endedReason: schedule.mode === "once" ? "fired" : "limit"
+			}, triggeredAt);
+			return [];
+		}
 		const refusal = this.bindingRefusal(task);
 		if (refusal !== void 0) {
 			this.document.scheduler.error = `scheduled run refused for task ${taskId}: ${bindingRefusalMessage(refusal, this.sessionDefaultPermission, "schedule")}`;
-			rollForward();
+			this.skipOccurrence(taskId, "permission", triggeredAt);
 			return [];
 		}
 		if (hasOpenExecution(task)) {
-			rollForward();
+			this.skipOccurrence(taskId, "busy", triggeredAt);
 			return [];
 		}
-		return this.startCascade(task, triggeredAt, void 0, false, nextRunAt);
+		if (schedule.mode === "once") return this.startCascade(task, triggeredAt, void 0, false, {
+			consumed: 1,
+			lastTriggeredAt: triggeredAt,
+			endedReason: "fired"
+		});
+		const next = nextRunAtMs(schedule.cron ?? "", schedule.nextRunAt ?? triggeredAt, scheduleZone(schedule));
+		if (next === void 0) {
+			this.progressSchedule(taskId, {
+				consumed: 0,
+				endedReason: "no-target"
+			}, triggeredAt);
+			return [];
+		}
+		const consumed = schedule.runCount + 1;
+		const budget = scheduleRunBudget(schedule);
+		const spent = budget !== void 0 && consumed >= budget;
+		return this.startCascade(task, triggeredAt, void 0, false, {
+			consumed: 1,
+			nextRunAt: spent ? void 0 : next,
+			lastTriggeredAt: triggeredAt,
+			...spent ? { endedReason: "limit" } : {}
+		});
+	}
+	/**
+	* Record a due occurrence that opened no execution: roll a recurring rule to
+	* its next occurrence (budget untouched), or stop it when there is none. A
+	* one-shot has no second occurrence, so it always stops here with the reason.
+	*/
+	skipOccurrence(taskId, reason, now) {
+		const schedule = this.document.tasks.find((item) => item.id === taskId)?.schedule;
+		if (schedule === void 0) return;
+		if (schedule.mode === "once") {
+			this.progressSchedule(taskId, {
+				consumed: 0,
+				endedReason: reason
+			}, now);
+			return;
+		}
+		const next = nextRunAtMs(schedule.cron ?? "", schedule.nextRunAt ?? now, scheduleZone(schedule));
+		if (next === void 0) this.progressSchedule(taskId, {
+			consumed: 0,
+			endedReason: "no-target"
+		}, now);
+		else this.progressSchedule(taskId, {
+			consumed: 0,
+			nextRunAt: next,
+			skippedReason: reason
+		}, now);
+	}
+	/** Apply a schedule-occurrence transition and persist it atomically. */
+	progressSchedule(taskId, progress, now) {
+		this.document.tasks = [...applyScheduleProgress(this.document.tasks, taskId, progress, now)];
+		this.commit();
 	}
+	/**
+	* Refund the one scheduled run an occurrence consumed before its launch
+	* failed without creating a session (see
+	* {@link applyScheduleRefund}). Called by the service on the failed-launch
+	* path only; a manual run and a launch that did reach a session are never
+	* refunded. A no-op for a task with no rule, so a failed cascade member does
+	* not touch anything.
+	* @param taskId - the task whose occurrence is being refunded.
+	* @param now - clock instant (ms epoch).
+	*/
+	refundScheduledOccurrence(taskId, now) {
+		const before = this.document.tasks.find((item) => item.id === taskId)?.schedule;
+		if (before === void 0) return;
+		const next = applyScheduleRefund(this.document.tasks, taskId, now, timeZone());
+		const after = next.find((item) => item.id === taskId)?.schedule;
+		if (JSON.stringify(before) === JSON.stringify(after)) return;
+		this.document.tasks = [...next];
+		this.commit();
+	}
+	/**
+	* Boot / resume recovery: skip every occurrence that came due while the board
+	* was not running through it. A recurring rule rolls to its next future
+	* target; a one-shot whose instant has passed is stopped as missed, because
+	* there is no later occurrence left to run. Rendering the missed occurrence
+	* is deliberately not attempted: the ACL of a card that fired hours ago is
+	* stale, and the board's own recovery contract is "missed triggers are
+	* skipped, never replayed".
+	*/
 	skipMissed(now) {
 		let changed = false;
 		this.document.tasks = this.document.tasks.map((task) => {
 			const schedule = task.schedule;
 			if (schedule === void 0 || !schedule.enabled || schedule.nextRunAt === void 0 || schedule.nextRunAt > now) return task;
 			changed = true;
-			return {
-				...task,
-				schedule: {
-					...schedule,
-					nextRunAt: nextRunAtMs(schedule.cron, now, scheduleZone(schedule))
-				},
-				updatedAt: now
-			};
+			if (schedule.mode === "once") return withSchedule(task, {
+				enabled: false,
+				nextRunAt: void 0,
+				endedAt: now,
+				endedReason: "missed"
+			}, now);
+			const next = nextRunAtMs(schedule.cron ?? "", now, scheduleZone(schedule));
+			if (next === void 0) return withSchedule(task, {
+				enabled: false,
+				nextRunAt: void 0,
+				endedAt: now,
+				endedReason: "no-target"
+			}, now);
+			return withSchedule(task, {
+				nextRunAt: next,
+				skippedAt: now,
+				skippedReason: "missed"
+			}, now);
 		});
 		if (changed) this.commit();
 	}
@@ -3434,7 +4593,7 @@ var HostTaskLedger = class {
 			case "import": {
 				const sources = new Set(this.document.scheduler.importedSources ?? []);
 				if (sources.has(action.sourceId)) return { state: this.state() };
-				const invalidScheduleIds = action.tasks.filter((task) => task.schedule !== void 0 && !isValidCron(task.schedule.cron)).map((task) => task.id);
+				const invalidScheduleIds = action.tasks.filter((task) => task.schedule !== void 0 && task.schedule.mode !== "once" && !isValidCron(task.schedule.cron ?? "")).map((task) => task.id);
 				const incoming = parseHostTasks(action.tasks);
 				const merged = new Map(this.document.tasks.map((task) => [task.id, task]));
 				for (const task of incoming) merged.set(task.id, merged.has(task.id) ? mergeTask(merged.get(task.id), task) : task);
@@ -3448,7 +4607,8 @@ var HostTaskLedger = class {
 			}
 			case "create": {
 				if (this.document.tasks.some((task) => task.id === action.id)) throw new Error("task id already exists");
-				if (action.input.schedule?.enabled === true && (!isValidCron(action.input.schedule.cron) || !isValidTimeZone(action.input.schedule.timeZone ?? timeZone()) || nextRunAtMs(action.input.schedule.cron, now, action.input.schedule.timeZone ?? timeZone()) === void 0)) throw new Error("invalid schedule");
+				const requested = action.input.schedule;
+				if (requested?.enabled === true && !this.validScheduleRequest(requested, now)) throw new Error("invalid schedule");
 				const input = action.input.freeze === void 0 || initiator === void 0 || initiator === "" ? action.input : {
 					...action.input,
 					freeze: {
@@ -3456,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;
@@ -3507,6 +4667,29 @@ var HostTaskLedger = class {
 				this.document.tasks = [...result.tasks];
 				break;
 			}
+			case "record-external-outcome": {
+				const task = this.document.tasks.find((item) => item.id === action.taskId);
+				if (task === void 0) throw new Error("task not found");
+				if (task.archivedAt !== void 0) throw new Error("archived task is read-only");
+				if (hasOpenExecution(task)) throw new Error("running task cannot receive an external outcome");
+				const execution = {
+					id: crypto.randomUUID(),
+					sessionId: void 0,
+					startedAt: now,
+					endedAt: now,
+					result: action.result,
+					error: action.summary,
+					initiatedBy: action.initiatedBy,
+					external: true
+				};
+				this.document.tasks = this.document.tasks.map((item) => item.id !== action.taskId ? item : {
+					...item,
+					status: settledStatus(item, action.result),
+					updatedAt: now,
+					executions: retainRecentExecutions([...item.executions, execution])
+				});
+				break;
+			}
 			case "settle": {
 				const task = this.document.tasks.find((item) => item.id === action.taskId);
 				if (task === void 0) throw new Error("task not found");
@@ -3520,6 +4703,26 @@ var HostTaskLedger = class {
 				this.finalizeReadyRuns(false);
 				break;
 			}
+			case "reset-verification": {
+				const task = this.document.tasks.find((item) => item.id === action.taskId);
+				if (task === void 0) throw new Error("task not found");
+				if (task.archivedAt !== void 0) throw new Error("archived task is read-only");
+				const execution = [...task.executions].reverse().find((entry) => entry.endedAt === void 0);
+				if (execution === void 0) throw new Error("task has no open execution");
+				const verification = execution.verification;
+				if (verification === void 0 || verification.applicability !== "enforced") throw new Error("this execution is not gated by task acceptance");
+				const cleared = withoutAcceptanceAnomalies(verification);
+				if (cleared === void 0) throw new Error("this execution has no acceptance anomaly to reset");
+				this.document.tasks = this.document.tasks.map((item) => item.id !== action.taskId ? item : {
+					...item,
+					updatedAt: now,
+					executions: item.executions.map((entry) => entry.id === execution.id ? {
+						...entry,
+						verification: cleared
+					} : entry)
+				});
+				break;
+			}
 			case "restore": {
 				if (this.subtreeHasOpenExecution(action.taskId)) throw new Error("running task cannot be restored");
 				const result = applyRestoreTask(this.document.tasks, action.taskId, now, this.maxSubtaskDepth);
@@ -3575,6 +4778,21 @@ var HostTaskLedger = class {
 		};
 	}
 	/**
+	* Whether a creation-time schedule request is usable. A one-shot must carry
+	* a whole-millisecond instant in the future; a recurring rule must carry a
+	* valid expression with a reachable occurrence and, when capped, a positive
+	* whole run budget. An unusable zone is refused rather than reinterpreted as
+	* the Host zone.
+	*/
+	validScheduleRequest(request, now) {
+		if (request.timeZone !== void 0 && !isValidTimeZone(request.timeZone)) return false;
+		if (request.mode === "once") return typeof request.at === "number" && Number.isInteger(request.at) && request.at > now;
+		const cron = (request.cron ?? "").trim();
+		if (cron === "" || !isValidCron(cron)) return false;
+		if (request.maxRuns !== void 0 && (!Number.isInteger(request.maxRuns) || request.maxRuns < 1)) return false;
+		return nextRunAtMs(cron, now, request.timeZone ?? timeZone()) !== void 0;
+	}
+	/**
 	* The binding that makes a run illegal, if any.
 	*
 	* A plain cascade launches one session per participant, so every participant
@@ -3628,17 +4846,20 @@ 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).
 	* @param rerun - true to reset the root to 'todo' before starting it.
-	* @param nextRunAt - when set, the root's schedule also rolls forward.
+	* @param progress - when set, this run was a due occurrence and the root's
+	*   rule is advanced (counter, next target, stop/skip record) in the same
+	*   atomic commit that opened the executions.
 	*/
-	startCascade(root, now, initiator, rerun = false, nextRunAt) {
+	startCascade(root, now, initiator, rerun = false, progress) {
 		const before = this.document.tasks;
 		const groupId = crypto.randomUUID();
 		const team = root.teamRun === true;
@@ -3646,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);
@@ -3657,7 +4879,7 @@ var HostTaskLedger = class {
 		}
 		if (runs.length === 0) return [];
 		let tasks = before.map((task) => started.get(task.id) ?? task);
-		if (nextRunAt !== void 0) tasks = applyScheduleNextRun(tasks, root.id, nextRunAt, now, now);
+		if (progress !== void 0) tasks = applyScheduleProgress(tasks, root.id, progress, now);
 		this.document.tasks = [...tasks];
 		this.commit();
 		return runs;
@@ -3779,6 +5001,14 @@ var HostTaskLedger = class {
 		for (const memberId of members) if (this.settleCascade(memberId, groupId, now)) changed = true;
 		return changed;
 	}
+	/**
+	* Re-align every armed rule at load/import. A recurring rule is recomputed
+	* from the current instant; a one-shot is armed at its planned instant when
+	* that is still in the future, and stopped as missed once it has passed
+	* (there is no later occurrence to run). A recurring rule recomputed past an
+	* occurrence records the skip, so the board can show that a fire was passed
+	* over rather than silently rewinding.
+	*/
 	repairSchedules(skipPast, persist = true) {
 		const now = this.now();
 		let changed = false;
@@ -3786,30 +5016,49 @@ var HostTaskLedger = class {
 			const schedule = task.schedule;
 			if (schedule === void 0 || !schedule.enabled) return task;
 			if (!skipPast && schedule.nextRunAt !== void 0) return task;
-			const next = nextRunAtMs(schedule.cron, now, scheduleZone(schedule));
+			if (schedule.mode === "once") {
+				const at = schedule.at;
+				if (at === void 0) {
+					changed = true;
+					return withSchedule(task, {
+						enabled: false,
+						nextRunAt: void 0,
+						endedAt: now,
+						endedReason: "no-target"
+					}, now);
+				}
+				if (at <= now) {
+					changed = true;
+					return withSchedule(task, {
+						enabled: false,
+						nextRunAt: void 0,
+						endedAt: now,
+						endedReason: "missed"
+					}, now);
+				}
+				if (schedule.nextRunAt === at) return task;
+				changed = true;
+				return withSchedule(task, { nextRunAt: at }, now);
+			}
+			const next = nextRunAtMs(schedule.cron ?? "", now, scheduleZone(schedule));
 			if (next === void 0) {
 				changed = true;
-				this.document.scheduler.error = `invalid cron disabled for task: ${task.id}`;
-				return {
-					...task,
-					schedule: {
-						...schedule,
-						enabled: false,
-						nextRunAt: void 0
-					},
-					updatedAt: now
-				};
+				this.document.scheduler.error = `invalid cron disabled for task: ${task.id}`;
+				return withSchedule(task, {
+					enabled: false,
+					nextRunAt: void 0,
+					endedAt: now,
+					endedReason: "no-target"
+				}, now);
 			}
-			if (schedule.nextRunAt === next) return task;
+			const passed = schedule.nextRunAt !== void 0 && schedule.nextRunAt <= now;
+			if (schedule.nextRunAt === next && !passed) return task;
 			changed = true;
-			return {
-				...task,
-				schedule: {
-					...schedule,
-					nextRunAt: next
-				},
-				updatedAt: now
-			};
+			return withSchedule(task, passed ? {
+				nextRunAt: next,
+				skippedAt: now,
+				skippedReason: "missed"
+			} : { nextRunAt: next }, now);
 		});
 		if (changed && persist) this.commit();
 	}
@@ -3854,7 +5103,7 @@ var HostTaskLedger = class {
 	*/
 	migrateLegacyDocument(parsed) {
 		if (!Array.isArray(parsed.tasks) || !parsed.tasks.every((row) => isTaskRecord(row))) throw new Error(`v${String(parsed.schemaVersion)} document contains structurally invalid task rows`);
-		const rows = parsed.tasks.map((value) => {
+		const rows = typeof parsed.schemaVersion === "number" && parsed.schemaVersion <= 4 ? parsed.tasks.map((value) => {
 			const schedule = value.schedule;
 			if (typeof schedule !== "object" || schedule === null) return value;
 			if (typeof schedule.timeZone === "string") return value;
@@ -3865,7 +5114,7 @@ var HostTaskLedger = class {
 					timeZone: timeZone()
 				}
 			};
-		});
+		}) : parsed.tasks;
 		return this.normalizeDocument({
 			...parsed,
 			tasks: rows
@@ -3931,10 +5180,10 @@ var HostTaskLedger = class {
 		if (typeof parsed.schemaVersion === "number" && TASK_BOARD_MIGRATABLE_SCHEMA_VERSIONS.includes(parsed.schemaVersion)) try {
 			return this.migrateLegacyDocument(parsed);
 		} catch (error) {
-			throw new Error(`ledger v${String(parsed.schemaVersion)} to v5 migration failed; original file kept at ${this.file}: ${error instanceof Error ? error.message : String(error)}`);
+			throw new Error(`ledger v${String(parsed.schemaVersion)} to v6 migration failed; original file kept at ${this.file}: ${error instanceof Error ? error.message : String(error)}`);
 		}
 		try {
-			if (parsed.schemaVersion !== 5 || !Array.isArray(parsed.tasks)) throw new Error("unsupported ledger schema");
+			if (parsed.schemaVersion !== 6 || !Array.isArray(parsed.tasks)) throw new Error("unsupported ledger schema");
 			return this.normalizeDocument(parsed);
 		} catch (error) {
 			return this.recoverCorrupt(dir, existed, error);
@@ -3949,14 +5198,15 @@ var HostTaskLedger = class {
 			if (typeof value !== "object" || value === null) return [];
 			const row = value;
 			if (typeof row.schedule !== "object" || row.schedule === null) return [];
-			const cron = row.schedule.cron;
-			return typeof cron !== "string" || !isValidCron(cron) ? [typeof row.id === "string" ? row.id : "unknown"] : [];
+			const rule = row.schedule;
+			if (rule.mode === "once") return typeof rule.at === "number" && Number.isFinite(rule.at) ? [] : [typeof row.id === "string" ? row.id : "unknown"];
+			return typeof rule.cron !== "string" || !isValidCron(rule.cron) ? [typeof row.id === "string" ? row.id : "unknown"] : [];
 		});
 		const documentLastTickAt = typeof parsed.scheduler?.lastTickAt === "number" ? parsed.scheduler.lastTickAt : void 0;
 		const sidecarLastTickAt = this.readSchedulerSidecar();
 		const lastTickAt = sidecarLastTickAt === void 0 || documentLastTickAt !== void 0 && documentLastTickAt >= sidecarLastTickAt ? documentLastTickAt : sidecarLastTickAt;
 		return {
-			schemaVersion: 5,
+			schemaVersion: 6,
 			revision: Number.isSafeInteger(parsed.revision) && parsed.revision >= 0 ? parsed.revision : 0,
 			tasks,
 			scheduler: {
@@ -3982,7 +5232,7 @@ var HostTaskLedger = class {
 		if (existed) renameSync(this.file, `${this.file}.corrupt-${this.now()}-${process.pid}-${crypto.randomUUID()}`);
 		mkdirSync(dir, { recursive: true });
 		return {
-			schemaVersion: 5,
+			schemaVersion: 6,
 			revision: 0,
 			tasks: [],
 			scheduler: {
@@ -4171,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",
@@ -4261,16 +5600,19 @@ function peerPromptPreamble(context) {
 	return `本次运行同时并发开启 ${peers.length} 个独立 DSH 会话执行下列子任务成员（可用 task_board_* 工具查看它们的进度）：\n${lines.join("\n")}`;
 }
 /**
-* The scheduled-run section: this execution was triggered by the card's cron
-* rule rather than by a person. It states the firing instant, the rule's zone,
-* and the rule text, so the run's own clock is unambiguous — the board's
+* The scheduled-run section: this execution was triggered by the card's
+* schedule rather than by a person. It states the firing instant, the rule's
+* zone, and the rule text, so the run's own clock is unambiguous — the board's
 * scheduler fires on a wall clock in a specific IANA zone, which is not
-* necessarily the zone of whatever session the run lands in.
+* necessarily the zone of whatever session the run lands in. A one-shot says
+* so explicitly, so the run does not expect a recurrence.
 */
 function schedulePromptPreamble(context) {
 	const schedule = context.schedule;
 	if (schedule === void 0) return void 0;
-	return `本次执行由任务看板的定时规则自动触发：触发时间 ${new Date(schedule.triggeredAt).toISOString()}（UTC），规则时区 ${schedule.timeZone}，cron 表达式 ${schedule.cron}。需要判断「今天」「现在」或计算时间窗口时，以该时区的触发时间为准。`;
+	const stamp = new Date(schedule.triggeredAt).toISOString();
+	if (schedule.mode === "once") return `本次执行由任务看板的单次定时自动触发：计划时间 ${stamp}（UTC），时区 ${schedule.timeZone}。这是一次性计划，本次执行之后该卡片不会再自动执行。需要判断「今天」「现在」或计算时间窗口时，以该时区的触发时间为准。`;
+	return `本次执行由任务看板的定时规则自动触发：触发时间 ${stamp}（UTC），规则时区 ${schedule.timeZone}，cron 表达式 ${schedule.cron}。需要判断「今天」「现在」或计算时间窗口时，以该时区的触发时间为准。`;
 }
 /**
 * Build the execution prompt for one task.
@@ -4369,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 }
 		});
 	}
@@ -4399,6 +5753,7 @@ var HostExecutionRunner = class {
 			namespace,
 			method,
 			args: { request },
+			peer: this.ownerPeer,
 			...signal === void 0 ? {} : { signal }
 		});
 	}
@@ -4440,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);
+				await this.pinAndPrompt(reused, task, permission, options.promptContext, options.onGoalArmed, options.goalEnabled === true, options.catalog);
 			} catch (error) {
 				throw new SessionLaunchError(reused, error);
 			}
@@ -4456,7 +5811,7 @@ var HostExecutionRunner = class {
 				sessionId,
 				title: task.title
 			});
-			await this.pinAndPrompt(sessionId, task, permission, options.promptContext, options.onGoalArmed);
+			await this.pinAndPrompt(sessionId, task, permission, options.promptContext, options.onGoalArmed, options.goalEnabled === true, options.catalog);
 		} catch (error) {
 			throw new SessionLaunchError(sessionId, error);
 		}
@@ -4483,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) {
+	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", {
@@ -4518,7 +5928,7 @@ var HostExecutionRunner = class {
 				text: promptText(task, context)
 			}]
 		});
-		const armed = await this.armGoal(sessionId, task, context);
+		const armed = await this.armGoal(sessionId, task, context, goalEnabled);
 		onGoalArmed?.(armed);
 	}
 	/**
@@ -4544,14 +5954,25 @@ var HostExecutionRunner = class {
 	* dsh's goal-round driver keeps starting continuation rounds until the agent
 	* marks it complete (see {@link goalVerdict} for how the run settles).
 	*
-	* Opt-out: a task whose `goalRun` is an explicit false runs one plain turn.
+	* Two switches gate the arming, and BOTH must ask for it:
+	* - the GLOBAL native-/goal switch (`goalEnabled`, default OFF), frozen when
+	*   this execution started; and
+	* - the task's own `goalRun` (absent means off, only an explicit true opts
+	*   the card into a goal run).
+	*
 	* A refusal (no command dispatcher, no `/goal` command in this cohort, an
-	* objective the command rejects) is reported and the run continues as that
-	* plain turn: the task was asked to run, and a missing goal mode must not
-	* lose the work.
+	* objective the command rejects) is reported and the run continues as a plain
+	* turn: the task was asked to run, and a missing goal mode must not lose the
+	* work.
+	* @param sessionId - the session to arm in.
+	* @param task - the task being run.
+	* @param context - the run's prompt context.
+	* @param goalEnabled - the GLOBAL switch, frozen for this execution.
+	* @returns whether `/goal` was really armed.
 	*/
-	async armGoal(sessionId, task, context) {
-		if (task.goalRun === false) return false;
+	async armGoal(sessionId, task, context, goalEnabled) {
+		if (!goalEnabled) return false;
+		if (task.goalRun !== true) return false;
 		if (this.commands === void 0) {
 			console.warn("[dsh-task-board] no command dispatcher is available; task " + task.id + " runs without /goal");
 			return false;
@@ -4710,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 {
@@ -4734,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;
 		}
@@ -5473,8 +6897,8 @@ var TaskBoardExtensionRegistry = class {
 };
 //#endregion
 //#region src/host-service.ts
-/** Session-roster poll cadence — the one recurring Host timer this service still holds. */
-const SESSION_POLL_MS = 5e3;
+/** Ceiling for the roster-poll failure backoff: a broken session tree is retried at most once a minute. */
+const POLL_FAILURE_MAX_BACKOFF_MS = 6e4;
 /**
 * How late an armed schedule fire may be before it counts as a resume rather
 * than a normal occurrence. The schedule timer is armed AT the next due
@@ -5495,10 +6919,51 @@ const MAX_TIMER_DELAY_MS = 2147483647;
 */
 const UNREADABLE_SETTLE_POLLS = 24;
 /**
-* Actions that can move an armed trigger. Only these re-arm the native timer;
-* an unrelated card edit leaves the pending fire untouched.
+* 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.
+*/
+const NO_MATCHING_PASS_VERIFICATION_REASON = "goal 验收：本次执行没有匹配的验收通过记录（验收未运行、未通过或报告来自其他执行），按未验收判失败。";
+/**
+* Why an enforced goal execution settled failed with ZERO acceptance records:
+* the gate was never opened, so the judge never ran and nothing was ever judged
+* (issue #1837). The root cause is a session that declared completion in prose
+* instead of calling `update_goal(action: complete)` — a tool-adherence problem,
+* NOT a quality verdict on the delivery — so this reason says so and keeps the
+* two investigation directions apart.
+*/
+const NEVER_INVOKED_VERIFICATION_REASON = "goal 验收未触发：本次执行没有任何验收记录，验收门从未打开——执行会话没有调用 update_goal(action: complete) 来完成目标（常见于只在回复里宣告完成）。这不是质量判负：交付从未被裁判评估。";
+/**
+* Why an enforced goal execution settled failed while its ONLY acceptance
+* records are INVALID: the judge answered but could not locate its own
+* rejection, so the board stopped calling it. This is NOT an evidence-backed
+* quality veto — the requirement is explicit that such a run must not be
+* described as one — but the execution still has no matching pass, so it ends
+* for lack of one, and the reason names that precisely.
+*/
+const INVALID_ONLY_VERIFICATION_REASON = "goal 验收无效：本次执行只记录了无效验收（裁判未能给出与任务要求对应、且可定位到本次证据的否决依据），看板已停止调用裁判。这**不是**有证据的质量判负：验收本身不可用，本次运行因没有匹配的通过记录而结束。请检查验收环境与证据可见性，或用 task_board_manage(action=reset-verification) 清除记录的无效验收后重新完成目标。";
+/**
+* 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"
@@ -5518,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;
@@ -5525,6 +7010,12 @@ var TaskBoardHostService = class {
 	listeners = /* @__PURE__ */ new Set();
 	/** The one recurring timer: the session-roster poll. */
 	pollTimer;
+	/** Cadence of the roster poll, in seconds (a settings field; see the config schema). */
+	sessionPollSeconds = 5;
+	/** Pending delay that follows a failed poll pass, if one is armed. */
+	pollBackoffTimer;
+	/** Consecutive failed poll passes; doubles the next retry delay. */
+	consecutivePollFailures = 0;
 	/** The armed schedule timer, if a trigger is pending. */
 	scheduleTimer;
 	/** The instant the armed schedule timer targets (ms epoch), for resume detection. */
@@ -5533,12 +7024,11 @@ var TaskBoardHostService = class {
 	pollInFlight = false;
 	active = true;
 	/**
-	* Ids the last roster poll saw as present and idle; undefined while the
-	* roster is unknown. Session reuse (issue #1419) requires this positive
-	* evidence, so a launch before the first successful poll mints a fresh
-	* conversation instead of prompting into a session it cannot see.
+	* 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}).
 	*/
-	idleSessionIds;
+	launches;
 	/**
 	* Consecutive unreadable-history polls per open execution (see
 	* {@link noteUnreadableInspection}). Cleared as soon as an inspection
@@ -5550,6 +7040,16 @@ var TaskBoardHostService = class {
 	verificationCatalog;
 	team;
 	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. */
@@ -5563,14 +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: "",
@@ -5599,14 +7104,35 @@ var TaskBoardHostService = class {
 		this.syncPowerReasons();
 		this.pollTimer = this.timers.interval(() => {
 			this.schedulePoll();
-		}, SESSION_POLL_MS);
+		}, sessionPollMs(this.sessionPollSeconds));
 		this.schedulePoll();
+		this.cleanupPendingAcceptanceDetail();
 		this.recoverSchedule();
 	}
-	setConfiguration(active, preventIdleSleep) {
+	/**
+	* Apply the live configuration. The roster cadence is re-read on every
+	* commit, so a settings edit takes effect without a restart; the poll is
+	* scheduled at the new cadence immediately rather than waiting out the old
+	* interval.
+	* @param active - the board's master switch.
+	* @param preventIdleSleep - whether the board holds an idle-sleep assertion.
+	* @param sessionPollSeconds - roster-poll cadence in seconds (clamped).
+	*/
+	setConfiguration(active, preventIdleSleep, sessionPollSeconds) {
 		const resumed = !this.active && active;
 		this.active = active;
 		this.preventIdleSleep = preventIdleSleep;
+		const cadence = normalizeSessionPollSeconds(sessionPollSeconds);
+		const retimed = this.pollTimer !== void 0 && cadence !== this.sessionPollSeconds;
+		this.sessionPollSeconds = cadence;
+		if (retimed) {
+			this.pollTimer?.();
+			this.pollTimer = this.timers.interval(() => {
+				this.schedulePoll();
+			}, sessionPollMs(this.sessionPollSeconds));
+			this.clearPollBackoff();
+			this.schedulePoll();
+		}
 		if (resumed) {
 			const current = this.power.snapshot();
 			this.power.updateReasons({
@@ -5626,8 +7152,9 @@ var TaskBoardHostService = class {
 	snapshot() {
 		const state = this.ledger.state();
 		const published = this.extensions.published();
+		const cardDefaults = cardDefaultsOf(this.cardDefaults());
 		return {
-			schemaVersion: 5,
+			schemaVersion: 6,
 			revision: state.revision,
 			tasks: state.tasks,
 			scheduler: state.scheduler,
@@ -5635,6 +7162,8 @@ var TaskBoardHostService = class {
 			sessionDefaultPermission: this.ledger.sessionDefaultPermission,
 			maxSubtaskDepth: this.ledger.maxSubtaskDepth,
 			teamRunAvailable: this.team !== void 0,
+			goalRunEnabled: this.goalRunEnabled(),
+			...cardDefaults === void 0 ? {} : { cardDefaults },
 			...Object.keys(published).length === 0 ? {} : { extensions: published }
 		};
 	}
@@ -5731,7 +7260,7 @@ var TaskBoardHostService = class {
 		this.emitStatusChanges(before, initiator);
 		if (action.kind === "delete") this.extensions.emitTaskDeleted({ taskId: action.taskId });
 		return {
-			schemaVersion: 5,
+			schemaVersion: 6,
 			revision: result.state.revision,
 			tasks: result.state.tasks,
 			scheduler: result.state.scheduler,
@@ -5767,18 +7296,23 @@ 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();
 		this.pollTimer?.();
 		this.pollTimer = void 0;
 		this.power.dispose();
 		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 {
 			const team = opened.task.teamRun === true;
-			const reuseSessionId = team ? void 0 : reusableSessionId(opened.task, this.idleSessionIds);
+			const reuseSessionId = team ? void 0 : await this.reuseSessionFor(opened.task);
 			const peers = others.length === 0 ? void 0 : others.map((other) => ({
 				id: other.task.id,
 				title: other.task.title,
@@ -5789,41 +7323,84 @@ var TaskBoardHostService = class {
 				...team ? { team: true } : {},
 				...schedule === void 0 ? {} : { schedule }
 			};
-			const settings = this.verificationSettings();
+			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,
 				attempts: [],
-				applicability: team ? "team-member" : !contract.enabled ? skippedBy : "goal-unavailable"
+				applicability: team ? "team-member" : !contract.enabled ? skippedBy : notArmed
 			};
 			this.ledger.setVerification(opened.task.id, opened.execution.id, initial);
-			let attached;
 			const sessionId = await this.runner.launch(opened.task, {
 				...reuseSessionId === void 0 ? {} : { reuseSessionId },
 				...promptContext === void 0 ? {} : { promptContext },
+				goalEnabled,
+				catalog,
 				onSession: (id) => {
 					attached = id;
 					this.ledger.attachSession(opened.task.id, opened.execution.id, id);
 				},
 				onGoalArmed: (armed) => {
-					this.setApplicability(opened.task.id, opened.execution.id, team ? "team-member" : !contract.enabled ? skippedBy : armed ? "enforced" : "goal-unavailable");
+					this.setApplicability(opened.task.id, opened.execution.id, team ? "team-member" : !contract.enabled ? skippedBy : armed ? "enforced" : notArmed);
 				}
 			});
 			if (attached === void 0) this.ledger.attachSession(opened.task.id, opened.execution.id, sessionId);
 			if (team) for (const teammate of others) this.scheduleTeammate(teammate, sessionId);
 		} catch (error) {
-			if (error instanceof SessionLaunchError) this.ledger.attachSession(opened.task.id, opened.execution.id, error.sessionId);
+			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.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
@@ -5854,31 +7431,70 @@ var TaskBoardHostService = class {
 			this.settleAndNotify(opened.task.id, opened.execution.id, "failed", error instanceof Error ? error.message : String(error));
 		}
 	}
+	/**
+	* One roster pass, and whether it could read the session tree.
+	*
+	* The board reads the DSH session roster only while it has something the
+	* roster can decide: an execution to inspect, or a card parked in the running
+	* column whose verdict may arrive from a settle this process never saw. That
+	* gate is what removes the cost the reporter measured — `session/list`
+	* rebuilds every persisted session row (string conversion, object allocation,
+	* a stat per record), and an idle board with no tasks was paying it every few
+	* seconds forever.
+	* @returns whether the roster was readable (an idle pass counts as readable).
+	*/
 	async pollSessions() {
-		if (this.disposed) return;
-		if (!this.active && this.ledger.runtimeView().openExecutions.length === 0) return;
+		if (this.disposed) return true;
+		const runtime = this.ledger.runtimeView();
+		if (!this.active) {
+			if (runtime.openExecutions.length === 0 && runtime.armedSchedules === 0) return true;
+		} else if (!runtime.needsSessionState) return true;
 		const running = await this.runner.listRunning();
 		const previous = this.power.snapshot();
 		if (!running.known) {
-			this.idleSessionIds = void 0;
 			this.power.updateReasons({
 				runningSessions: previous.runningSessions,
-				armedSchedules: this.ledger.armedScheduleCount(),
+				armedSchedules: runtime.armedSchedules,
 				sessionStateKnown: false
 			});
-			return;
+			return false;
 		}
-		this.idleSessionIds = new Set(running.items.filter((item) => !item.running).map((item) => item.sessionId));
 		const foldedBefore = this.statusMap();
 		this.ledger.finalizeReadyRuns();
 		this.emitStatusChanges(foldedBefore);
-		const runtime = this.ledger.runtimeView();
+		const current = this.ledger.runtimeView();
 		this.power.updateReasons({
 			runningSessions: running.count,
-			armedSchedules: runtime.armedSchedules,
+			armedSchedules: current.armedSchedules,
 			sessionStateKnown: true
 		});
-		await this.reconcileExecutions(running.items, runtime.openExecutions);
+		await this.reconcileExecutions(running.items, current.openExecutions);
+		return true;
+	}
+	/**
+	* The session a run may continue in, for a card that opted into reuse
+	* (issue #1419). Reuse requires positive evidence that the previous session
+	* is present and idle, and that evidence must be read for THIS launch: an
+	* idle board no longer polls, so a roster cached from an earlier pass could
+	* be hours old — either refusing a session that has been idle all along, or
+	* prompting into one that started running since. A card that did not opt in
+	* reads no roster at all, and a read that fails mints a fresh conversation
+	* exactly as an unknown roster always did.
+	* @param task - the task about to run.
+	* @returns the session id to continue in, or undefined for a fresh session.
+	*/
+	async reuseSessionFor(task) {
+		if (task.reuseSession !== true) return void 0;
+		let running;
+		try {
+			running = await this.runner.listRunning();
+		} catch (error) {
+			this.notePollFailure();
+			safeConsoleError("[dsh-task-board] session roster read for session reuse failed; starting a fresh session", error);
+			return;
+		}
+		if (!running.known) return void 0;
+		return reusableSessionId(task, new Set(running.items.filter((item) => !item.running).map((item) => item.sessionId)));
 	}
 	/** Reuse the session list this poll already fetched: one list RPC per tick, not 1 + E. */
 	async reconcileExecutions(sessions, executions) {
@@ -5898,7 +7514,7 @@ var TaskBoardHostService = class {
 				}
 				this.unreadablePolls.delete(execution.executionId);
 				if (result.outcome === "succeeded" && verificationRequired(verification) && passedAttempt(verification) === void 0) {
-					this.settleAndNotify(execution.taskId, execution.executionId, "failed", "goal 验收：本次执行没有匹配的验收通过记录（验收未运行、未通过或报告来自其他执行），按未验收判失败。");
+					this.settleAndNotify(execution.taskId, execution.executionId, "failed", verificationNeverInvoked(verification) ? NEVER_INVOKED_VERIFICATION_REASON : verificationOnlyInvalid(verification) ? INVALID_ONLY_VERIFICATION_REASON : NO_MATCHING_PASS_VERIFICATION_REASON);
 					continue;
 				}
 				this.settleAndNotify(execution.taskId, execution.executionId, result.outcome, "error" in result ? result.error : void 0);
@@ -5936,6 +7552,59 @@ var TaskBoardHostService = class {
 			outcome,
 			...error === void 0 ? {} : { error }
 		});
+		if (outcome === "succeeded") this.cleanupAcceptanceDetail(taskId, executionId);
+	}
+	/**
+	* Remove one execution's acceptance-only detail after it PASSED and settled.
+	*
+	* Deliberately narrow: only the acceptance mechanism's own per-attempt
+	* material (findings, invalid diagnostics, the bulky judge side) is removed,
+	* and only for THIS execution, keyed by its own id in the ledger it belongs
+	* to. No user file, task artifact, raw session history or other execution's
+	* record is read or written. Idempotent by the record's own state, and it
+	* clearly never touches a run that did not pass (the caller's guard) — a
+	* failed or invalid execution keeps everything a repair or a review needs.
+	* @param taskId - the task whose execution settled.
+	* @param executionId - the settled execution.
+	*/
+	cleanupAcceptanceDetail(taskId, executionId) {
+		const verification = (this.ledger.getTask(taskId)?.executions.find((entry) => entry.id === executionId))?.verification;
+		if (verification === void 0 || passedAttempt(verification) === void 0) return;
+		if (verification.cleanup?.state === "cleaned") return;
+		try {
+			const cleaned = withAcceptanceDetailCleared(verification, this.now());
+			if (cleaned === void 0) return;
+			this.ledger.setVerification(taskId, executionId, cleaned);
+		} catch (error) {
+			const attempts = (verification.cleanup?.attempts ?? 0) + 1;
+			this.ledger.setVerification(taskId, executionId, {
+				...verification,
+				cleanup: {
+					state: "failed",
+					attempts,
+					startedAt: verification.cleanup?.startedAt ?? this.now(),
+					lastError: error instanceof Error ? error.message : String(error),
+					audit: verification.cleanup?.audit ?? []
+				}
+			});
+			safeConsoleError("[dsh-task-board] acceptance-detail cleanup failed; it is retried on the next Host start", error);
+		}
+	}
+	/**
+	* Catch-up pass: clean the acceptance detail of every execution that PASSED
+	* and settled but whose cleanup did not finish (a crash, a failed write, a
+	* Host killed mid-cleanup).
+	*
+	* The same bounds as any other cleanup apply — only a real pass record on a
+	* settled execution is touched — so this can never delete material belonging
+	* to an execution that did not pass, and never a user file.
+	*/
+	cleanupPendingAcceptanceDetail() {
+		for (const task of this.ledger.allTasks()) for (const execution of task.executions) {
+			if (execution.endedAt === void 0) continue;
+			if (execution.result !== "succeeded") continue;
+			this.cleanupAcceptanceDetail(task.id, execution.id);
+		}
 	}
 	noteUnreadableInspection(execution, reason) {
 		const polls = (this.unreadablePolls.get(execution.executionId) ?? 0) + 1;
@@ -6003,14 +7672,12 @@ var TaskBoardHostService = class {
 			return;
 		}
 		const before = this.statusMap();
-		for (const schedule of this.ledger.dueSchedules(now)) {
-			const next = nextRunAtMs(schedule.cron, schedule.nextRunAt, schedule.timeZone);
-			this.dispatchRuns(this.ledger.openScheduled(schedule.taskId, next, now), {
-				triggeredAt: now,
-				timeZone: schedule.timeZone,
-				cron: schedule.cron
-			});
-		}
+		for (const schedule of this.ledger.dueSchedules(now)) this.dispatchRuns(this.ledger.openScheduled(schedule.taskId, now), {
+			triggeredAt: now,
+			timeZone: schedule.timeZone,
+			mode: schedule.mode,
+			...schedule.cron === void 0 ? {} : { cron: schedule.cron }
+		});
 		this.emitStatusChanges(before);
 		this.armSchedule();
 	}
@@ -6023,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
@@ -6043,21 +7718,92 @@ 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;
 		this.pollInFlight = true;
-		this.pollSessions().catch((error) => {
+		this.pollSessions().then((rosterReadable) => {
+			if (rosterReadable) this.consecutivePollFailures = 0;
+			else this.notePollFailure();
+		}).catch((error) => {
+			this.notePollFailure();
 			safeConsoleError("[dsh-task-board] session polling failed", error);
 		}).finally(() => {
 			this.pollInFlight = false;
 		});
 	}
 	/**
+	* Count one failed pass and arm the retry that follows it.
+	*
+	* A session tree that is down is retried on a doubling delay instead of
+	* hammering it on the fixed cadence: the heartbeat would otherwise repeat
+	* every failure — and every retry inside {@link HostExecutionRunner.listRunning}
+	* — at exactly the interval the reporter measured.
+	*/
+	notePollFailure() {
+		this.consecutivePollFailures += 1;
+		this.armPollBackoff();
+	}
+	/** Arm the retry that follows a failed pass, doubling up to the ceiling. */
+	armPollBackoff() {
+		if (this.disposed) return;
+		this.pollBackoffTimer?.();
+		const delay = Math.min(sessionPollMs(this.sessionPollSeconds) * 2 ** Math.min(this.consecutivePollFailures, 8), POLL_FAILURE_MAX_BACKOFF_MS);
+		this.pollBackoffTimer = this.timers.timeout(() => {
+			this.pollBackoffTimer = void 0;
+			this.schedulePoll();
+		}, delay);
+	}
+	/** Drop a pending retry; the next regular tick takes over. */
+	clearPollBackoff() {
+		this.pollBackoffTimer?.();
+		this.pollBackoffTimer = void 0;
+	}
+	/**
 	* Re-arm from the ledger's current targets. Callers that just changed a
 	* schedule (the host routes, the agent tools) invoke this after the write
 	* commits, so a new or edited trigger arms without waiting for the next fire.
@@ -6314,6 +8060,64 @@ async function parseTaskDraft(llm, request, signal) {
 		signal?.removeEventListener("abort", abortFromCaller);
 	}
 }
+/**
+* Total ceiling of one acceptance attempt, covering evidence rendering and
+* every judge call including retries. Derived from the per-call default rather
+* than pinned, because a total budget smaller than
+* {@link ACCEPTANCE_JUDGE_CALLS} times the per-call ceiling guarantees that no
+* acceptance can ever finish.
+*/
+const DEFAULT_VERIFICATION_BUDGET_SECONDS = 150 * (CODING_CRITERIA.length * 2 + 2);
+/** Longest accepted total budget, thirty minutes. */
+const VERIFICATION_BUDGET_MAX_SECONDS = 1800;
+/** The default total budget in milliseconds, the face the abort timer takes. */
+const DEFAULT_VERIFICATION_BUDGET_MS = DEFAULT_VERIFICATION_BUDGET_SECONDS * 1e3;
+/**
+* Clamp a configured ceiling into the supported range. A value the schema
+* would refuse (non-finite, below the floor, above the ceiling) still leaves
+* the board judging: an out-of-range setting never disables acceptance.
+* @param value - configured seconds, or undefined for the default.
+* @param fallback - the default to use when nothing usable was configured.
+* @param min - shortest accepted value.
+* @param max - longest accepted value.
+* @returns the effective value in seconds.
+*/
+function clampSeconds(value, fallback, min, max) {
+	if (value === void 0 || !Number.isFinite(value)) return fallback;
+	return Math.min(Math.max(Math.trunc(value), min), max);
+}
+/**
+* The effective per-judge-call ceiling.
+* @param seconds - configured seconds, or undefined for the default.
+* @returns the effective ceiling in seconds.
+*/
+function normalizeVerificationCallTimeoutSeconds(seconds) {
+	return clampSeconds(seconds, 150, 30, 600);
+}
+/**
+* The effective per-judge-call ceiling the timer face takes.
+* @param seconds - configured seconds, or undefined for the default.
+* @returns the effective ceiling in milliseconds.
+*/
+function verificationCallTimeoutMs(seconds) {
+	return normalizeVerificationCallTimeoutSeconds(seconds) * 1e3;
+}
+/**
+* The effective total budget of one acceptance attempt.
+* @param seconds - configured seconds, or undefined for the default.
+* @returns the effective budget in seconds.
+*/
+function normalizeVerificationBudgetSeconds(seconds) {
+	return clampSeconds(seconds, DEFAULT_VERIFICATION_BUDGET_SECONDS, 120, VERIFICATION_BUDGET_MAX_SECONDS);
+}
+/**
+* The effective total budget the abort face takes.
+* @param seconds - configured seconds, or undefined for the default.
+* @returns the effective budget in milliseconds.
+*/
+function verificationBudgetMs(seconds) {
+	return normalizeVerificationBudgetSeconds(seconds) * 1e3;
+}
 //#endregion
 //#region src/host/agent-tools.ts
 /** Registered tool names, in registration order. */
@@ -6364,10 +8168,18 @@ function callingSessionId(exec) {
 function scheduleView(schedule) {
 	return {
 		enabled: schedule.enabled,
-		cron: schedule.cron,
+		mode: schedule.mode,
+		...schedule.cron === void 0 ? {} : { cron: schedule.cron },
+		...schedule.at === void 0 ? {} : { at: schedule.at },
 		...schedule.timeZone === void 0 ? {} : { timeZone: schedule.timeZone },
 		...schedule.nextRunAt === void 0 ? {} : { nextRunAt: schedule.nextRunAt },
-		...schedule.lastTriggeredAt === void 0 ? {} : { lastTriggeredAt: schedule.lastTriggeredAt }
+		...schedule.lastTriggeredAt === void 0 ? {} : { lastTriggeredAt: schedule.lastTriggeredAt },
+		runCount: schedule.runCount,
+		...schedule.maxRuns === void 0 ? {} : { maxRuns: schedule.maxRuns },
+		...schedule.endedAt === void 0 ? {} : { endedAt: schedule.endedAt },
+		...schedule.endedReason === void 0 ? {} : { endedReason: schedule.endedReason },
+		...schedule.skippedAt === void 0 ? {} : { skippedAt: schedule.skippedAt },
+		...schedule.skippedReason === void 0 ? {} : { skippedReason: schedule.skippedReason }
 	};
 }
 function tagView(tag) {
@@ -6385,6 +8197,7 @@ function executionView(execution) {
 		...execution.result === void 0 ? {} : { result: execution.result },
 		...execution.error === void 0 ? {} : { error: execution.error },
 		...execution.initiatedBy === void 0 ? {} : { initiatedBy: execution.initiatedBy },
+		...execution.external === true ? { external: true } : {},
 		...execution.runGroupId === void 0 ? {} : { cascade: true },
 		...execution.ownResult === void 0 ? {} : {
 			ownResult: execution.ownResult,
@@ -6413,9 +8226,10 @@ 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 === false ? { goalRun: false } : {},
+		...task.goalRun === true ? { goalRun: true } : {},
 		...task.skipVerification === true ? { skipVerification: true } : {},
 		...task.schedule === void 0 ? {} : { schedule: scheduleView(task.schedule) },
 		...task.freeze === void 0 ? {} : { continuationCard: true },
@@ -6510,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: {
@@ -6562,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",
@@ -6610,7 +8424,9 @@ function buildManageTool(host) {
 			"Move, archive, restore, delete, or settle one task board card.",
 			"move-backlog, move-todo, move-running, move-done and move-failed are the manual column moves and cover every column; a card the runner is executing (one with an open execution) cannot be moved.",
 			"A manual move writes the card column only and never fabricates an execution record, so the card reports a declaration rather than evidence of a run: done/failed declare work finished (or failed) outside a Host-run execution — human work, an external system, a decision made elsewhere — and running says the work is under way without a tracked session. Use task_board_run when the work should actually run in a session here.",
+			"record-external-outcome is the record-backed version of move-done and move-failed: use it when YOU, or another agent outside this Host, actually finished or failed the card with your own model, so the terminal column and the run history both derive from one execution record. It takes result (succeeded or failed) and initiatedBy (who completed it, for example your own agent name) plus an optional summary, and it is refused while the card still has an open execution: the Host stays the only authority over a run it is executing. It cannot record running or cancelled — those remain Host-only.",
 			"settle force-closes the open execution of a card the board can no longer observe (a stuck running card) and records it cancelled with the caller as the reason, so the card returns to the todo column and can be run again.",
+			"reset-verification clears the acceptance anomalies (timeouts, authentication failures, an unresolvable judge route, or an attempt the time budget ended) recorded on a card open execution, so the next update_goal(action: complete) runs a fresh acceptance. It is refused unless that execution really carries such anomalies, it never clears a quality verdict, and a spent anomaly budget otherwise HOLDS the card open instead of failing it: tell the user the acceptance environment is unusable and that this action is how they clear it once they have fixed it.",
 			"archive takes the whole subtask tree off the board and is refused while any member has an unsettled execution; restore brings the task, its ancestors and its subtree back; delete removes one card and is refused while it still has subtasks (detach or delete them first) or while it runs.",
 			"It cannot confirm a permission binding: the confirmation gate is a human act performed in the board UI."
 		].join(" "),
@@ -6632,9 +8448,24 @@ function buildManageTool(host) {
 					"archive",
 					"restore",
 					"delete",
-					"settle"
+					"settle",
+					"reset-verification",
+					"record-external-outcome"
 				],
 				description: "The lifecycle operation to perform."
+			},
+			result: {
+				type: "string",
+				enum: ["succeeded", "failed"],
+				description: "record-external-outcome only: the verdict the outside agent actually reached."
+			},
+			initiatedBy: {
+				type: "string",
+				description: "record-external-outcome only: who finished the work outside this Host (for example your own agent name)."
+			},
+			summary: {
+				type: "string",
+				description: "record-external-outcome only: optional free-text note stored with the recorded outcome."
 			}
 		},
 		output: {
@@ -6643,6 +8474,31 @@ function buildManageTool(host) {
 		},
 		async execute(args, exec) {
 			const initiator = callingSessionId(exec);
+			if (args.action === "record-external-outcome") {
+				const result = args.result;
+				const by = typeof args.initiatedBy === "string" ? args.initiatedBy.trim() : "";
+				if (result !== "succeeded" && result !== "failed") return refused("missing-result", "record-external-outcome needs result=succeeded or result=failed");
+				if (by === "") return refused("missing-initiator", "record-external-outcome needs initiatedBy naming who completed the work outside this Host");
+				if (!host.snapshot().tasks.some((task) => task.id === args.taskId)) return refused("task-not-found", "no task with id " + args.taskId);
+				try {
+					const snapshot = await host.apply(crypto.randomUUID(), {
+						kind: "record-external-outcome",
+						taskId: args.taskId,
+						result,
+						initiatedBy: by,
+						...typeof args.summary === "string" && args.summary.trim() !== "" ? { summary: args.summary } : {}
+					}, initiator);
+					const task = snapshot.tasks.find((item) => item.id === args.taskId);
+					return json({
+						ok: true,
+						action: args.action,
+						...task === void 0 ? {} : { task: taskSummary(task, snapshot.tasks, snapshot.sessionDefaultPermission) },
+						note: "The outcome is recorded as its own execution, so the terminal column and the run history agree. Read it back with task_board_get."
+					});
+				} catch (error) {
+					return refused("refused", messageOf(error));
+				}
+			}
 			const action = {
 				"move-todo": {
 					kind: "move",
@@ -6677,6 +8533,10 @@ function buildManageTool(host) {
 					kind: "settle",
 					taskId: args.taskId
 				},
+				"reset-verification": {
+					kind: "reset-verification",
+					taskId: args.taskId
+				},
 				restore: {
 					kind: "restore",
 					taskId: args.taskId
@@ -6712,11 +8572,12 @@ function buildScheduleTool(host) {
 	return defineTool({
 		name: "task_board_schedule",
 		description: [
-			"Arm, change, or disarm a task scheduled runs (5-field cron; day-of-month and day-of-week follow Vixie semantics: both restricted means OR, otherwise AND).",
-			"The cron 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 schedule whose tree contains an unconfirmed above-default permission is refused and rolls to its next occurrence; the reason is reported in the list board summary as schedulerError.",
-			"Missed occurrences during Host downtime are skipped, never queued; a task that is already running skips its occurrence."
+			"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 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(" "),
 		parameters: {
 			taskId: {
@@ -6728,13 +8589,26 @@ function buildScheduleTool(host) {
 				type: "boolean",
 				description: "Arm (true) or disarm (false) the schedule."
 			},
+			mode: {
+				type: "string",
+				enum: ["cron", "once"],
+				description: "The kind of plan: \"cron\" for a recurring rule, \"once\" for a single future instant. Omit to keep the stored kind."
+			},
 			cron: {
 				type: "string",
-				description: "5-field cron expression: minute hour day-of-month month day-of-week."
+				description: "5-field cron expression of a recurring rule: minute hour day-of-month month day-of-week."
+			},
+			at: {
+				type: "integer",
+				description: "Planned instant of a one-shot, in milliseconds since the Unix epoch (UTC). Must be in the future."
 			},
 			timeZone: {
 				type: "string",
-				description: "IANA zone the cron wall clock is read in (for example Asia/Shanghai). Omit to keep the stored zone, or pass an empty string to clear it back to the Host zone."
+				description: "IANA zone the wall clock is read in (for example Asia/Shanghai). Omit to keep the stored zone, or pass an empty string to clear it back to the Host zone."
+			},
+			maxRuns: {
+				type: "integer",
+				description: "Maximum scheduled executions of a recurring rule (positive whole number). Omit to keep the stored cap; pass 0 to clear it back to unlimited."
 			}
 		},
 		output: {
@@ -6742,12 +8616,15 @@ function buildScheduleTool(host) {
 			render: renderJson
 		},
 		async execute(args, exec) {
-			if (args.enabled === void 0 && args.cron === void 0 && args.timeZone === void 0) return refused("nothing-to-change", "pass enabled and/or cron and/or timeZone");
+			if (args.enabled === void 0 && args.mode === void 0 && args.cron === void 0 && args.at === void 0 && args.timeZone === void 0 && args.maxRuns === void 0) return refused("nothing-to-change", "pass enabled, mode, cron, at, timeZone and/or maxRuns");
 			if (!host.snapshot().tasks.some((task) => task.id === args.taskId)) return refused("task-not-found", "no task with id " + args.taskId);
 			const patch = {
 				...args.enabled === void 0 ? {} : { enabled: args.enabled },
+				...args.mode === void 0 ? {} : { mode: args.mode },
 				...args.cron === void 0 ? {} : { cron: args.cron },
-				...args.timeZone === void 0 ? {} : { timeZone: args.timeZone === "" ? null : args.timeZone }
+				...args.at === void 0 ? {} : { at: args.at },
+				...args.timeZone === void 0 ? {} : { timeZone: args.timeZone === "" ? null : args.timeZone },
+				...args.maxRuns === void 0 ? {} : { maxRuns: args.maxRuns <= 0 ? null : args.maxRuns }
 			};
 			try {
 				const snapshot = await host.apply(crypto.randomUUID(), {
@@ -6879,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(" "),
@@ -6907,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",
@@ -6928,7 +8809,7 @@ function buildCreateTool(host) {
 			},
 			goalRun: {
 				type: "boolean",
-				description: "Start each run with dsh built-in /goal so the session keeps working continuation rounds until the goal completes. Default true (omit to keep it); pass false for a single plain turn."
+				description: "Start each run with dsh built-in /goal so the session keeps working continuation rounds until the goal completes. Off by default: omit (or pass false) for a single plain turn, and pass true to opt this card in. It only takes effect while the deployment global native /goal switch is on."
 			},
 			skipVerification: {
 				type: "boolean",
@@ -6956,17 +8837,29 @@ function buildCreateTool(host) {
 			schedule: {
 				type: "object",
 				additionalProperties: false,
-				description: "Arm a 5-field cron schedule at creation time (Host local time zone).",
+				description: "Arm a schedule at creation time. Use mode \"once\" with at for a single future run, or mode \"cron\" (or omit mode) with a 5-field cron expression, optionally capped by maxRuns.",
 				properties: {
 					enabled: {
 						type: "boolean",
 						required: true,
 						description: "Whether the schedule is armed."
 					},
+					mode: {
+						type: "string",
+						enum: ["cron", "once"],
+						description: "The kind of plan: \"cron\" for a recurring rule, \"once\" for a single future instant."
+					},
 					cron: {
 						type: "string",
-						required: true,
-						description: "5-field cron: minute hour day-of-month month day-of-week."
+						description: "5-field cron of a recurring rule: minute hour day-of-month month day-of-week."
+					},
+					at: {
+						type: "integer",
+						description: "Planned instant of a one-shot, in milliseconds since the Unix epoch (UTC). Must be in the future."
+					},
+					maxRuns: {
+						type: "integer",
+						description: "Maximum scheduled executions of a recurring rule (positive whole number); omit for unlimited."
 					}
 				}
 			}
@@ -6991,14 +8884,19 @@ 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 === false ? { goalRun: false } : {},
+				...args.goalRun === true ? { goalRun: true } : {},
 				...args.skipVerification === true ? { skipVerification: true } : {},
 				...tags.length === 0 ? {} : { tags },
 				...args.schedule === void 0 ? {} : { schedule: {
 					enabled: args.schedule.enabled,
-					cron: args.schedule.cron
+					...args.schedule.mode === void 0 ? {} : { mode: args.schedule.mode },
+					...args.schedule.cron === void 0 ? {} : { cron: args.schedule.cron },
+					...args.schedule.at === void 0 ? {} : { at: args.schedule.at },
+					...args.schedule.maxRuns === void 0 ? {} : { maxRuns: args.schedule.maxRuns }
 				} }
 			};
 			try {
@@ -7023,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."
@@ -7068,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."
@@ -7078,7 +8980,7 @@ function buildUpdateTool(host) {
 			},
 			goalRun: {
 				type: "boolean",
-				description: "Whether each run starts with dsh built-in /goal (default true). Pass false to run one plain turn instead."
+				description: "Whether each run starts with dsh built-in /goal (default false, one plain turn). Pass true to opt this card in, or false to return it to the default."
 			},
 			skipVerification: {
 				type: "boolean",
@@ -7116,10 +9018,11 @@ 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;
-			if (has(args, "goalRun")) patch.goalRun = args.goalRun === false ? false : true;
+			if (has(args, "goalRun")) patch.goalRun = args.goalRun === true ? true : false;
 			if (has(args, "skipVerification")) patch.skipVerification = args.skipVerification === true ? true : false;
 			if (has(args, "tags")) {
 				const tags = args.tags ?? [];
@@ -7702,8 +9605,11 @@ function mountOnce(packageName, fn) {
 const VERIFICATION_MAX_TRACE_CHARS = 8e4;
 /** Largest single trace entry; one huge tool result must not eat the budget. */
 const VERIFICATION_MAX_ENTRY_CHARS = 4e3;
-/** One judge request's ceiling and its retry budget. */
-const VERIFICATION_CALL_TIMEOUT_MS = 12e4;
+/** Largest verbatim citation kept from one finding. */
+const VERIFICATION_MAX_QUOTE_CHARS = 600;
+/** Largest requirement/observation/gap statement kept from one finding. */
+const VERIFICATION_MAX_PROBLEM_CHARS = 400;
+const VERIFICATION_MAX_FINDINGS = 12;
 const VERIFICATION_MAX_TOKENS = 16384;
 const VERIFICATION_TEMPERATURE = .2;
 /** Redaction patterns, mirrored from the verifier's defaults. */
@@ -7858,8 +9764,29 @@ function collectEvidence(session, problem, startedAt) {
 		hash
 	};
 }
-/** Parse the optional `<finding ...>` lines out of one judge answer. */
-function parseFindings(text, criterion) {
+/** How one cited slot maps onto the caller's own evidence under a swapped round. */
+function locationOfSlot(slot, round) {
+	return slot === workSlotOfRound(round) ? "trajectory" : "baseline";
+}
+/** Resolve one `location` (or legacy `evidence`) attribute into an evidence location. */
+function readLocation(raw, round) {
+	const value = raw.trim().toUpperCase();
+	if (value === "TASK") return "task";
+	if (value === "CONTEXT" || value === "WORKSPACE") return "workspace";
+	if (value === "TRAJECTORY_A" || value === "A") return locationOfSlot("A", round);
+	if (value === "TRAJECTORY_B" || value === "B") return locationOfSlot("B", round);
+}
+/**
+* Parse the `<finding ...>` elements out of one judge answer.
+*
+* A finding must name the criterion this prompt offered and cite an evidence
+* location the prompt actually rendered; a finding for another criterion, a
+* citation of a location that was never offered, and an empty body are dropped
+* here rather than echoed back as if the judge had located something. The
+* quote is carried verbatim: whether it really occurs in the evidence it names
+* is decided by the caller, which is the only side holding the evidence text.
+*/
+function parseFindings(text, criterion, round) {
 	const pattern = /<finding\s+([^>]*)>([\s\S]*?)<\/finding>/giu;
 	const attributes = /([A-Za-z_][A-Za-z0-9_]*)\s*=\s*"([^"]*)"/gu;
 	const found = [];
@@ -7869,25 +9796,35 @@ function parseFindings(text, criterion) {
 		for (let attribute = attributes.exec(match[1] ?? ""); attribute !== null; attribute = attributes.exec(match[1] ?? "")) if ([
 			"criterion",
 			"evidence",
+			"location",
+			"requirement",
+			"observation",
+			"gap",
+			"quote",
 			"action"
 		].includes(attribute[1] ?? "")) attrs.set(attribute[1] ?? "", attribute[2] ?? "");
 		const named = attrs.get("criterion") ?? "";
 		if (named !== "" && named.toLowerCase() !== criterion.name.toLowerCase() && named.toLowerCase() !== criterion.id.toLowerCase()) continue;
-		const evidence = (attrs.get("evidence") ?? "").trim().toUpperCase();
-		if (![
-			"TASK",
-			"A",
-			"B"
-		].includes(evidence)) continue;
+		const location = readLocation(attrs.get("location") ?? attrs.get("evidence") ?? "", round);
+		if (location === void 0) continue;
+		const quote = (attrs.get("quote") ?? "").trim().slice(0, VERIFICATION_MAX_QUOTE_CHARS);
+		const requirement = (attrs.get("requirement") ?? "").trim().slice(0, VERIFICATION_MAX_PROBLEM_CHARS);
+		const observation = (attrs.get("observation") ?? "").trim().slice(0, VERIFICATION_MAX_PROBLEM_CHARS);
+		const gap = (attrs.get("gap") ?? "").trim().slice(0, VERIFICATION_MAX_PROBLEM_CHARS);
 		const body = (match[2] ?? "").trim().slice(0, 400);
-		if (body === "") continue;
+		if (body === "" && quote === "") continue;
 		const action = (attrs.get("action") ?? "").trim().slice(0, 300);
-		const key = named + "|" + evidence + "|" + body;
+		const key = criterion.id + "|" + location + "|" + quote + "|" + body;
 		if (seen.has(key)) continue;
 		seen.add(key);
 		found.push({
-			criterion: criterion.name,
-			evidence,
+			criterionId: criterion.id,
+			criterionName: criterion.name,
+			location,
+			quote,
+			requirement,
+			observation,
+			gap,
 			body,
 			...action === "" ? {} : { action }
 		});
@@ -7896,20 +9833,31 @@ function parseFindings(text, criterion) {
 }
 /** Render one finding as the single feedback line the agent reads. */
 function renderFinding(finding) {
-	const locator = "[" + (finding.criterion ?? "finding") + " evidence=" + finding.evidence + "]";
+	const locator = "[" + finding.criterionName + " " + finding.location + "]";
 	const action = finding.action === void 0 ? "" : " → 建议核实：" + finding.action;
-	return locator + " " + finding.body + action;
+	const detail = finding.body !== "" ? finding.body : finding.quote;
+	return locator + " " + detail + action;
 }
-/** One judge request's outcome. */
-async function judgeOnce(llm, route, prompt, signal) {
+/**
+* One judge request's outcome.
+*
+* Every attempt is admitted against the acceptance budget first: a call whose
+* own ceiling no longer fits in the time left is refused before it is opened,
+* so a slow route cannot spend the whole acceptance budget on calls the outer
+* abort is going to kill anyway.
+*/
+async function judgeOnce(llm, route, prompt, signal, budget) {
 	const usage = emptyUsage();
 	let lastError;
+	/** The outer abort is the acceptance budget running out, not a cancellation. */
+	const stopped = () => budget.now() >= budget.deadline ? new VerificationError("budget", "the acceptance budget ran out before the judge answered", usage) : new VerificationError("aborted", "the acceptance was cancelled", usage);
 	for (let attempt = 0; attempt < 3; attempt++) {
-		if (signal.aborted) throw new VerificationError("aborted", "the acceptance was cancelled before the judge answer", usage);
+		if (signal.aborted) throw stopped();
+		if (budget.deadline - budget.now() <= budget.callTimeoutMs) throw new VerificationError("budget", "the acceptance budget cannot fit another judge call", usage);
 		const timeout = new AbortController();
 		const timer = setTimeout(() => {
 			timeout.abort(/* @__PURE__ */ new Error("task-board verification: the judge request timed out"));
-		}, VERIFICATION_CALL_TIMEOUT_MS);
+		}, budget.callTimeoutMs);
 		const forward = () => {
 			timeout.abort(signal.reason);
 		};
@@ -7944,7 +9892,7 @@ async function judgeOnce(llm, route, prompt, signal) {
 					usage.reasoningTokens += typeof reported.reasoningTokens === "number" ? reported.reasoningTokens : 0;
 				} else if (row.type === "finish") finishReason = chunk.type === "finish" ? chunk.reason : void 0;
 			}
-			if (signal.aborted) throw new VerificationError("aborted", "the acceptance was cancelled", usage);
+			if (signal.aborted) throw stopped();
 			if (timeout.signal.aborted) throw new VerificationError("timeout", "the judge request timed out", usage);
 			if (finishReason?.kind === "error" || finishReason?.kind === "aborted") {
 				const failure = finishReason.failure;
@@ -7970,8 +9918,8 @@ async function judgeOnce(llm, route, prompt, signal) {
 		} catch (error) {
 			lastError = error;
 			if (error instanceof VerificationError && (error.kind === "aborted" || error.kind === "auth")) throw error;
-			if (signal.aborted) throw new VerificationError("aborted", "the acceptance was cancelled", usage);
-			if (timeout.signal.aborted) lastError = new VerificationError("timeout", "the judge request timed out after " + Math.round(VERIFICATION_CALL_TIMEOUT_MS / 1e3) + "s", usage);
+			if (signal.aborted) throw stopped();
+			if (timeout.signal.aborted) lastError = new VerificationError("timeout", "the judge request timed out after " + Math.round(budget.callTimeoutMs / 1e3) + "s", usage);
 			const parseFailure = lastError instanceof VerificationError && lastError.kind === "parse";
 			if (attempt + 1 >= 3 || !parseFailure && !retryable(lastError)) break;
 			if (!parseFailure) usage.usageIncomplete = true;
@@ -7992,11 +9940,17 @@ async function judgeOnce(llm, route, prompt, signal) {
 * Run one acceptance: every criterion is judged twice, the odd round with the
 * A/B slots swapped, and the per-round scores are mapped back and averaged per
 * criterion.
-* @param input - the judge route, evidence, threshold and cancellation.
-* @returns the recorded attempt (quality verdict or anomaly).
+* @param input - the judge route, evidence, threshold, time budget and cancellation.
+* @returns the recorded attempt (quality verdict, anomaly, or budget stop).
 */
 async function runAcceptance(input) {
-	const startedAt = (input.now ?? Date.now)();
+	const now = input.now ?? Date.now;
+	const startedAt = now();
+	const budget = {
+		deadline: input.deadline ?? startedAt + DEFAULT_VERIFICATION_BUDGET_MS,
+		callTimeoutMs: input.callTimeoutMs ?? 15e4,
+		now
+	};
 	const usage = emptyUsage();
 	const evidenceSummary = {
 		chars: input.evidence.trace.length,
@@ -8009,6 +9963,13 @@ async function runAcceptance(input) {
 	};
 	const findings = [];
 	const seenFindings = /* @__PURE__ */ new Set();
+	const structured = [];
+	const seenStructured = /* @__PURE__ */ new Set();
+	const evidenceText = {
+		task: input.evidence.problem,
+		trajectory: input.evidence.trace,
+		workspace: input.context ?? ""
+	};
 	try {
 		const perCriterion = /* @__PURE__ */ new Map();
 		for (const criterion of CODING_CRITERIA) perCriterion.set(criterion.id, {
@@ -8020,8 +9981,8 @@ async function runAcceptance(input) {
 			const swapped = repeat % 2 === 1;
 			const candidateA = swapped ? EMPTY_WORK_BASELINE : input.evidence.trace;
 			const candidateB = swapped ? input.evidence.trace : EMPTY_WORK_BASELINE;
-			const prompt = buildAcceptancePrompt(input.evidence.problem, candidateA, candidateB, criterion, void 0, input.context);
-			const answer = await judgeOnce(input.llm, input.route, prompt, input.signal);
+			const prompt = buildAcceptancePrompt(input.evidence.problem, candidateA, candidateB, criterion, void 0, input.context, workSlotOfRound(repeat));
+			const answer = await judgeOnce(input.llm, input.route, prompt, input.signal, budget);
 			const scoreA = extractScore(answer.text, "score_A");
 			const scoreB = extractScore(answer.text, "score_B");
 			if (answer.usage.usageIncomplete === true) usage.usageIncomplete = true;
@@ -8032,14 +9993,26 @@ async function runAcceptance(input) {
 			const bucket = perCriterion.get(criterion.id);
 			bucket.work.push(swapped ? scoreB : scoreA);
 			bucket.baseline.push(swapped ? scoreA : scoreB);
-			for (const finding of parseFindings(answer.text, criterion)) {
-				const line = renderFinding(swapped && (finding.evidence === "A" || finding.evidence === "B") ? {
-					...finding,
-					evidence: finding.evidence === "A" ? "B" : "A"
-				} : finding);
+			for (const finding of parseFindings(answer.text, criterion, repeat)) {
+				if (structured.length < VERIFICATION_MAX_FINDINGS) {
+					const key = finding.criterionId + "|" + finding.location + "|" + finding.quote + "|" + finding.body;
+					if (!seenStructured.has(key)) {
+						seenStructured.add(key);
+						structured.push({
+							criterionId: finding.criterionId,
+							requirement: finding.requirement !== "" ? finding.requirement : finding.criterionName,
+							observation: finding.observation !== "" ? finding.observation : finding.body,
+							gap: finding.gap !== "" ? finding.gap : finding.body,
+							quote: finding.quote,
+							location: finding.location,
+							...finding.action === void 0 ? {} : { action: finding.action }
+						});
+					}
+				}
+				const line = renderFinding(finding);
 				if (seenFindings.has(line)) continue;
 				seenFindings.add(line);
-				if (findings.length < 6) findings.push(line);
+				if (findings.length < VERIFICATION_MAX_FINDINGS) findings.push(line);
 			}
 		}
 		const criteria = CODING_CRITERIA.map((criterion) => {
@@ -8058,11 +10031,17 @@ async function runAcceptance(input) {
 		const score = average(criteria.map((criterion) => criterion.score));
 		const baseline = average(criteria.map((criterion) => criterion.baseline));
 		const passed = acceptancePassed(score, baseline, criteria, input.threshold);
+		const validity = passed ? { valid: true } : assessAcceptanceValidity({
+			criteria,
+			findings: structured,
+			evidence: evidenceText,
+			omittedCharacters: input.evidence.omittedCharacters
+		});
 		return { attempt: {
 			index: input.index,
 			at: startedAt,
-			stage: "quality",
-			passed,
+			stage: validity.valid ? "quality" : "invalid",
+			passed: validity.valid ? passed : false,
 			score,
 			baseline,
 			criteria,
@@ -8071,7 +10050,12 @@ async function runAcceptance(input) {
 			evidence: evidenceSummary,
 			route: input.route,
 			channel: "explicit-tag",
-			rounds: 2
+			rounds: 2,
+			...structured.length === 0 ? {} : { criterionFindings: structured },
+			...validity.valid ? {} : {
+				invalidReason: validity.reason,
+				error: classifyInvalid(validity)
+			}
 		} };
 	} catch (error) {
 		const failure = error instanceof Error ? error : new Error(String(error));
@@ -8080,7 +10064,7 @@ async function runAcceptance(input) {
 		return { attempt: {
 			index: input.index,
 			at: startedAt,
-			stage: "exception",
+			stage: kind === "budget" ? "budget" : "exception",
 			passed: false,
 			score: 0,
 			baseline: 0,
@@ -8110,6 +10094,16 @@ function mergeUsage(target, source) {
 		...target.usageIncomplete === true || source.usageIncomplete === true ? { usageIncomplete: true } : {}
 	};
 }
+/** Prefix one invalid-acceptance message with its class so the report stays actionable. */
+function classifyInvalid(validity) {
+	return {
+		"missing-finding": "验收无效（未达标判据没有对应的结构化问题反馈）",
+		"unlocatable-quote": "验收无效（问题反馈引用不存在于本次裁判所见的证据中）",
+		"baseline-finding": "验收无效（问题反馈指向空工作基线而非本次工作）",
+		"vacuous-finding": "验收无效（问题反馈空泛，未说明实际观测与差异）",
+		"insufficient-evidence": "验收无效（裁判所见证据不足，无法支撑否决）"
+	}[validity.reason] + ": " + validity.detail;
+}
 /** Prefix one anomaly message with its class so the report stays actionable. */
 function classifyMessage(kind, message) {
 	return {
@@ -8118,7 +10112,8 @@ function classifyMessage(kind, message) {
 		auth: "验收异常（鉴权失败）",
 		parse: "验收异常（裁判回答无法解析）",
 		request: "验收异常（裁判请求失败）",
-		aborted: "验收异常（验收被取消）"
+		aborted: "验收异常（验收被取消）",
+		budget: "验收未完成（时间预算耗尽，未产生任何判定，不计入异常额度）"
 	}[kind] + ": " + message;
 }
 /** Character ceiling for one file's rendered comparison. */
@@ -8329,6 +10324,45 @@ function createGoalVerificationGate(deps) {
 		blockGoal(agent, reason);
 		return deny(bounded("[任务看板 · goal 验收判定失败] " + reason + "\n本次执行不会完成；请如实向用户报告验收未通过、已记录的分数与问题，不要再尝试标记完成。"), "TASK_BOARD_VERIFICATION_FAILED", reason);
 	};
+	/**
+	* Hold the cycle open after its non-quality budget ran out.
+	*
+	* A judge route that times out, cannot authenticate or cannot be resolved is
+	* the ENVIRONMENT failing, not the work, so this records the attempt and
+	* refuses the completion claim without writing a `failedReason` and without
+	* blocking the goal (issue #1828). The execution therefore survives for a
+	* user who fixes the environment and clears the recorded anomalies, instead
+	* of carrying a verdict that only the clock produced.
+	*/
+	const hold = (taskId, executionId, verification, message, detail, code) => {
+		write(taskId, executionId, {
+			...verification,
+			inFlight: void 0
+		});
+		return deny(bounded(message), code, detail);
+	};
+	/** The refusal one recorded anomaly returns to the fixing agent. */
+	const anomalyRefusal = (spend, error) => deny(bounded("[任务看板 · 验收异常] " + (error ?? "unknown") + "\n这是验收异常而非质量判定，本次未消耗质量验收额度（已用 " + exceptionAttempts(spend).length + "/2）。请修复环境后再次调用 update_goal(action: complete)。"), "TASK_BOARD_VERIFICATION_ANOMALY", error);
+	/**
+	* The refusal one recorded INVALID acceptance returns.
+	*
+	* The claim is still refused (no pass record exists), but the agent is told
+	* the veto itself was unusable and is explicitly NOT asked to repair anything
+	* on that basis. The reason and scores stay recorded for review; the quality
+	* budget is untouched.
+	*/
+	const invalidRefusal = (spend, attempt) => deny(bounded(invalidAcceptanceFeedback(attempt, 2 - invalidAttempts(spend).length)), "TASK_BOARD_VERIFICATION_INVALID", attempt.error);
+	/**
+	* Hold a cycle whose invalid-acceptance budget is spent.
+	*
+	* No usable veto was ever produced, so the board neither passes nor fails the
+	* card: it stops calling the judge and leaves the execution for a human. Only
+	* an explicit user action (or a rerun) resumes it, which is what bounds the
+	* retries.
+	*/
+	const invalidHeld = (taskId, executionId, spend) => hold(taskId, executionId, spend, "[任务看板 · 验收无效] " + invalidHoldReason(invalidAttempts(spend).length), "acceptance produced no usable veto; a user action must clear the recorded invalid acceptances", "TASK_BOARD_VERIFICATION_INVALID");
+	/** The refusal a spent anomaly budget returns: no verdict, and no card failure. */
+	const anomalyHeld = (taskId, executionId, spend) => hold(taskId, executionId, spend, "[任务看板 · 验收异常] 验收异常额度已用尽（2/2）：本执行周期不再调用裁判模型，也不把这次执行判为失败。\n这是环境异常而非质量判定：请如实告诉用户验收环境当前不可用，由用户修复环境后用 task_board_manage(action=reset-verification) 清除已记录的异常，再重新完成目标。", "acceptance anomaly budget exhausted; a user action must clear the recorded anomalies", "TASK_BOARD_VERIFICATION_ANOMALY");
 	/** Record one attempt and decide whether the completion claim may proceed. */
 	const settle = async (input) => {
 		const { task, execution, verification, agent, objective } = input;
@@ -8373,9 +10407,9 @@ function createGoalVerificationGate(deps) {
 				attempts,
 				inFlight: void 0
 			};
-			if (exceptionAttempts(spend).length >= 2) return finalize(task.id, execution.id, spend, "验收异常达到上限：" + attempt.error, agent);
+			if (exceptionAttempts(spend).length >= 2) return anomalyHeld(task.id, execution.id, spend);
 			write(task.id, execution.id, spend);
-			return deny(bounded("[任务看板 · 验收异常] " + attempt.error + "\n这是验收异常而非质量判定，本次未消耗质量验收额度（已用 " + exceptionAttempts(spend).length + "/2）。请修复环境后再次调用 update_goal(action: complete)。"), "TASK_BOARD_VERIFICATION_ANOMALY", attempt.error);
+			return anomalyRefusal(spend, attempt.error);
 		}
 		write(task.id, execution.id, baselines);
 		const llm = deps.llm?.();
@@ -8411,13 +10445,16 @@ function createGoalVerificationGate(deps) {
 				attempts: [...verification.attempts, attempt],
 				inFlight: void 0
 			};
-			if (exceptionAttempts(spend).length >= 2) return finalize(task.id, execution.id, spend, "验收异常达到上限：" + attempt.error, agent);
+			if (exceptionAttempts(spend).length >= 2) return anomalyHeld(task.id, execution.id, spend);
 			write(task.id, execution.id, spend);
 			return deny(bounded("[任务看板 · 验收异常] " + attempt.error), "TASK_BOARD_VERIFICATION_ANOMALY", attempt.error);
 		}
 		const session = agent.session;
 		const evidence = collectEvidence(session, objective, execution.startedAt);
-		const acceptance = AbortSignal.timeout(6e5);
+		const callTimeout = deps.callTimeoutMs?.() ?? verificationCallTimeoutMs(void 0);
+		const budget = deps.budgetMs?.() ?? DEFAULT_VERIFICATION_BUDGET_MS;
+		const deadline = now() + budget;
+		const acceptance = AbortSignal.timeout(budget);
 		const source = deps.workspaceChanges?.();
 		const workspace = source === void 0 ? {
 			text: "",
@@ -8437,6 +10474,8 @@ function createGoalVerificationGate(deps) {
 			context: workspace.text === "" ? void 0 : workspace.text,
 			workspaceFiles: workspace.files,
 			signal: acceptance,
+			deadline,
+			callTimeoutMs: callTimeout,
 			now
 		})).attempt;
 		const attempts = [...verification.attempts, attempt];
@@ -8445,10 +10484,16 @@ function createGoalVerificationGate(deps) {
 			attempts,
 			inFlight: void 0
 		};
+		if (attempt.stage === "budget") return hold(task.id, execution.id, spend, "[任务看板 · 验收未完成] " + (attempt.error ?? "时间预算耗尽") + "\n本次没有产生任何质量判定，也不消耗质量或异常额度。请稍后重试；若裁判路由确实很慢，可调大验收的单次调用上限或总时间预算。", attempt.error ?? "the acceptance time budget ran out before a verdict", "TASK_BOARD_VERIFICATION_BUDGET");
 		if (attempt.stage === "exception") {
-			if (exceptionAttempts(spend).length >= 2) return finalize(task.id, execution.id, spend, "验收异常达到上限：" + (attempt.error ?? "unknown"), agent);
+			if (exceptionAttempts(spend).length >= 2) return anomalyHeld(task.id, execution.id, spend);
+			write(task.id, execution.id, spend);
+			return anomalyRefusal(spend, attempt.error);
+		}
+		if (attempt.stage === "invalid") {
+			if (invalidAttempts(spend).length >= 2) return invalidHeld(task.id, execution.id, spend);
 			write(task.id, execution.id, spend);
-			return deny(bounded("[任务看板 · 验收异常] " + (attempt.error ?? "unknown") + "\n这是验收异常而非质量判定，本次未消耗质量验收额度（已用 " + exceptionAttempts(spend).length + "/2）。请修复环境后再次调用 update_goal(action: complete)。"), "TASK_BOARD_VERIFICATION_ANOMALY", attempt.error);
+			return invalidRefusal(spend, attempt);
 		}
 		if (attempt.passed) {
 			write(task.id, execution.id, spend);
@@ -8457,7 +10502,7 @@ function createGoalVerificationGate(deps) {
 		const used = qualityAttempts(spend).length;
 		if (used >= 2) return finalize(task.id, execution.id, spend, finalFailureReason(attempt, used, verification.contract.threshold), agent);
 		write(task.id, execution.id, spend);
-		return deny(bounded(qualityFeedback(attempt, 2 - used)), "TASK_BOARD_VERIFICATION_FAILED", attempt.findings.join("\n"));
+		return deny(bounded(qualityFeedback(attempt, 2 - used)), "TASK_BOARD_VERIFICATION_FAILED", locatedFindingDetail(attempt));
 	};
 	/** Evaluate one tool call; undefined means "not this gate's business". */
 	const evaluate = async (exec) => {
@@ -8472,7 +10517,9 @@ function createGoalVerificationGate(deps) {
 		if (verification.applicability !== "enforced") return void 0;
 		if (passedAttempt(verification) !== void 0) return { kind: "allow" };
 		if (verification.failedReason !== void 0) return deny(bounded("[任务看板 · goal 验收判定失败] " + verification.failedReason + "\n本次执行已被判失败，不会再运行新的验收。请如实报告结果。"), "TASK_BOARD_VERIFICATION_FAILED", verification.failedReason);
-		if (!hasQualityBudget(verification) && !hasExceptionBudget(verification)) return finalize(binding.task.id, binding.execution.id, verification, "goal 验收额度已耗尽，本次 execution 判失败。", exec.agent);
+		if (!hasInvalidBudget(verification)) return invalidHeld(binding.task.id, binding.execution.id, verification);
+		if (!hasQualityBudget(verification)) return finalize(binding.task.id, binding.execution.id, verification, "goal 验收额度已耗尽，本次 execution 判失败。", exec.agent);
+		if (!hasExceptionBudget(verification)) return anomalyHeld(binding.task.id, binding.execution.id, verification);
 		const key = binding.execution.id;
 		const running = inFlight.get(key);
 		if (running !== void 0) return await running;
@@ -8514,6 +10561,17 @@ function createGoalVerificationGate(deps) {
 		}
 	};
 }
+/**
+* The structured detail of one quality refusal: the judge's own findings, in
+* the order the acceptance recorded them, so the denial carries exactly the
+* located evidence the report shows.
+*/
+function locatedFindingDetail(attempt) {
+	const lines = [];
+	for (const finding of attempt.criterionFindings ?? []) lines.push("[" + finding.criterionId + " " + finding.location + "] \"" + finding.quote + "\"");
+	if (lines.length === 0) lines.push(...attempt.findings);
+	return lines.join("\n");
+}
 /** The bare execution prompt, used when the goal service carries no objective. */
 function taskPrompt(task) {
 	return task.prompt.trim() !== "" ? task.prompt : task.title;
@@ -8547,14 +10605,29 @@ const Config = z.object({
 	proxyTokenEnv: z.string().min(1).default(DEFAULT_PROXY_TOKEN_ENV),
 	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()
+	goalVerificationReasoningEffort: z.string().default("").volatile(),
+	goalVerificationCallTimeoutSeconds: z.number().min(30).max(600).default(150).volatile(),
+	goalVerificationBudgetSeconds: z.number().min(120).max(VERIFICATION_BUDGET_MAX_SECONDS).default(DEFAULT_VERIFICATION_BUDGET_SECONDS).volatile()
 });
 /** Schema default for the goal-acceptance switch, re-read for hand-built contexts. */
 const DEFAULT_GOAL_VERIFICATION = true;
 /**
+* Schema default for the GLOBAL native-/goal switch, re-read for hand-built
+* contexts. Deliberately false: a deployment that never configured it (and
+* every card written before the option existed) runs plain single turns.
+*/
+const DEFAULT_GOAL_RUN = false;
+/**
 * Read one config field's current value.
 *
 * The Loader hands schema-volatile fields as stable references it commits in
@@ -8722,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.
 *
@@ -8744,6 +10861,14 @@ function applyImpl(ctx, config) {
 	const preventIdleSleep = () => readConfigField(config?.preventIdleSleep, false);
 	/** Current subtask depth limit (read live: the settings card edits it in place). */
 	const maxSubtaskDepth = () => readConfigField(config?.maxSubtaskDepth, 1);
+	/** 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
@@ -8758,27 +10883,59 @@ function applyImpl(ctx, config) {
 		model: readConfigField(config?.goalVerificationModel, ""),
 		reasoningEffort: readConfigField(config?.goalVerificationReasoningEffort, "")
 	});
+	/**
+	* The acceptance time ceilings, read live: raising one must unblock a card
+	* whose acceptance is stuck on a slow judge route without a remount, so
+	* these deliberately are NOT frozen into the per-execution contract.
+	*/
+	const verificationCallTimeoutMsLive = () => verificationCallTimeoutMs(readConfigField(config?.goalVerificationCallTimeoutSeconds, 150));
+	const verificationBudgetMsLive = () => verificationBudgetMs(readConfigField(config?.goalVerificationBudgetSeconds, DEFAULT_VERIFICATION_BUDGET_SECONDS));
 	let hostForCatalog;
 	const verificationCatalog = async () => {
 		const runner = hostForCatalog?.runner;
 		return runner === void 0 ? void 0 : normalizeCatalog(await runner.modelCatalog());
 	};
+	/**
+	* Live reader of the GLOBAL native-/goal switch. The service calls it exactly
+	* once per execution and carries the value, so a settings edit only reaches
+	* 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;
 		} }
 	});
 	hostForCatalog = host;
-	host.setConfiguration(enabled(), preventIdleSleep());
+	host.setConfiguration(enabled(), preventIdleSleep(), sessionPollSeconds());
 	host.start();
 	if (typeof ctx.provide === "function") ctx.provide(TASK_BOARD_SERVICE_NAME, {
 		registerExtension: (extension) => host.registerExtension(extension),
@@ -8824,6 +10981,8 @@ function applyImpl(ctx, config) {
 					}
 				},
 				workspaceChanges: () => probeWorkspaceChanges(ctx),
+				callTimeoutMs: verificationCallTimeoutMsLive,
+				budgetMs: verificationBudgetMsLive,
 				logger: { warn: (message, ...rest) => {
 					const logger = ctx.logger;
 					if (typeof logger?.warn === "function") logger.warn(message, ...rest);
@@ -8870,12 +11029,13 @@ function applyImpl(ctx, config) {
 			enabled: enabled(),
 			announceToAgent: announceToAgent(),
 			preventIdleSleep: preventIdleSleep(),
-			maxSubtaskDepth: maxSubtaskDepth()
+			maxSubtaskDepth: maxSubtaskDepth(),
+			sessionPollSeconds: sessionPollSeconds()
 		};
-		if (applied !== void 0 && applied.enabled === next.enabled && applied.announceToAgent === next.announceToAgent && applied.preventIdleSleep === next.preventIdleSleep && applied.maxSubtaskDepth === next.maxSubtaskDepth) return;
+		if (applied !== void 0 && applied.enabled === next.enabled && applied.announceToAgent === next.announceToAgent && applied.preventIdleSleep === next.preventIdleSleep && applied.maxSubtaskDepth === next.maxSubtaskDepth && applied.sessionPollSeconds === next.sessionPollSeconds) return;
 		applied = next;
 		host.ledger.setMaxSubtaskDepth(next.maxSubtaskDepth);
-		host.setConfiguration(next.enabled, next.preventIdleSleep);
+		host.setConfiguration(next.enabled, next.preventIdleSleep, next.sessionPollSeconds);
 		setToolsEnabled(next.enabled);
 		if (disposeSection !== void 0) {
 			disposeSection();
@@ -8894,4 +11054,4 @@ function applyImpl(ctx, config) {
 	sync();
 }
 //#endregion
-export { Config, 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 };