@iowarp/clio-coder 0.3.7 → 0.3.9

package/src/interactive/overlay-session-lifecycle.ts

@@ -403,19 +403,83 @@ export function createOverlaySessionLifecycle(deps: OverlaySessionLifecycleDeps)
 		void runHandoffExtraction(session, fromSessionId, verdict.goal);
 	}
 
+	/** Characters of the second round's answer quoted in the terminal refusal. */
+	const HANDOFF_REFUSAL_QUOTE_CHARS = 200;
+
+	/**
+	 * A refusal that says what was asked for and what came back, not only that no
+	 * JSON object arrived. Both rounds are named, so an operator reading it knows
+	 * two model calls were spent and on what.
+	 */
+	function terminalHandoffRefusal(firstReason: string, secondReason: string, secondText: string): string {
+		const answered = secondText.replace(/\s+/g, " ").trim().slice(0, HANDOFF_REFUSAL_QUOTE_CHARS);
+		return [
+			"the extraction round could not produce a handoff record after one repair attempt.",
+			`Asked for: one JSON object with decisions, facts, files, commands, and openQuestions.`,
+			`Round 1: ${firstReason}.`,
+			`Round 2: ${secondReason}.`,
+			`Round 2 returned: ${answered.length > 0 ? answered : "(nothing)"}`,
+		].join(" ");
+	}
+
+	/**
+	 * Extract, then repair once.
+	 *
+	 * A local model that answers with prose around the object, or with nothing
+	 * parseable, used to end `/handoff` outright: every downstream behavior (the
+	 * dropped-path listing, the `e` editor, accept-mints-a-session) was
+	 * unreachable and the operator had paid for the round either way (issue
+	 * #223). Exactly one repair round follows, quoting what came back and what
+	 * the parser objected to, and both rounds bill through the same out-of-turn
+	 * usage store.
+	 */
+	async function extractWithOneRepair(
+		goal: string,
+	): Promise<
+		| { ok: true; parsed: Extract<ReturnType<typeof parseHandoffExtraction>, { ok: true }> }
+		| { ok: false; level: "error" | "warn"; reason: string }
+	> {
+		const first = await deps.chat.extractHandoff(goal);
+		if (first.status !== "answered") {
+			return {
+				ok: false,
+				level: first.status === "failed" ? "error" : "warn",
+				reason: first.status === "aborted" ? "the extraction round was cancelled" : first.reason,
+			};
+		}
+		const parsedFirst = parseHandoffExtraction(first.text);
+		if (parsedFirst.ok) return { ok: true, parsed: parsedFirst };
+
+		const second = await deps.chat.extractHandoff(goal, {
+			repair: { complaint: parsedFirst.reason, previous: first.text },
+		});
+		if (second.status !== "answered") {
+			return {
+				ok: false,
+				level: second.status === "failed" ? "error" : "warn",
+				reason:
+					second.status === "aborted"
+						? "the repair round was cancelled"
+						: `round 1 could not be read (${parsedFirst.reason}); the repair round then failed: ${second.reason}`,
+			};
+		}
+		const parsedSecond = parseHandoffExtraction(second.text);
+		if (parsedSecond.ok) return { ok: true, parsed: parsedSecond };
+		return {
+			ok: false,
+			level: "error",
+			reason: terminalHandoffRefusal(parsedFirst.reason, parsedSecond.reason, second.text),
+		};
+	}
+
 	async function runHandoffExtraction(session: SessionContract, fromSessionId: string, goal: string): Promise<void> {
 		const notice = deps.getSlashNotice();
-		const outcome = await deps.chat.extractHandoff(goal);
-		if (outcome.status !== "answered") {
-			const reason = outcome.status === "aborted" ? "the extraction round was cancelled" : outcome.reason;
-			emitCommandNotice(notice, outcome.status === "failed" ? "error" : "warn", "handoff", reason);
-			return;
-		}
-		const parsed = parseHandoffExtraction(outcome.text);
-		if (!parsed.ok) {
-			emitCommandNotice(notice, "error", "handoff", parsed.reason);
+		const extraction = await extractWithOneRepair(goal);
+		if (!extraction.ok) {
+			emitCommandNotice(notice, extraction.level, "handoff", extraction.reason);
 			return;
 		}
+		const parsed = extraction.parsed;
 		const meta = session.current();
 		const cwd = typeof meta?.cwd === "string" && meta.cwd.length > 0 ? meta.cwd : null;
 		const entries = deps.readStructuredEntries(fromSessionId);

package/src/interactive/overlays/ask-user.ts

@@ -129,6 +129,14 @@ interface QuestionState {
 	customAnswer: string;
 	inputValue: string;
 	answer: string;
+	/**
+	 * The operator's typed text exactly as submitted, empty when they typed
+	 * nothing. `answer` is the one-line rendering of the whole decision and gets
+	 * trimmed and joined; this is the record of what they actually typed, and
+	 * losing it is what made an interview re-ask for the same figures three times
+	 * (issue #228).
+	 */
+	rawValue: string;
 	focusedValue?: string;
 }
 
@@ -154,6 +162,7 @@ function createQuestionState(question: AskUserQuestion): QuestionState {
 		customAnswer: "",
 		inputValue: "",
 		answer: "",
+		rawValue: "",
 	};
 }
 
@@ -205,12 +214,18 @@ function optionIndexFromValue(value: string): number | null {
 	return Number.isInteger(index) && index >= 0 ? index : null;
 }
 
-function answerText(question: AskUserQuestion, selected: ReadonlySet<number>, customAnswer: string): string {
-	const parts: string[] = [];
+/** The labels the operator chose, in list order. */
+function selectedOptionLabels(question: AskUserQuestion, selected: ReadonlySet<number>): string[] {
+	const labels: string[] = [];
 	for (const index of [...selected].sort((a, b) => a - b)) {
 		const label = question.options?.[index]?.label;
-		if (label) parts.push(label);
+		if (label) labels.push(label);
 	}
+	return labels;
+}
+
+function answerText(question: AskUserQuestion, selected: ReadonlySet<number>, customAnswer: string): string {
+	const parts = selectedOptionLabels(question, selected);
 	const custom = customAnswer.trim();
 	if (custom.length > 0) parts.push(custom);
 	return parts.join("; ");
@@ -348,6 +363,10 @@ class AskUserOverlayView implements Component {
 			this.commitMultiSelectOrOpenOther(state);
 			return;
 		}
+		if (this.isAddTextKey(data)) {
+			this.chooseFocusedAndOpenText(question, state);
+			return;
+		}
 		this.list?.handleInput(data);
 	}
 
@@ -502,24 +521,22 @@ class AskUserOverlayView implements Component {
 		// The classified action label distinguishes recording an answer from
 		// granting authority. Esc keeps the product's one word for the way out,
 		// since it closes the prompt and the interview together.
+		// `t` is on every select footer because the operator cannot tell from a
+		// label whether the option needs a figure attached until they read it.
+		const addText: HintEntry = { key: "t", verb: "add text", short: "text" };
 		if (question.multi_select === true) {
 			return this.questions.length > 1
 				? this.withScrollHint([
 						{ key: "Left/Right", verb: "question" },
 						{ key: "Space", verb: "toggle" },
+						addText,
 						{ key: "Enter", verb: recordAnswer },
 					])
-				: this.withScrollHint([
-						{ key: "Space", verb: "toggle" },
-						{ key: "Enter", verb: recordAnswer },
-					]);
+				: this.withScrollHint([{ key: "Space", verb: "toggle" }, addText, { key: "Enter", verb: recordAnswer }]);
 		}
 		return this.questions.length > 1
-			? this.withScrollHint([
-					{ key: "Left/Right", verb: "question" },
-					{ key: "Enter", verb: recordAnswer },
-				])
-			: this.withScrollHint([{ key: "Enter", verb: recordAnswer }]);
+			? this.withScrollHint([{ key: "Left/Right", verb: "question" }, addText, { key: "Enter", verb: recordAnswer }])
+			: this.withScrollHint([addText, { key: "Enter", verb: recordAnswer }]);
 	}
 
 	private renderDecisionContext(width: number): string[] {
@@ -644,6 +661,34 @@ class AskUserOverlayView implements Component {
 		return this.questions.length > 1 && (matchesKey(data, "alt+right") || matchesKey(data, "ctrl+right"));
 	}
 
+	/**
+	 * The key that adds typed text to the option under the cursor.
+	 *
+	 * Choosing an option used to be the whole answer, so a model that offered
+	 * "Exact number - I'll type it" gave the operator a label and nowhere to put
+	 * the number; the interview then spent two of its four rounds asking for the
+	 * figures again (issue #228). The list itself only reads the arrows, Enter,
+	 * and Esc, so a letter is free here.
+	 */
+	private isAddTextKey(data: string): boolean {
+		return matchesKey(data, "t");
+	}
+
+	/**
+	 * Take the focused option and open the text field for it, without committing.
+	 * Submitting the text records the label and the text together.
+	 */
+	private chooseFocusedAndOpenText(question: AskUserQuestion, state: QuestionState): void {
+		const current = this.list?.getSelectedItem();
+		const optionIndex = current && current.value !== "other" ? optionIndexFromValue(current.value) : null;
+		if (optionIndex !== null) {
+			if (question.multi_select === true) state.selected.add(optionIndex);
+			else state.selected = new Set<number>([optionIndex]);
+			state.focusedValue = `option:${optionIndex}`;
+		}
+		this.openTextInput(state.selected.size > 0 ? "Add your answer to the chosen option" : "Other answer");
+	}
+
 	/**
 	 * The row above the question, or nothing.
 	 *
@@ -829,14 +874,20 @@ class AskUserOverlayView implements Component {
 				return;
 			}
 			state.inputValue = answer;
+			// Verbatim, before any joining or trimming the display line does. The
+			// typed text is the answer; the one-line `answer` is a rendering of it.
+			state.rawValue = value;
 			if (questionHasOptions(question) && question.multi_select === true) {
 				state.customAnswer = answer;
 				this.commitCurrentAnswer();
-			} else {
-				state.customAnswer = questionHasOptions(question) ? answer : "";
-				state.answer = answer;
-				this.finishIfCompleteOrAdvance();
+				return;
 			}
+			state.customAnswer = questionHasOptions(question) ? answer : "";
+			// The chosen labels and the typed text compose, so a question answered
+			// with an option that says "I will type it" keeps both. With nothing
+			// selected, which is the implicit Other path, this is the text alone.
+			state.answer = questionHasOptions(question) ? answerText(question, state.selected, state.customAnswer) : answer;
+			this.finishIfCompleteOrAdvance();
 		};
 		activeInput.onEscape = () => this.cancel();
 		this.input = activeInput;
@@ -866,7 +917,14 @@ class AskUserOverlayView implements Component {
 				return;
 			}
 			state.selected = new Set<number>([optionIndex]);
-			state.answer = question.options?.[optionIndex]?.label ?? item.label;
+			// Choosing a plain option is a label-only answer, so the typed text
+			// clears with the choice: it was given for a label the operator has
+			// just moved off, and the composed answer runs through the same
+			// `answerText` every other path uses.
+			state.customAnswer = "";
+			state.rawValue = "";
+			state.inputValue = "";
+			state.answer = answerText(question, state.selected, state.customAnswer) || item.label;
 			state.focusedValue = item.value;
 			this.status = "";
 			this.finishIfCompleteOrAdvance();
@@ -992,12 +1050,26 @@ class AskUserOverlayView implements Component {
 		return this.states.length > 0 && this.states.every((state) => state.answer.trim().length > 0);
 	}
 
+	/**
+	 * What the round captured, as three separable facts per question: the one-line
+	 * answer, the labels chosen, and the text typed. A reader tells a label-only
+	 * answer from a label-plus-value one by whether `value` is there, which the
+	 * joined string alone could never say.
+	 */
 	private answers(): AskUserResult["answers"] {
 		const answers: AskUserResult["answers"] = [];
 		for (let index = 0; index < this.questions.length; index += 1) {
 			const question = this.questions[index];
-			const answer = this.states[index]?.answer.trim();
-			if (question && answer && answer.length > 0) answers.push({ question: question.question, answer });
+			const state = this.states[index];
+			const answer = state?.answer.trim();
+			if (!question || !state || !answer || answer.length === 0) continue;
+			const options = selectedOptionLabels(question, state.selected);
+			answers.push({
+				question: question.question,
+				answer,
+				...(options.length > 0 ? { options } : {}),
+				...(state.rawValue.length > 0 ? { value: state.rawValue } : {}),
+			});
 		}
 		return answers;
 	}

package/src/interactive/overlays/help-reference.ts

@@ -129,6 +129,10 @@ export function openHelpOverlay(
 					"auto-edit parks unrecognized commands, and full-auto runs them.",
 				"**Approvals**: a parked call waits for a one-shot operator decision; approving resumes only that call. " +
 					"Workers resolve asks per `workers.onPermission` (Approvals Routing); headless runs auto-deny.",
+				"**Inspecting a mutation**: a parked `write` or `edit` card carries the target, the byte count, and a `sha256` digest of the exact call arguments. " +
+					"Press `v` to read the complete proposed content, or the complete effective diff against the file on disk, and `v` again to put it away; ↑/↓ and PageUp/PageDown scroll it. " +
+					"Enter still allows, `s` still stops, and Esc still denies while it is open. The mutation text is shown locally and never enters the transcript, a notice, a desktop notification, or the render trace. " +
+					"A worker escalation has no preview because the call's arguments never leave the worker, and its card says so.",
 			],
 		},
 	];

package/src/interactive/overlays/prompts.ts

@@ -22,13 +22,23 @@ export function openPromptsOverlay(tui: TUI, ctx: SlashCommandContext, onClose:
 					lines.push(`**Argument Hint:** \`${template.argumentHint}\``);
 				}
 				lines.push(`**Source:** ${template.sourceInfo.source ?? template.sourceInfo.scope}`);
+				if (template.unavailable !== undefined) {
+					lines.push(`**Unavailable:** ${template.unavailable}`);
+				}
 				if (!template.trusted) {
 					lines.push("**Untrusted:** set `skills.trustProjectCompatRoots` before this template will expand.");
 				}
 				return lines;
 			},
 		};
-		const marker = template.trusted ? undefined : clioTheme().fg("warning", "untrusted");
+		// A template that loaded in a refusing state is listed, because the
+		// operator's command does exist; the marker is what says it will not run.
+		const marker =
+			template.unavailable !== undefined
+				? clioTheme().fg("error", "unavailable")
+				: template.trusted
+					? undefined
+					: clioTheme().fg("warning", "untrusted");
 		if (marker) item.meta = template.argumentHint ? `${template.argumentHint} · ${marker}` : marker;
 		else if (template.argumentHint) item.meta = template.argumentHint;
 		return item;

package/src/interactive/overlays/settings.ts

@@ -9,6 +9,7 @@ import {
 import { DEFAULT_SETTINGS, THINKING_LEVELS } from "../../core/defaults.js";
 import { getAtPath, isRoutingPath } from "../../core/session-routing.js";
 import { MAX_TIMER_DELAY_MS } from "../../core/timers.js";
+import { capacityLeaseUsage } from "../../domains/dispatch/capacity-lease.js";
 import {
 	delegationEntryForKind,
 	type InteropAgentId,
@@ -17,6 +18,8 @@ import {
 } from "../../domains/interop/index.js";
 import {
 	type CapabilityFlags,
+	endpointCapacitiesForStatuses,
+	endpointCapacityForStatus,
 	isDispatchEligibleRuntime,
 	isOrchestratorEligibleRuntime,
 	type ProvidersContract,
@@ -225,7 +228,8 @@ type EntrySettingId =
 	| `workers.profiles.${string}`
 	| `workers.agentBindings.${string}`
 	| `targets.${string}`
-	| `fleet.nodes.${string}`;
+	| `fleet.nodes.${string}`
+	| `fleet.endpoints.${string}`;
 export type EditableSettingId = keyof typeof SETTINGS_LABELS_BY_ID | EntrySettingId;
 type FleetGroupHeaderId = `fleet.group.${"defaults" | "profiles" | "agent-routes" | "placement"}`;
 type TargetsCtaId = "targets.add-cta";
@@ -593,6 +597,13 @@ function delegationAgentsAffordance(
 type SubmenuTitle = string | ((width: number) => string);
 
 export class SubmenuWrapper implements Component {
+	/**
+	 * Why the last submission was refused, or null while nothing is wrong. The
+	 * editor sets it instead of closing, so the operator corrects the value with
+	 * the reason on screen rather than back at the row list with no reason.
+	 */
+	private problem: string | null = null;
+
 	constructor(
 		private readonly title: SubmenuTitle,
 		private readonly child: Component,
@@ -600,6 +611,10 @@ export class SubmenuWrapper implements Component {
 		private readonly note?: string,
 	) {}
 
+	setProblem(problem: string | null): void {
+		this.problem = problem;
+	}
+
 	render(width: number): string[] {
 		const theme = clioTheme();
 		const lines: string[] = [];
@@ -619,6 +634,11 @@ export class SubmenuWrapper implements Component {
 		// two columns off each one and marked the cut, so every entry wore a
 		// trailing … it had not earned.
 		lines.push(...this.child.render(Math.max(1, width - 2)).map((line) => `  ${line}`));
+		if (this.problem !== null) {
+			for (const line of wrapTextWithAnsi(this.problem, Math.max(1, width - 2))) {
+				lines.push(theme.fg("error", `  ${line}`));
+			}
+		}
 		lines.push("");
 		lines.push(theme.fg("dim", `  ${this.hint}`));
 		return lines;
@@ -693,33 +713,108 @@ function editTextSubmenu(title: string, note?: string): SettingSubmenuBuilder {
 	return textInputSubmenu(title, note);
 }
 
-function editNumberSubmenu(title: string, options: { min?: number; allowBlank?: boolean } = {}): SettingSubmenuBuilder {
-	const min = options.min ?? 0;
+/**
+ * The bound a number row enforces, shared by the editor and the apply path so
+ * the two cannot drift: whatever the editor forwards, the apply path stores.
+ * The bounds mirror the config validator's, so a value the Settings Center
+ * refuses is one settings.yaml would have refused too, in the same words.
+ */
+interface NumberSettingRule {
+	readonly min: number;
+	readonly max?: number;
+	readonly integer: boolean;
+	/** A blank submission clears the key instead of being a parse failure. */
+	readonly allowBlank?: boolean;
+}
+
+const NUMBER_SETTING_RULES = {
+	"budget.sessionCeilingUsd": { min: 0, integer: false },
+	"watchdog.cadenceToolCalls": { min: 1, integer: true, allowBlank: true },
+	"delegation.defaults.connectTimeoutMs": { min: 1, max: MAX_TIMER_DELAY_MS, integer: true },
+	"delegation.defaults.turnTimeoutMs": { min: 1, max: MAX_TIMER_DELAY_MS, integer: true },
+	"delegation.defaults.permissionTimeoutMs": { min: 1, max: MAX_TIMER_DELAY_MS, integer: true },
+} as const satisfies Partial<Record<EditableSettingId, NumberSettingRule>>;
+
+export type NumberSettingId = keyof typeof NUMBER_SETTING_RULES;
+
+export const NUMBER_SETTING_IDS = Object.keys(NUMBER_SETTING_RULES) as readonly NumberSettingId[];
+
+type NumberSettingOutcome = { readonly value: number | null } | { readonly refusal: string };
+
+function describeSubmittedText(value: string): string {
+	const trimmed = value.trim();
+	return trimmed.length === 0 ? "an empty string" : JSON.stringify(trimmed);
+}
+
+/**
+ * Parse one submitted number-row value under its rule. A null value means the
+ * operator cleared an optional key. The refusal is worded like the config
+ * validator's issue for the same key ("expected an integer >= 1, got 0"), with
+ * a "Not applied:" prefix so it reads as the outcome of this submission.
+ */
+function parseNumberSetting(value: string, rule: NumberSettingRule): NumberSettingOutcome {
+	const trimmed = value.trim();
+	const noun = rule.integer ? "an integer" : "a number";
+	if (trimmed.length === 0 && rule.allowBlank === true) return { value: null };
+	const parsed = trimmed.length === 0 ? Number.NaN : Number(trimmed);
+	if (!Number.isFinite(parsed) || (rule.integer && !Number.isInteger(parsed))) {
+		const shown = Number.isFinite(parsed) ? String(parsed) : describeSubmittedText(value);
+		return { refusal: `Not applied: expected ${noun}, got ${shown}.` };
+	}
+	if (parsed < rule.min) return { refusal: `Not applied: expected ${noun} >= ${rule.min}, got ${parsed}.` };
+	if (rule.max !== undefined && parsed > rule.max) {
+		return { refusal: `Not applied: expected ${noun} <= ${rule.max}, got ${parsed}.` };
+	}
+	return { value: parsed };
+}
+
+/**
+ * The reason a number row would refuse `value`, or null when it would apply.
+ * This is the same check the editor and `applySettingChange` run, exposed so a
+ * caller that bypasses the editor can still name the bound it hit.
+ */
+export function describeNumberSettingRefusal(id: NumberSettingId, value: string): string | null {
+	const outcome = parseNumberSetting(value, NUMBER_SETTING_RULES[id]);
+	return "refusal" in outcome ? outcome.refusal : null;
+}
+
+function numberSettingNote(rule: NumberSettingRule): string {
+	const noun = rule.integer ? "a whole number" : "a number";
+	const clears = rule.allowBlank === true ? "; blank clears it" : "";
+	if (rule.min > 0 && rule.max !== undefined) return `Use ${noun} from ${rule.min} to ${rule.max}${clears}.`;
+	if (rule.min > 0) return `Use ${noun} of at least ${rule.min}${clears}.`;
+	return `Use a non-negative ${rule.integer ? "whole number" : "number"}${clears}.`;
+}
+
+/**
+ * A number editor that stays open on a refused submission. Closing with no
+ * value looked like a successful edit that changed nothing, so the reason is
+ * rendered under the input and the operator corrects the text in place; Esc
+ * still leaves without applying.
+ */
+function editNumberSubmenu(title: string, id: NumberSettingId): SettingSubmenuBuilder {
+	const rule = NUMBER_SETTING_RULES[id];
 	return (currentValue: string, done: (val?: string) => void) => {
 		const input = new Input();
 		input.setValue(currentValue);
 		input.focused = true;
+		const wrapper = new SubmenuWrapper(
+			title,
+			input,
+			buildHint([{ key: "Enter", verb: "confirm" }], "back"),
+			numberSettingNote(rule),
+		);
 		input.onSubmit = (val) => {
-			if (options.allowBlank === true && val.trim().length === 0) {
-				done("");
+			const outcome = parseNumberSetting(val, rule);
+			if ("refusal" in outcome) {
+				wrapper.setProblem(outcome.refusal);
 				return;
 			}
-			const num = Number(val);
-			if (Number.isFinite(num) && num >= min) {
-				done(val);
-			} else {
-				done();
-			}
+			wrapper.setProblem(null);
+			done(outcome.value === null ? "" : val.trim());
 		};
 		input.onEscape = () => done();
-		return new SubmenuWrapper(
-			title,
-			input,
-			buildHint([{ key: "Enter", verb: "confirm" }], "back"),
-			min > 0
-				? `Use a whole number of at least ${min}${options.allowBlank === true ? "; blank clears it" : ""}.`
-				: "Use a non-negative number.",
-		);
+		return wrapper;
 	};
 }
 
@@ -1391,6 +1486,7 @@ export function buildSettingItems(
 		}),
 		fleetGroupHeader("fleet.group.placement", "Placement"),
 		...fleetNodeRows(options?.getFleetNodes?.() ?? []),
+		...fleetEndpointRows(options?.providers),
 		settingItem("targets", "", {
 			description: "Live inference target inventory and routing roles.",
 			affordance: "column heading",
@@ -1412,7 +1508,7 @@ export function buildSettingItems(
 			readOnly: true,
 		}),
 		settingItem("budget.sessionCeilingUsd", String(settings.budget.sessionCeilingUsd), {
-			submenu: editNumberSubmenu("Edit session cost ceiling USD"),
+			submenu: editNumberSubmenu("Edit session cost ceiling USD", "budget.sessionCeilingUsd"),
 			affordance: "free text",
 		}),
 		settingItem("defaults.maxTokens", String(settings.defaults.maxTokens), {
@@ -1479,10 +1575,10 @@ export function buildSettingItems(
 			"watchdog.cadenceToolCalls",
 			watchdog.cadenceToolCalls === undefined ? "(turn end only)" : String(watchdog.cadenceToolCalls),
 			{
-				submenu: editNumberSubmenu("Edit watchdog cadence in tool calls; blank fires at turn end only", {
-					min: 1,
-					allowBlank: true,
-				}),
+				submenu: editNumberSubmenu(
+					"Edit watchdog cadence in tool calls; blank fires at turn end only",
+					"watchdog.cadenceToolCalls",
+				),
 				affordance: "free text",
 				editValue: watchdog.cadenceToolCalls === undefined ? "" : String(watchdog.cadenceToolCalls),
 			},
@@ -1503,15 +1599,15 @@ export function buildSettingItems(
 			affordance: "free text",
 		}),
 		settingItem("delegation.defaults.connectTimeoutMs", String(settings.delegation.defaults.connectTimeoutMs), {
-			submenu: editNumberSubmenu("Edit delegate connect timeout (ms)"),
+			submenu: editNumberSubmenu("Edit delegate connect timeout (ms)", "delegation.defaults.connectTimeoutMs"),
 			affordance: "free text",
 		}),
 		settingItem("delegation.defaults.turnTimeoutMs", String(settings.delegation.defaults.turnTimeoutMs), {
-			submenu: editNumberSubmenu("Edit delegate turn timeout (ms)"),
+			submenu: editNumberSubmenu("Edit delegate turn timeout (ms)", "delegation.defaults.turnTimeoutMs"),
 			affordance: "free text",
 		}),
 		settingItem("delegation.defaults.permissionTimeoutMs", String(settings.delegation.defaults.permissionTimeoutMs), {
-			submenu: editNumberSubmenu("Edit delegate permission timeout (ms)"),
+			submenu: editNumberSubmenu("Edit delegate permission timeout (ms)", "delegation.defaults.permissionTimeoutMs"),
 			affordance: "free text",
 		}),
 		settingItem("keybindings", keybindingCount > 0 ? `${keybindingCount} override(s)` : "(defaults)", {
@@ -1769,6 +1865,35 @@ function fleetNodeRows(nodes: ReadonlyArray<FleetNodeSnapshot>): SettingsCenterI
 	});
 }
 
+/** Read-only endpoint rows show the independent inference scheduler dimension. */
+function fleetEndpointRows(providers: ProvidersContract | undefined): SettingsCenterItem[] {
+	if (providers === undefined) return [];
+	let usage: Readonly<Record<string, number>> = {};
+	try {
+		usage = capacityLeaseUsage().endpoints;
+	} catch {
+		// A damaged capacity file belongs to admission. Settings still shows the configured limits.
+	}
+	const capacities = endpointCapacitiesForStatuses(providers.list());
+	const targetsByEndpoint = new Map<string, string[]>();
+	for (const status of providers.list()) {
+		const endpoint = endpointCapacityForStatus(status);
+		if (endpoint === null) continue;
+		targetsByEndpoint.set(endpoint.key, [...(targetsByEndpoint.get(endpoint.key) ?? []), status.target.id]);
+	}
+	return Object.entries(capacities).map(([key, endpoint]) => {
+		const slots = `slots ${usage[key] ?? 0}/${endpoint.limit}`;
+		return settingItem(`fleet.endpoints.${key}`, slots, {
+			label: `endpoint ${endpoint.label}`,
+			description: `Targets: ${(targetsByEndpoint.get(key) ?? []).join(", ")} · Limit source: ${endpoint.source}`,
+			affordance: "read-only inference endpoint capacity",
+			readOnly: true,
+			presentationKind: "status",
+			valueSegments: [{ text: slots, tone: "neutral" }],
+		});
+	});
+}
+
 export function buildSettingsSections(items: readonly SettingsCenterItem[]): SettingsCenterSection[] {
 	return SETTINGS_SECTIONS.map((section) => ({
 		id: section.id,
@@ -1819,9 +1944,15 @@ function applyNonNegativeInteger(value: string, set: (next: number) => void): vo
 	if (Number.isFinite(parsed) && parsed >= 0) set(Math.floor(parsed));
 }
 
-function applyPositiveInteger(value: string, set: (next: number) => void): void {
-	const parsed = Number(value);
-	if (Number.isInteger(parsed) && parsed >= 1 && parsed <= MAX_TIMER_DELAY_MS) set(parsed);
+/**
+ * Store a number-row submission under the row's shared rule. A refused value
+ * leaves the setting alone; the editor has already shown the operator why, and
+ * `describeNumberSettingRefusal` names the reason for any other caller.
+ */
+function applyNumberSetting(id: NumberSettingId, value: string, set: (next: number | null) => void): void {
+	const outcome = parseNumberSetting(value, NUMBER_SETTING_RULES[id]);
+	if ("refusal" in outcome) return;
+	set(outcome.value);
 }
 
 /**
@@ -1986,15 +2117,12 @@ export function applySettingChange(settings: ClioSettings, id: string, value: st
 			else delete settings.watchdog.target;
 			return;
 		}
-		case "watchdog.cadenceToolCalls": {
-			if (value.trim().length === 0) {
-				delete settings.watchdog.cadenceToolCalls;
-				return;
-			}
-			const parsed = Number(value);
-			if (Number.isFinite(parsed) && Math.floor(parsed) >= 1) settings.watchdog.cadenceToolCalls = Math.floor(parsed);
+		case "watchdog.cadenceToolCalls":
+			applyNumberSetting("watchdog.cadenceToolCalls", value, (next) => {
+				if (next === null) delete settings.watchdog.cadenceToolCalls;
+				else settings.watchdog.cadenceToolCalls = next;
+			});
 			return;
-		}
 		case "terminal.smoothStreaming":
 			if (value === "off" || value === "auto" || value === "on") settings.terminal.smoothStreaming = value;
 			return;
@@ -2005,18 +2133,18 @@ export function applySettingChange(settings: ClioSettings, id: string, value: st
 				.filter(Boolean);
 			return;
 		case "delegation.defaults.connectTimeoutMs":
-			applyPositiveInteger(value, (next) => {
-				settings.delegation.defaults.connectTimeoutMs = next;
+			applyNumberSetting("delegation.defaults.connectTimeoutMs", value, (next) => {
+				if (next !== null) settings.delegation.defaults.connectTimeoutMs = next;
 			});
 			return;
 		case "delegation.defaults.turnTimeoutMs":
-			applyPositiveInteger(value, (next) => {
-				settings.delegation.defaults.turnTimeoutMs = next;
+			applyNumberSetting("delegation.defaults.turnTimeoutMs", value, (next) => {
+				if (next !== null) settings.delegation.defaults.turnTimeoutMs = next;
 			});
 			return;
 		case "delegation.defaults.permissionTimeoutMs":
-			applyPositiveInteger(value, (next) => {
-				settings.delegation.defaults.permissionTimeoutMs = next;
+			applyNumberSetting("delegation.defaults.permissionTimeoutMs", value, (next) => {
+				if (next !== null) settings.delegation.defaults.permissionTimeoutMs = next;
 			});
 			return;
 		case "orchestrator.target": {
@@ -2067,11 +2195,11 @@ export function applySettingChange(settings: ClioSettings, id: string, value: st
 					.map((v) => v.trim())
 					.filter(Boolean);
 			return;
-		case "budget.sessionCeilingUsd": {
-			const parsed = Number(value);
-			if (Number.isFinite(parsed) && parsed >= 0) settings.budget.sessionCeilingUsd = parsed;
+		case "budget.sessionCeilingUsd":
+			applyNumberSetting("budget.sessionCeilingUsd", value, (next) => {
+				if (next !== null) settings.budget.sessionCeilingUsd = next;
+			});
 			return;
-		}
 	}
 }