@iowarp/clio-coder 0.4.9 → 0.5.0

package/src/interactive/overlays/settings.ts

@@ -1,11 +1,29 @@
+import {
+	applyControlValue,
+	controlInstructions,
+	formatControlValue,
+	SETTING_CONTROLS,
+	SETTINGS_DESCRIPTIONS_BY_ID,
+	SETTINGS_HELP_BY_ID,
+	SETTINGS_LABELS_BY_ID,
+	SETTINGS_VALUE_HELP_BY_ID,
+	type SettingControl,
+	settingControl,
+	settingsV2PathForRow,
+} from "../../core/settings-controls.js";
+import { settingsChangeKind } from "../../domains/config/classify.js";
+
+export { SETTINGS_LABELS_BY_ID } from "../../core/settings-controls.js";
+
 import {
 	bindAgentProfileInSettings,
 	type ClioSettings,
 	removeFleetProfileFromSettings,
 	removeTargetFromSettings,
-	SETTINGS_V1_PATH_MOVES,
+	SettingsValidationError,
 	setFleetProfileInSettings,
 	useTargetInSettings,
+	validateSettings,
 } from "../../core/config.js";
 import {
 	ACTIVE_ROUTING_POSTURES,
@@ -17,8 +35,17 @@ import {
 	type WorkerEscalationSettings,
 } from "../../core/defaults.js";
 import { getAtPath, isRoutingPath } from "../../core/session-routing.js";
+import {
+	resolveSettingsSection,
+	SETTINGS_SECTIONS,
+	type SettingsSectionId,
+	type SettingsSectionName,
+	settingsGroupForPath,
+	settingsSectionForPath,
+} from "../../core/settings-navigation.js";
 import { MAX_TIMER_DELAY_MS } from "../../core/timers.js";
 import { capacityLeaseUsage } from "../../domains/dispatch/capacity-lease.js";
+import type { RouteBreakerView } from "../../domains/dispatch/contract.js";
 import {
 	delegationEntryForKind,
 	type InteropAgentId,
@@ -39,6 +66,7 @@ import {
 	thinkingLevelFromChoiceLabel,
 } from "../../domains/providers/index.js";
 import type { FleetNodeSnapshot } from "../../domains/scheduling/cluster.js";
+import { describeLocalCapacity } from "../../domains/scheduling/local-capacity.js";
 import {
 	type Component,
 	getKeybindings,
@@ -58,7 +86,6 @@ import { localKey } from "../keyboard-owner.js";
 import { buildHint, DEFAULT_SELECT_THEME, showClioOverlayFrame } from "../overlay-frame.js";
 import { barSep, clioTheme, GLYPH, padAnsi, rule, screenTitle } from "../theme/index.js";
 import { modelsForTarget } from "./model-selector.js";
-import { SETTINGS_SECTIONS, type SettingsSectionId } from "./settings-sections.js";
 
 export const SETTINGS_OVERLAY_WIDTH = "100%";
 export const SETTINGS_OVERLAY_MAX_HEIGHT = "100%";
@@ -146,526 +173,36 @@ const RESTART_REQUIRED_IDS = new Set<string>([
 
 export { SETTINGS_SECTIONS, type SettingsSectionId };
 
-const SETTINGS_SECTION_DESCRIPTIONS = {
-	safety: "How freely Clio acts, how a worker's approval ask resolves, and how delegated agents' tools are governed.",
-	orchestrator: "Interactive chat routing, prompt pre-warm, and the optional proactive-memory model plane.",
-	fleet: "Defaults, profiles, agent bindings, and route activation for dispatched workers, and where they run.",
-	targets: "Configured inference targets: which one chat and the fleet use, and whether each answers.",
-	models: "The /model picker, favorites, and configured model cycling.",
-	budget: "Cost ceiling, per-turn output budget, worker concurrency, and the guardrail backstops.",
-	compaction: "When and how the context window is evicted and summarized under pressure.",
-	retry: "Automatic recovery from transient provider, network, and stalled-stream errors.",
-	terminal: "Terminal integration and the Clio color palette.",
-	watchdog: "The opt-in turn-end verifier run, where it is routed, and whether it also fires mid-turn.",
-	advanced:
-		"Commit provenance, runtime plugins, delegation timeouts, the resource library, and links to other surfaces.",
-} as const satisfies Record<SettingsSectionId, string>;
-
-export const SETTINGS_LABELS_BY_ID = {
-	autonomy: "Autonomy level",
-	// Labels follow the CLI's post-rename vocabulary: the config surface is the
-	// fleet, and `worker` is the runtime entity the descriptions still name. A
-	// section headed Fleet whose rows read "Worker profiles" and "Worker
-	// retries" made one setting look like two subsystems.
-	"workers.onPermission": "Fleet approvals routing",
-	"workers.escalation.timeoutMs": "Escalation timeout (ms)",
-	"workers.escalation.fallback": "Escalation fallback",
-	"delegation.defaults.toolGovernance": "Delegation governance",
-	"skills.trustProjectCompatRoots": "Trust project skill roots",
-	"attribution.gitCommits": "Clio commit provenance",
-	safetyNet: "Safety net",
-	"orchestrator.thinkingLevel": "Thinking level",
-	"orchestrator.target": "Target",
-	"orchestrator.model": "Model",
-	"background.target": "Memory target",
-	"background.model": "Memory model",
-	"memory.intervention.enabled": "Proactive memory",
-	"memory.intervention.everyNTools": "Memory cadence (tools)",
-	"memory.intervention.windowSteps": "Memory trajectory steps",
-	"memory.intervention.maxTokens": "Memory reminder tokens",
-	"memory.intervention.timeoutMs": "Memory timeout (ms)",
-	"prewarm.enabled": "Prompt pre-warm",
-	"workers.default.target": "Default target",
-	"workers.default.model": "Default model",
-	"workers.default.thinkingLevel": "Default thinking level",
-	"workers.profiles": "Add profile",
-	"workers.agentBindings": "Add agent route",
-	"workers.maxRetries": "Fleet retries",
-	"workers.resilienceCooldownMs": "Resilience cooldown (ms)",
-	"routing.activeRoles": "Active routing roles",
-	"routing.activePostures": "Active routing postures",
-	"routing.agentAutomation.activeAgentRoles": "Active agent routes",
-	"panes.enabled": "Panes",
-	"panes.notifications": "Pane notifications",
-	"panes.layout": "Boot layout",
-	"panes.workers.ratio": "Workers dock share",
-	"panes.journal": "Run event journal",
-	"panes.yazi.enabled": "Files pane",
-	"panes.yazi.mode": "Files pane mode",
-	"panes.yazi.profile": "Files pane profile",
-	"panes.yazi.followCwd": "Follow conversation cwd",
-	"panes.yazi.ratio": "Files dock share",
-	scope: "Model cycle set",
-	"modelSelector.recentLimit": "Recent models kept",
-	"modelSelector.favorites": "Pinned favorites",
-	"budget.sessionCeilingUsd": "Session ceiling (USD)",
-	"defaults.maxTokens": "Output budget (tokens)",
-	"context.toolResultMaxBytes": "Tool result cap (bytes)",
-	"budget.concurrency": "Fleet concurrency",
-	"guardrails.turnToolCallBudget": "Turn tool-call budget",
-	"guardrails.workerToolCallCap": "Worker tool-call cap",
-	"guardrails.maxDispatchRuns": "Run ledger retention",
-	"guardrails.readMaxBytes": "Read byte cap",
-	"guardrails.observationTurnBudgetBytes": "Observation byte pool",
-	"guardrails.internalDispatchTimeoutMs": "Internal dispatch timeout (ms)",
-	"compaction.auto": "Auto-compact",
-	"compaction.threshold": "Compaction threshold",
-	"context.workingSet.enabled": "Working-set eviction",
-	"context.workingSet.policy": "Eviction policy",
-	"context.workingSet.target": "Eviction target pressure",
-	"context.workingSet.protectLastTurns": "Turns protected from eviction",
-	"context.workingSet.minEvictableTokens": "Minimum evictable tokens",
-	"retry.enabled": "Retry transient errors",
-	"retry.maxRetries": "Max retries",
-	"retry.baseDelayMs": "Base delay (ms)",
-	"retry.maxDelayMs": "Max delay (ms)",
-	"retry.streamStallMs": "Stream stall timeout (ms)",
-	"retry.firstTokenStallMs": "First token timeout (ms)",
-	"terminal.showTerminalProgress": "Terminal progress badges",
-	"terminal.outputVerbosity": "Output style",
-	"terminal.tuiMode": "TUI mode",
-	"terminal.fullscreenScrollbar": "Fullscreen scrollbar",
-	"terminal.smoothStreaming": "Smooth streaming",
-	"terminal.notify": "Desktop notifications",
-	"watchdog.enabled": "Turn-end watchdog",
-	"watchdog.target": "Watchdog target",
-	"watchdog.cadenceToolCalls": "Watchdog cadence (tools)",
-	runtimePlugins: "Runtime plugins",
-	"compaction.model": "Compaction model",
-	"compaction.systemPrompt": "Compaction prompt",
-	"delegation.defaults.connectTimeoutMs": "Delegate connect (ms)",
-	"delegation.defaults.turnTimeoutMs": "Delegate turn (ms)",
-	"delegation.defaults.permissionTimeoutMs": "Delegate permission (ms)",
-	targets: "Configured targets",
-	keybindings: "Keybinding overrides",
-	"delegation.agents": "Delegation agents",
-	"library.catalog": "Library catalog path",
-	"library.remote": "Library remote",
-	"library.confirmedRemote": "Confirmed library remote",
-	"library.sync": "Library sync",
-} as const;
+const SETTINGS_SECTION_DESCRIPTIONS = Object.fromEntries(
+	SETTINGS_SECTIONS.map((section) => [section.id, section.description]),
+) as Record<SettingsSectionId, string>;
 
 /**
  * Entry rows (one per fleet profile field, agent binding, target, fleet node)
  * are keyed by the config path they edit; fleet node rows are read-only status.
  */
 type EntrySettingId =
+	| `setting.${string}`
 	| `workers.profiles.${string}`
 	| `workers.agentBindings.${string}`
 	| `targets.${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" | "route-activation" | "placement" | "panes"}`;
-type TerminalGroupHeaderId = "terminal.group.files-pane";
-type BudgetGroupHeaderId = "budget.group.guardrails";
-type CompactionGroupHeaderId = "compaction.group.working-set";
-type AdvancedGroupHeaderId = "advanced.group.library";
-type GroupHeaderId =
-	| FleetGroupHeaderId
-	| TerminalGroupHeaderId
-	| BudgetGroupHeaderId
-	| CompactionGroupHeaderId
-	| AdvancedGroupHeaderId;
+type GroupHeaderId = `settings.group.${string}`;
 type TargetsCtaId = "targets.add-cta";
-export type SettingsCenterRowId = EditableSettingId | GroupHeaderId | TargetsCtaId;
+export type SettingsCenterRowId =
+	| EditableSettingId
+	| GroupHeaderId
+	| TargetsCtaId
+	| "maintenance.diagnostics"
+	| "maintenance.editor";
 const REMOVE_PROFILE_CHOICE = "(remove profile)";
 const UNBIND_CHOICE = "(unbind)";
 const AUTO_PLACEMENT_CHOICE = "(auto placement)";
 const PROFILE_FIELD_SEPARATOR = " -> ";
 const PROFILE_SUMMARY_VALUE_BUDGET = 26;
 
-export const SETTINGS_SECTION_ROWS = {
-	safety: [
-		"autonomy",
-		"workers.onPermission",
-		"workers.escalation.timeoutMs",
-		"workers.escalation.fallback",
-		"delegation.defaults.toolGovernance",
-		"skills.trustProjectCompatRoots",
-		"safetyNet",
-	],
-	orchestrator: [
-		"orchestrator.thinkingLevel",
-		"orchestrator.target",
-		"orchestrator.model",
-		"background.target",
-		"background.model",
-		"memory.intervention.enabled",
-		"memory.intervention.everyNTools",
-		"memory.intervention.windowSteps",
-		"memory.intervention.maxTokens",
-		"memory.intervention.timeoutMs",
-		"prewarm.enabled",
-	],
-	fleet: [
-		"workers.default.target",
-		"workers.default.model",
-		"workers.default.thinkingLevel",
-		"workers.maxRetries",
-		"workers.resilienceCooldownMs",
-		"workers.profiles",
-		"workers.agentBindings",
-		"routing.activeRoles",
-		"routing.activePostures",
-		"routing.agentAutomation.activeAgentRoles",
-		"panes.enabled",
-		"panes.notifications",
-		"panes.layout",
-		"panes.workers.ratio",
-		"panes.journal",
-	],
-	models: ["scope", "modelSelector.recentLimit", "modelSelector.favorites"],
-	budget: [
-		"budget.sessionCeilingUsd",
-		"defaults.maxTokens",
-		"context.toolResultMaxBytes",
-		"budget.concurrency",
-		"guardrails.turnToolCallBudget",
-		"guardrails.workerToolCallCap",
-		"guardrails.maxDispatchRuns",
-		"guardrails.readMaxBytes",
-		"guardrails.observationTurnBudgetBytes",
-		"guardrails.internalDispatchTimeoutMs",
-	],
-	compaction: [
-		"compaction.auto",
-		"compaction.threshold",
-		"context.workingSet.enabled",
-		"context.workingSet.policy",
-		"context.workingSet.target",
-		"context.workingSet.protectLastTurns",
-		"context.workingSet.minEvictableTokens",
-	],
-	retry: [
-		"retry.enabled",
-		"retry.maxRetries",
-		"retry.baseDelayMs",
-		"retry.maxDelayMs",
-		"retry.streamStallMs",
-		"retry.firstTokenStallMs",
-	],
-	terminal: [
-		"terminal.showTerminalProgress",
-		"terminal.outputVerbosity",
-		"terminal.tuiMode",
-		"terminal.fullscreenScrollbar",
-		"terminal.smoothStreaming",
-		"terminal.notify",
-		"panes.yazi.enabled",
-		"panes.yazi.mode",
-		"panes.yazi.profile",
-		"panes.yazi.followCwd",
-		"panes.yazi.ratio",
-	],
-	watchdog: ["watchdog.enabled", "watchdog.target", "watchdog.cadenceToolCalls"],
-	advanced: [
-		"runtimePlugins",
-		"attribution.gitCommits",
-		"compaction.model",
-		"compaction.systemPrompt",
-		"delegation.defaults.connectTimeoutMs",
-		"delegation.defaults.turnTimeoutMs",
-		"delegation.defaults.permissionTimeoutMs",
-		"keybindings",
-		"delegation.agents",
-		"library.catalog",
-		"library.remote",
-		"library.confirmedRemote",
-		"library.sync",
-	],
-	targets: ["targets"],
-} as const satisfies Record<SettingsSectionId, readonly EditableSettingId[]>;
-
-const SETTINGS_DESCRIPTIONS_BY_ID = {
-	autonomy: "How freely Clio acts; the safety net always applies.",
-	"workers.onPermission":
-		"How a worker resolves an approval ask: deny the call, fail the run, or escalate to this session.",
-	"workers.escalation.timeoutMs": "How long an escalated worker approval waits for you before the fallback applies.",
-	"workers.escalation.fallback": "What an escalated approval becomes when nobody answers inside the timeout.",
-	"delegation.defaults.toolGovernance": "Tool policy for delegated external agents.",
-	"skills.trustProjectCompatRoots": "Whether third-party project skill roots are loaded.",
-	"attribution.gitCommits":
-		"Add evidence-backed assistance, testing, review, and contributor trailers to commits created through Clio.",
-	safetyNet: "Always-on rails; tuned in .clio-coder/safety.yaml.",
-	"orchestrator.thinkingLevel": "Reasoning budget for the chat loop.",
-	"orchestrator.target": "Active chat target id.",
-	"orchestrator.model": "Active chat wire model id.",
-	"background.target": "Optional target for LLM memory steps; unset keeps rules-only memory.",
-	"background.model": "Small non-reasoning model used only for task memory steps.",
-	"memory.intervention.enabled": "Master switch for rules-only and model-backed task memory.",
-	"memory.intervention.everyNTools": "Maximum tool executions between prompted memory steps.",
-	"memory.intervention.windowSteps": "Recent completed tool steps visible to the memory policy.",
-	"memory.intervention.maxTokens": "Hard cap for one visible memory reminder.",
-	"memory.intervention.timeoutMs": "Hard deadline for one background-model memory call.",
-	"prewarm.enabled": "Send the next turn's known prefix ahead of time so a local server has already prefilled it.",
-	"workers.default.target": "Default /run target id.",
-	"workers.default.model": "Default /run wire model id.",
-	"workers.default.thinkingLevel": "Reasoning budget for dispatched workers.",
-	"workers.profiles": "Named target/model/thinking choices that native workers can use. Enter adds one.",
-	"workers.agentBindings": "Pins native Clio agents, including shadow agents, to worker profiles. Enter adds one.",
-	"workers.maxRetries": "Automatic retries for a retryable worker outcome.",
-	"workers.resilienceCooldownMs":
-		"How long a failing target, runtime, and model route is skipped before it is tried again.",
-	"routing.activeRoles": "Execution roles whose joint route selection may act instead of only shadowing.",
-	"routing.activePostures": "Route postures whose selection may act instead of only shadowing.",
-	"routing.agentAutomation.activeAgentRoles": "Exact agent and execution-role pairs whose agent choice may act.",
-	"panes.enabled": "Default panes activation for new sessions; `--with-panes` / `--no-panes` beat it.",
-	"panes.notifications": "Which terminal run states raise a pane-host toast.",
-	"panes.layout": "What composes itself at interactive boot: nothing, the workers dock, or workers plus files.",
-	"panes.workers.ratio": "Share of the width the workers dock takes, at most half.",
-	"panes.journal": "Whether every dispatched run's event tail is written to disk for `clio-coder fleet view`.",
-	"panes.yazi.enabled":
-		"Whether `/files`, its key, and `/panes open files` may open the files pane or the one-shot pick.",
-	"panes.yazi.mode": "Keep the files pane beside the conversation, or close it after one selection.",
-	"panes.yazi.profile": "Use Clio's managed, themed engine profile or the operator's own file-manager configuration.",
-	"panes.yazi.followCwd": "Push the conversation directory into an already-open companion pane.",
-	"panes.yazi.ratio": "Share of the height the files dock takes, at most half.",
-	scope: "Configured model-cycle action set.",
-	"modelSelector.recentLimit": "How many recently used models /model remembers.",
-	"modelSelector.favorites": "Exact target/model refs pinned in /model.",
-	"budget.sessionCeilingUsd": "Per-session cost cap.",
-	"defaults.maxTokens": "Output tokens requested per turn, applied to every target.",
-	"context.toolResultMaxBytes": "Maximum bytes returned from one tool result before the full text spills to scratch.",
-	"budget.concurrency": "Parallel workers allowed during dispatch.",
-	"guardrails.turnToolCallBudget": "Soft per-turn tool-call budget for this chat loop.",
-	"guardrails.workerToolCallCap": "Lifetime ceiling on tool calls one dispatched worker may execute.",
-	"guardrails.maxDispatchRuns": "How many finished runs the dispatch ledger keeps before the oldest are dropped.",
-	"guardrails.readMaxBytes": "Per-call byte cap for the read tool.",
-	"guardrails.observationTurnBudgetBytes": "Shared per-turn byte pool across every observation-producing tool.",
-	"guardrails.internalDispatchTimeoutMs": "Wall-clock cap for one internal generator dispatch.",
-	"compaction.auto": "Auto-compact before a turn when context crosses the threshold.",
-	"compaction.threshold": "Pressure at which compaction masks stale observations, then summarizes.",
-	"context.workingSet.enabled": "Non-destructive eviction of stale tool results before a summary is ever needed.",
-	"context.workingSet.policy": "Which candidates the eviction pass selects.",
-	"context.workingSet.target": "Context pressure an applied eviction batch brings the session down to.",
-	"context.workingSet.protectLastTurns": "Recent user turns whose observations are never evicted.",
-	"context.workingSet.minEvictableTokens":
-		"Results below this token estimate stay; the marker would cost more than it saves.",
-	"retry.enabled": "Retry transient provider errors on the next submit.",
-	"retry.maxRetries": "Retry attempts after the initial failure.",
-	"retry.baseDelayMs": "Initial retry delay in milliseconds.",
-	"retry.maxDelayMs": "Maximum retry delay in milliseconds.",
-	"retry.streamStallMs": "Silence on an in-flight stream past this long is treated as a wedged backend.",
-	"retry.firstTokenStallMs": "Silence allowed before a call's first token, for backends that load the model on demand.",
-	"terminal.showTerminalProgress": "Emit OSC 9;4 progress badges during agent turns.",
-	"terminal.outputVerbosity": "How much reasoning, tool input, and live tool output appears in the transcript.",
-	"terminal.tuiMode": "Use regular terminal scrollback or a fullscreen transcript with a sticky composer and footer.",
-	"terminal.fullscreenScrollbar": "When the draggable transcript scrollbar is visible in fullscreen mode.",
-	"terminal.smoothStreaming": "Presentation-only pacing for streamed assistant text and thinking.",
-	"terminal.notify":
-		"Content-free desktop notification when a turn ends, a detached batch settles, or an approval parks.",
-	"watchdog.enabled": "When enabled, a turn that changed the tree is reviewed by one read-only verifier run.",
-	"watchdog.target": "Set target to route the run at a cheap local model; blank uses the session's active target.",
-	"watchdog.cadenceToolCalls": "Also fire every N tool calls inside a turn; blank fires at turn end only.",
-	runtimePlugins: "npm packages exporting clioRuntimes: RuntimeDescriptor[].",
-	"compaction.model": "Dedicated summarization model; blank uses the orchestrator.",
-	"compaction.systemPrompt": "Path to a compaction prompt override; blank uses the built-in.",
-	"delegation.defaults.connectTimeoutMs": "How long to wait for a delegated agent to connect.",
-	"delegation.defaults.turnTimeoutMs": "How long a single delegated turn may run.",
-	"delegation.defaults.permissionTimeoutMs": "How long a delegated permission ask may wait.",
-	targets: "Inference targets available for chat and workers. Add one with `clio-coder targets add`.",
-	keybindings: "Custom key overrides layered on the defaults.",
-	"delegation.agents": "External ACP agents available to /delegate.",
-	"library.catalog": "Path to the private resource catalog; blank uses the one in your config directory.",
-	"library.remote": "Git remote the catalog syncs with; blank keeps the library entirely local.",
-	"library.confirmedRemote": "The remote you confirmed. Sync refuses until it matches library.remote.",
-	"library.sync": "Whether `clio-coder library sync` and `push` may talk to the remote at all.",
-} as const satisfies Record<EditableSettingId, string>;
-
-/** Longer, optional guidance shown beneath the one-line description when there is room. */
-const SETTINGS_HELP_BY_ID: Partial<Record<EditableSettingId, string>> = {
-	autonomy:
-		"read-only observes; suggest parks non-read calls; auto-edit edits, dispatches, and runs recognized commands; full-auto runs except command substitution and system-level changes. A confirmation marked exposure=outward parks for you at suggest and auto-edit.",
-	"defaults.maxTokens":
-		"Clamped down to each model's max-output cap and the remaining context window. Set 0 to use per-model caps only.",
-	"context.toolResultMaxBytes":
-		"The 192KB per-turn observation pool remains authoritative. Three full 64KB results consume it, so a fourth finds it filled. Whole number of at least 4096 bytes · default: 65536 (64KB).",
-	"compaction.threshold":
-		"pressure = estimated tokens ÷ context window. Higher keeps more history but risks overflow before a summary runs.",
-	"context.workingSet.enabled":
-		"Eviction moves stale tool-result bodies and thinking blocks out of the model's working set and records a ledger entry; history is never rewritten. Off skips eviction and goes straight to summary compaction. Legal values: true, false · default: true.",
-	"context.workingSet.policy":
-		"structural-v1 selects by message structure; age-horizon is the older age-based rule. Legal values: structural-v1, age-horizon · default: structural-v1.",
-	"context.workingSet.target":
-		"An applied eviction batch keeps evicting until pressure reaches this ratio, so it sits below compaction.threshold. Greater than 0 and less than 1 · default: 0.6.",
-	"context.workingSet.protectLastTurns": "Counted in user turns. Whole number of at least 1 · default: 6.",
-	"context.workingSet.minEvictableTokens":
-		"The floor sweep put marker break-even near 50 tokens; 200 is the churn guard. Whole number, 0 evicts anything · default: 200.",
-	"guardrails.turnToolCallBudget":
-		"Crossing it blocks further calls in the turn with a stop-and-summarize directive, and the hard interrupt ceiling sits a fixed margin above. A backstop against a model spraying unproductive calls, not a routine ceiling: a repo-wide audit legitimately runs dozens. Whole number of at least 1 · default: 60.",
-	"guardrails.workerToolCallCap":
-		"Bounds admitted calls, not attempts: a call the harness refuses never ran and never spends the cap. Dispatch takes the smaller of this and the agent recipe's own budget, so the recipe normally binds. Whole number of at least 1 · default: 150.",
-	"guardrails.maxDispatchRuns":
-		"Runs leaving the ring also lose their event journal directory. Whole number of at least 1 · default: 1000.",
-	"guardrails.readMaxBytes":
-		"Clamped up to a 1KB floor at use. Whole number of bytes, at least 1 · default: 51200 (50KB).",
-	"guardrails.observationTurnBudgetBytes":
-		"One pool shared by every observation-producing tool in a turn, so a single verbose tool cannot starve the rest. Whole number of bytes, at least 1 · default: 196608 (192KB).",
-	"guardrails.internalDispatchTimeoutMs":
-		"Covers the wiki documenter and the bootstrap scout. Continuous output satisfies the heartbeat watchdog and a run mid-generation spends no tool calls, so this is the only guard that ends a degenerate generator. Healthy runs finish in minutes. Whole milliseconds of at least 1 · default: 900000 (15 minutes).",
-	"retry.streamStallMs":
-		"Measured from the last token received, not from the request, so a slow-but-alive stream is never aborted. The retry then follows the same enabled/maxRetries/delay settings above. Whole milliseconds · default: 180000 (three minutes).",
-	"retry.firstTokenStallMs":
-		"Measured from the request until the first token. A local server that slept reloads the model and prefills cold first, so this window is longer than the stream stall timeout; the larger of the two applies. 0 never aborts a call that has not started streaming. Whole milliseconds · default: 600000 (ten minutes).",
-	"library.catalog":
-		"Absolute path, or blank for the catalog in your config directory. The catalog is the index `clio-coder library` reads; installed resources land in the usual skill and resource roots either way. Default: blank.",
-	"library.remote":
-		"A Git remote URL, or blank to keep the library local. Setting it is not enough to sync: the remote must also be confirmed, and library.sync must be true. Default: blank.",
-	"library.confirmedRemote":
-		"Written by the confirm flow, not by hand, because confirming a remote here would be the record confirming itself. Sync refuses with library_remote_unconfirmed until this equals library.remote. Default: blank.",
-	"library.sync":
-		"Off means `clio-coder library sync` and `push` refuse before touching the network, whatever the remote says. Legal values: true, false · default: false.",
-	"budget.concurrency":
-		"auto allows four local workers. A fixed number caps how many workers run at once; the default is one.",
-	"skills.trustProjectCompatRoots":
-		"Project roots like .claude/skills and .codex/skills are untrusted by default; enabling exposes them to the model.",
-	"attribution.gitCommits":
-		"Role trailers are added only when Clio has trusted evidence for that role. Disabling leaves subsequent commit messages entirely unchanged.",
-	"workers.onPermission":
-		"deny turns the ask into a tool denial and the run continues; fail stops the run as permission_required; escalate forwards the ask to you and falls back per workers.escalation on timeout.",
-	"workers.escalation.timeoutMs":
-		"Only the escalate posture reads it, and it is what keeps that posture non-stall: a headless session has no operator to answer, so the fallback always governs there. Whole milliseconds of at least 1; default: 120000 (two minutes).",
-	"workers.escalation.fallback":
-		"deny turns the unanswered ask into a tool denial and the run continues; fail ends the run as permission_required. Legal values: deny, fail · default: deny.",
-	"workers.resilienceCooldownMs":
-		"Applied per target, runtime, and wire model after a failure class that trips the breaker; a clean run clears it immediately. Whole milliseconds, 0 disables the cooldown; default: 15000.",
-	"routing.activeRoles":
-		"Joint route selection stays shadow-only, recording what it would have picked, unless both the execution role and the requested posture are named as active. Legal values: researcher, verifier, reviewer, judge · default: none active.",
-	"routing.activePostures":
-		"Manual pins are exact rather than adaptive, so manual is never an activated posture. Legal values: quality, balanced, latency, economy · default: none active.",
-	"routing.agentAutomation.activeAgentRoles":
-		"Exact agentId and executionRole pairs, because independent agent and role lists would authorize their whole cross-product. Execution roles: builder, researcher, verifier, reviewer, judge; the agentId `auto` is reserved. Edit the pairs in settings.yaml; default: none active.",
-	"prewarm.enabled":
-		"Fires at session start, after a resume rebuilds the message array, and after a compaction settles, never while a turn or dispatch is running. Local-native targets and interactive sessions only, whatever this says. Legal values: true, false · default: true.",
-	"workers.agentBindings":
-		"Bind base, custom, and shadow native agents such as scout, researcher, and provenance to profiles. ACP delegation agents cannot be bound.",
-	"delegation.defaults.toolGovernance":
-		"clio-coder-policy gates the agent through Clio's safety net; agent-managed trusts the agent; deny-all blocks every tool.",
-	scope:
-		"Choose target-level or exact target/model refs. Explicit model-cycle bindings step the chat target through this list.",
-	runtimePlugins: "Comma-separated package names, loaded at startup. Restart Clio after changing.",
-	"terminal.notify":
-		"OSC 777, or OSC 9 on iTerm2, Windows Terminal, and ConEmu. Interactive TTY runs only; the body never carries prompt text, file paths, or model output.",
-	"watchdog.enabled":
-		"The verifier run is briefed with the turn's coalesced diff and the task board's current scope; its blockers become one transcript notice and nothing else. Headless and ACP runs never fire it.",
-	"watchdog.target":
-		"A watchdog run costs a worker run per mutating turn, so routing it at a local target keeps the review cheap. Leave blank to reuse whatever the session is already talking to.",
-	"watchdog.cadenceToolCalls":
-		"Mid-turn firing is how scope drift becomes visible before the turn ends. Leave blank and the watchdog fires at turn end only.",
-	keybindings:
-		"Alt+O cycles Output style: Compact, Standard, Detailed. Use /view for full reasoning and action details. Shift+Tab changes model thinking effort.",
-};
-
-/** Per-value meaning, surfaced for the current value of an enum knob. */
-const SETTINGS_VALUE_HELP_BY_ID: Partial<Record<EditableSettingId, Record<string, string>>> = {
-	autonomy: {
-		"read-only": "observe and answer only; never edits files or runs commands",
-		suggest:
-			"propose every edit and command for your approval; confirmations marked exposure=outward (filing an issue or PR, pushing, releasing) park here as well",
-		"auto-edit":
-			"edits and dispatches run; recognized commands (tests, lint, build, .clio-coder/safety.yaml entries) run; other commands ask, as do confirmations marked exposure=outward (filing an issue or PR, pushing, releasing)",
-		"full-auto":
-			"runs without approval prompts, outward-facing confirmations included, except command substitution and system-level changes; hard blocks always apply",
-	},
-	"workers.onPermission": {
-		deny: "a worker permission ask becomes a tool denial; the run continues",
-		fail: "the run ends immediately as permission_required",
-		escalate:
-			"the ask is forwarded to this session's operator; on timeout it falls back to deny or fail per workers.escalation",
-	},
-	"workers.escalation.fallback": {
-		deny: "an unanswered escalation becomes a tool denial and the run continues",
-		fail: "an unanswered escalation ends the run as permission_required",
-	},
-	"prewarm.enabled": {
-		true: "prefill the next turn's known prefix on local-native targets",
-		false: "never send a pre-warm request; the first turn pays the whole prefill",
-	},
-	"context.workingSet.enabled": {
-		true: "evict stale observations non-destructively before summarizing",
-		false: "skip eviction and go straight to summary compaction",
-	},
-	"context.workingSet.policy": {
-		"structural-v1": "select eviction candidates by message structure",
-		"age-horizon": "the older rule: select by age alone",
-	},
-	"library.sync": {
-		true: "allow `clio-coder library sync` and `push` to reach the confirmed remote",
-		false: "refuse every library network operation",
-	},
-	"delegation.defaults.toolGovernance": {
-		"clio-coder-policy": "Clio's safety policy gates the delegated agent's tools",
-		"agent-managed": "the external agent governs its own tools",
-		"deny-all": "block every tool the delegated agent requests",
-	},
-	"compaction.auto": {
-		true: "compact automatically before a turn crosses the threshold",
-		false: "context is only compacted when you run /context compact",
-	},
-	// `embedded` is a declared rung with no implementation behind it yet; it
-	// refuses until Clio can own a pane host, and the hint says so.
-	"panes.enabled": {
-		auto: "detect a herdr session and join it as a guest; no pane host, no panes",
-		embedded: "not implemented yet; use auto or guest",
-		off: "never detect or open a pane",
-	},
-	"retry.enabled": {
-		true: "retry transient provider errors automatically",
-		false: "surface transient errors immediately without retrying",
-	},
-	"skills.trustProjectCompatRoots": {
-		true: "load skills from .claude/.codex/.github/etc. project roots",
-		false: "ignore third-party project skill roots",
-	},
-	"attribution.gitCommits": {
-		enabled: "add only the Clio role trailers justified by trusted evidence",
-		disabled: "leave every subsequent commit message byte-for-byte unchanged",
-	},
-	"terminal.showTerminalProgress": {
-		true: "emit OSC 9;4 taskbar/tab progress badges during turns",
-		false: "no terminal progress badges",
-	},
-	"terminal.outputVerbosity": {
-		compact: "quiet action summaries, answers, and visible failures",
-		standard: "short reasoning and change previews, clear action outcomes",
-		detailed: "larger bounded previews; full content is available in /view",
-	},
-	"terminal.tuiMode": {
-		regular: "preserve terminal scrollback and render the composer below the transcript",
-		fullscreen: "use the alternate screen with an independently scrollable transcript and sticky composer/footer",
-	},
-	"terminal.fullscreenScrollbar": {
-		hidden: "never draw the fullscreen transcript scrollbar",
-		auto: "show the scrollbar while scrolling or dragging",
-		always: "reserve the rightmost column for the scrollbar",
-	},
-	"terminal.notify": {
-		true: "post a content-free desktop notification on turn end, batch settlement, and a parked approval",
-		false: "never post a desktop notification",
-	},
-	"watchdog.enabled": {
-		true: "review every mutating turn with one read-only verifier run",
-		false: "no verifier run; a turn ends without a second opinion",
-	},
-	"terminal.smoothStreaming": {
-		off: "preserve the current immediate 16ms-coalesced streaming behavior",
-		auto: "pace only on a capable local TTY without accessibility or backpressure risk",
-		on: "request grapheme-safe pacing; stdout backpressure still pauses presentation",
-	},
-};
-
 export type SettingSubmenuBuilder = NonNullable<SettingItem["submenu"]>;
 type SettingsCenterLane = "sections" | "rows";
 /**
@@ -752,6 +289,8 @@ interface BuildSettingItemsOptions {
 	requestRefresh?: () => void;
 	/** Live fleet node snapshots (scheduling.fleet.list()); absent hides the node rows. */
 	getFleetNodes?: () => ReadonlyArray<FleetNodeSnapshot>;
+	/** Live in-process dispatch breaker state per route; absent shows no breaker state. */
+	getRouteBreakers?: () => ReadonlyArray<RouteBreakerView>;
 	/** Run the API-key / OAuth connect flow for a target; absent hides the action. */
 	connectTarget?: (targetId: string) => Promise<void> | void;
 	/** The connect/probe operation currently acting on a target, if any. */
@@ -1474,14 +1013,7 @@ function targetActionsSubmenu(targetId: string, options: BuildSettingItemsOption
 }
 
 function sectionForSetting(id: EditableSettingId): SettingsSectionId {
-	if (id.startsWith("workers.profiles.") || id.startsWith("workers.agentBindings.") || id.startsWith("fleet.nodes.")) {
-		return "fleet";
-	}
-	if (id.startsWith("targets.")) return "targets";
-	for (const section of SETTINGS_SECTIONS) {
-		if ((SETTINGS_SECTION_ROWS[section.id] as readonly EditableSettingId[]).includes(id)) return section.id;
-	}
-	return "safety";
+	return settingsSectionForPath(settingsV2PathForRow(id));
 }
 
 function cycleAffordance(values: readonly string[]): string {
@@ -1502,36 +1034,12 @@ function defaultValueFor(id: EditableSettingId): string | undefined {
 	return String(raw);
 }
 
-const SETTINGS_CENTER_V2_PATH_OVERRIDES: Readonly<Record<string, string>> = {
-	"workers.profiles": "fleet.profiles",
-	"workers.agentBindings": "fleet.agentProfiles",
-	"routing.agentAutomation.activeAgentRoles": "fleet.adaptiveRouting.agentRoles",
-	"panes.enabled": "interface.panes.enabled",
-	"panes.notifications": "interface.panes.notifications",
-	"panes.journal": "fleet.history.journal",
-	"panes.yazi.enabled": "interface.panes.files.enabled",
-	"panes.yazi.mode": "interface.panes.files.mode",
-	"panes.yazi.profile": "interface.panes.files.profile",
-	"panes.yazi.followCwd": "interface.panes.files.followCwd",
-	"panes.yazi.ratio": "interface.panes.files.ratio",
-	"panes.layout": "interface.panes.layout",
-	"panes.workers.ratio": "interface.panes.workers.ratio",
-	"delegation.agents": "integrations.externalAgents.entries",
-	keybindings: "interface.keybindings",
-};
-
-/** Keep the existing Center navigation while showing and persisting only canonical v2 paths. */
-function settingsV2PathForRow(id: EditableSettingId): string {
-	if (id.startsWith("workers.profiles.")) return `fleet.profiles.${id.slice("workers.profiles.".length)}`;
-	if (id.startsWith("workers.agentBindings.")) return `fleet.agentProfiles.${id.slice("workers.agentBindings.".length)}`;
-	const override = SETTINGS_CENTER_V2_PATH_OVERRIDES[id];
-	if (override !== undefined) return override;
-	for (const [v1Path, v2Path] of SETTINGS_V1_PATH_MOVES) {
-		if (v1Path === id) return v2Path;
-		if (v1Path === `${id}[]` && v2Path.endsWith("[]")) return v2Path.slice(0, -2);
-	}
-	return id;
-}
+export const SETTINGS_SECTION_ROWS = Object.fromEntries(
+	SETTINGS_SECTIONS.map((section) => [
+		section.id,
+		(Object.keys(SETTINGS_LABELS_BY_ID) as EditableSettingId[]).filter((id) => sectionForSetting(id) === section.id),
+	]),
+) as unknown as Record<SettingsSectionId, readonly EditableSettingId[]>;
 
 function settingItem(
 	id: EditableSettingId,
@@ -1581,7 +1089,7 @@ function settingItem(
  */
 function groupHeader(
 	id: GroupHeaderId,
-	section: SettingsSectionId,
+	section: SettingsSectionName,
 	label: string,
 	description: string,
 ): SettingsCenterItem {
@@ -1590,7 +1098,7 @@ function groupHeader(
 		label,
 		currentValue: "",
 		description,
-		section,
+		section: resolveSettingsSection(section) ?? "advanced",
 		configPath: id,
 		affordance: "group heading",
 		scope: "live",
@@ -1600,14 +1108,6 @@ function groupHeader(
 	};
 }
 
-function fleetGroupHeader(id: FleetGroupHeaderId, label: string): SettingsCenterItem {
-	return groupHeader(id, "fleet", label, `${label} in the Fleet workbench.`);
-}
-
-function terminalGroupHeader(id: TerminalGroupHeaderId, label: string): SettingsCenterItem {
-	return groupHeader(id, "terminal", label, `${label} behavior in the terminal.`);
-}
-
 function targetAddCta(): SettingsCenterItem {
 	return {
 		id: "targets.add-cta",
@@ -1642,10 +1142,83 @@ function thinkingChoices(
 
 /**
  * Surface every configurable knob. Editable knobs carry values/submenus;
- * read-only pointer rows (targets, keybindings, favorites, safety net) name the
+ * read-only pointer rows (maintenance and safety net) name the
  * surface that owns them so the Center has no dead-but-tappable rows.
  */
-function buildSettingItems(settings: Readonly<ClioSettings>, options?: BuildSettingItemsOptions): SettingsCenterItem[] {
+function commonControlItem(control: SettingControl, live: () => Readonly<ClioSettings>): SettingsCenterItem {
+	const id = `setting.${control.path}` as const;
+	return {
+		id,
+		label: control.label,
+		description: control.description,
+		help: controlInstructions(control),
+		section: settingsSectionForPath(control.path),
+		configPath: control.path,
+		currentValue: "",
+		affordance: control.readOnly ? "managed by its confirmation flow" : "edit with validation",
+		scope: settingsChangeKind(control.path) === "restartRequired" ? "restart" : "live",
+		defaultValue: formatControlValue(getAtPath(DEFAULT_SETTINGS, control.path)),
+		readOnly: control.readOnly,
+		presentationKind: "setting",
+		valueSegments: [],
+		...(control.choices || control.kind === "boolean"
+			? { values: [...(control.choices ?? ["true", "false"])] }
+			: {
+					submenu: (current, done) => {
+						const input = new Input();
+						input.setValue(current);
+						input.focused = true;
+						const wrapper = new SubmenuWrapper(
+							control.label,
+							input,
+							buildHint([{ key: "Enter", verb: "review" }], "back"),
+							controlInstructions(control),
+						);
+						input.onSubmit = (value) => {
+							try {
+								applyControlValue(structuredClone(live()), control.path, value);
+								done(value);
+							} catch (error) {
+								wrapper.setProblem(error instanceof Error ? error.message : String(error));
+							}
+						};
+						input.onEscape = () => done();
+						return wrapper;
+					},
+				}),
+	};
+}
+
+function maintenanceRows(): SettingsCenterItem[] {
+	return [
+		{
+			id: "maintenance.diagnostics" as const,
+			label: "Diagnostics",
+			currentValue: "clio-coder configure --section diagnostics",
+			description: "Inspect version and directories, run doctor, or read settings.yaml from the configure wizard.",
+		},
+		{
+			id: "maintenance.editor" as const,
+			label: "All settings",
+			currentValue: "clio-coder configure --edit",
+			description: "Open the complete settings.yaml in your editor, validate the draft, and review before saving.",
+		},
+	].map((row) => ({
+		...row,
+		configPath: row.id,
+		valueSegments: [],
+		section: "advanced",
+		affordance: "run in a terminal",
+		scope: "restart",
+		readOnly: true,
+		presentationKind: "status",
+	}));
+}
+
+export function buildSettingItems(
+	settings: Readonly<ClioSettings>,
+	options?: BuildSettingItemsOptions,
+): SettingsCenterItem[] {
 	const live = options?.getSettings ?? ((): Readonly<ClioSettings> => settings);
 	const scopeList = settings.chat.modelPicker.cycleSet ?? [];
 	const scopeText = scopeList.length > 0 ? scopeList.join(", ") : "(empty)";
@@ -1703,7 +1276,8 @@ function buildSettingItems(settings: Readonly<ClioSettings>, options?: BuildSett
 	const favorites = settings.chat.modelPicker?.favorites ?? [];
 	const agents = settings.integrations.externalAgents?.entries ?? [];
 	const keybindingCount = Object.keys(settings.interface.keybindings ?? {}).length;
-	return [
+	const items: SettingsCenterItem[] = [
+		...maintenanceRows(),
 		settingItem("autonomy", settings.safety.autonomy, {
 			values: ["read-only", "suggest", "auto-edit", "full-auto"],
 		}),
@@ -1764,7 +1338,6 @@ function buildSettingItems(settings: Readonly<ClioSettings>, options?: BuildSett
 		settingItem("prewarm.enabled", String(settings.chat.prewarm), {
 			values: ["true", "false"],
 		}),
-		fleetGroupHeader("fleet.group.defaults", "Defaults"),
 		settingItem("workers.default.target", settings.fleet.default.target ?? "(unset)", {
 			submenu: targetSubmenu,
 			affordance: options?.providers ? "opens picker" : "free text",
@@ -1783,7 +1356,6 @@ function buildSettingItems(settings: Readonly<ClioSettings>, options?: BuildSett
 			submenu: editNumberSubmenu("Edit resilience cooldown (ms)", "workers.resilienceCooldownMs"),
 			affordance: "free text",
 		}),
-		fleetGroupHeader("fleet.group.profiles", "Profiles"),
 		...fleetProfileRows(settings, live, options),
 		settingItem("workers.profiles", "", {
 			label: "Add profile",
@@ -1792,7 +1364,6 @@ function buildSettingItems(settings: Readonly<ClioSettings>, options?: BuildSett
 			presentationKind: "action",
 			valueSegments: [],
 		}),
-		fleetGroupHeader("fleet.group.agent-routes", "Agent routes"),
 		...agentBindingRows(settings, live),
 		settingItem("workers.agentBindings", "", {
 			label: "Add agent route",
@@ -1801,7 +1372,6 @@ function buildSettingItems(settings: Readonly<ClioSettings>, options?: BuildSett
 			presentationKind: profileCount > 0 ? "action" : "read-only-fact",
 			valueSegments: [],
 		}),
-		fleetGroupHeader("fleet.group.route-activation", "Route activation"),
 		settingItem("routing.activeRoles", routing.roles.length > 0 ? routing.roles.join(", ") : "(none)", {
 			submenu: editEnumListSubmenu("Edit active routing roles", ACTIVE_ROUTING_ROLES),
 			affordance: `free text from ${ACTIVE_ROUTING_ROLES.join(", ")}`,
@@ -1819,11 +1389,9 @@ function buildSettingItems(settings: Readonly<ClioSettings>, options?: BuildSett
 				: "(none)",
 			{ affordance: "edit settings.yaml", readOnly: true },
 		),
-		fleetGroupHeader("fleet.group.placement", "Placement"),
 		...fleetNodeRows(options?.getFleetNodes?.() ?? []),
 		...fleetEndpointRows(options?.providers),
-		fleetGroupHeader("fleet.group.panes", "Panes"),
-		settingItem("panes.enabled", panes.enabled, { values: ["auto", "embedded", "off"] }),
+		settingItem("panes.enabled", panes.enabled, { values: ["auto", "off"] }),
 		settingItem("panes.notifications", panes.notifications, { values: ["failures", "all", "off"] }),
 		settingItem("panes.layout", panes.layout, { values: ["off", "workers", "cockpit"] }),
 		settingItem("panes.workers.ratio", formatThreshold(panes.workers.ratio, "0.34"), {
@@ -1864,12 +1432,6 @@ function buildSettingItems(settings: Readonly<ClioSettings>, options?: BuildSett
 		settingItem("budget.concurrency", String(settings.fleet.concurrency), {
 			values: ["auto", "1", "2", "4", "8"],
 		}),
-		groupHeader(
-			"budget.group.guardrails",
-			"budget",
-			"Guardrails",
-			"Numeric backstops that bound runaway agent behavior.",
-		),
 		settingItem("guardrails.turnToolCallBudget", String(safetyLimits.chatToolCallsPerTurn), {
 			submenu: editNumberSubmenu("Edit turn tool-call budget", "guardrails.turnToolCallBudget"),
 			affordance: "free text",
@@ -1900,12 +1462,6 @@ function buildSettingItems(settings: Readonly<ClioSettings>, options?: BuildSett
 		settingItem("compaction.threshold", formatThreshold(compaction.threshold), {
 			values: ["0.7", "0.8", "0.85", "0.9"],
 		}),
-		groupHeader(
-			"compaction.group.working-set",
-			"compaction",
-			"Working set",
-			"The non-destructive eviction layer that runs before a summary is needed.",
-		),
 		settingItem("context.workingSet.enabled", String(workingSet.enabled), {
 			values: ["true", "false"],
 		}),
@@ -1957,7 +1513,6 @@ function buildSettingItems(settings: Readonly<ClioSettings>, options?: BuildSett
 		settingItem("terminal.notify", String(terminal.desktopNotifications), {
 			values: ["false", "true"],
 		}),
-		terminalGroupHeader("terminal.group.files-pane", "Files pane"),
 		settingItem("panes.yazi.enabled", String(panes.files.enabled), { values: ["true", "false"] }),
 		settingItem("panes.yazi.mode", panes.files.mode, { values: ["companion", "chooser"] }),
 		settingItem("panes.yazi.profile", panes.files.profile, { values: ["managed", "user"] }),
@@ -2039,12 +1594,6 @@ function buildSettingItems(settings: Readonly<ClioSettings>, options?: BuildSett
 		settingItem("delegation.agents", agents.length > 0 ? `${agents.length} agent(s)` : "(none)", {
 			...delegationAgentsAffordance(agents, options?.getInteropProposals?.() ?? []),
 		}),
-		groupHeader(
-			"advanced.group.library",
-			"advanced",
-			"Library",
-			"The private resource catalog and the remote it may sync with.",
-		),
 		settingItem("library.catalog", library.catalog ?? "(config directory)", {
 			submenu: editTextSubmenu("Edit library catalog path; blank uses the config directory"),
 			affordance: "free text",
@@ -2065,6 +1614,51 @@ function buildSettingItems(settings: Readonly<ClioSettings>, options?: BuildSett
 			values: ["true", "false"],
 		}),
 	];
+	for (const item of items) {
+		const control = settingControl(item.configPath);
+		if (
+			control?.kind === "number" ||
+			item.configPath === "fleet.concurrency" ||
+			["modelSelector.favorites", "keybindings", "routing.agentAutomation.activeAgentRoles"].includes(item.id)
+		) {
+			if (control) {
+				const replacement = commonControlItem(control, live);
+				const value = getAtPath(settings, control.path);
+				Object.assign(item, replacement, {
+					id: item.id,
+					currentValue: formatControlValue(value),
+					editValue:
+						value == null
+							? ""
+							: control.kind === "list"
+								? (value as string[]).join(", ")
+								: typeof value === "object"
+									? JSON.stringify(value)
+									: String(value),
+				});
+			}
+		}
+	}
+	const paths = new Set(items.map((item) => item.configPath));
+	return [
+		...items,
+		...SETTING_CONTROLS.filter(
+			(control) => !paths.has(control.path) || control.path === "integrations.externalAgents.entries",
+		).map((control) => {
+			const item = commonControlItem(control, live);
+			const value = getAtPath(settings, control.path);
+			item.currentValue = formatControlValue(value);
+			item.editValue =
+				value == null
+					? ""
+					: control.kind === "list"
+						? (value as string[]).join(", ")
+						: typeof value === "object"
+							? JSON.stringify(value)
+							: String(value);
+			return item;
+		}),
+	];
 }
 
 function fleetProfileRows(
@@ -2217,12 +1811,39 @@ function agentBindingRows(settings: Readonly<ClioSettings>, live: () => Readonly
 		});
 }
 
-function targetRows(
+/** One short phrase for a route's breaker, keyed by the model it serves. */
+function routeBreakerPhrase(route: RouteBreakerView): string {
+	switch (route.state) {
+		case "open":
+			return `${route.wireModelId} open ${Math.ceil(route.remainingMs / 1000)}s after ${route.reason}`;
+		case "half-open":
+			return `${route.wireModelId} half-open after ${route.reason}`;
+		case "probing":
+			return `${route.wireModelId} probing after ${route.reason}`;
+		case "closed":
+			return `${route.wireModelId} ${route.consecutiveFailures} failure${route.consecutiveFailures === 1 ? "" : "s"} (${route.reason})`;
+	}
+}
+
+/** The health cell a tripped route takes over: open first, then a probe in flight, then half-open. */
+function routeBreakerSegment(routes: ReadonlyArray<RouteBreakerView>): SettingsValueSegment | null {
+	const open = routes.filter((route) => route.state === "open");
+	if (open.length > 0) {
+		const remainingMs = Math.max(...open.map((route) => route.remainingMs));
+		return { text: `○ open ${Math.ceil(remainingMs / 1000)}s`, tone: "unhealthy" };
+	}
+	if (routes.some((route) => route.state === "probing")) return { text: "◐ probing", tone: "degraded" };
+	if (routes.some((route) => route.state === "half-open")) return { text: "◐ half-open", tone: "degraded" };
+	return null;
+}
+
+export function targetRows(
 	settings: Readonly<ClioSettings>,
 	options: BuildSettingItemsOptions | undefined,
 ): SettingsCenterItem[] {
 	const providers = options?.providers;
 	const statuses = new Map(providers?.list().map((status) => [status.target.id, status] as const) ?? []);
+	const breakers = options?.getRouteBreakers?.() ?? [];
 	return settings.targets.map((target) => {
 		const status = statuses.get(target.id);
 		const roles = [
@@ -2240,7 +1861,9 @@ function targetRows(
 					tone: "activity",
 				}
 			: null;
-		const liveHealth = activitySegment ?? healthSegment;
+		const routes = breakers.filter((route) => route.targetId === target.id);
+		const liveHealth = activitySegment ?? routeBreakerSegment(routes) ?? healthSegment;
+		const breakerText = routes.length > 0 ? ` · Breaker: ${routes.map(routeBreakerPhrase).join("; ")}` : "";
 		const runtime = status?.runtime?.id ?? target.runtime;
 		const latency =
 			status?.health.latencyMs === null || status?.health.latencyMs === undefined ? "—" : `${status.health.latencyMs} ms`;
@@ -2253,11 +1876,11 @@ function targetRows(
 			{ text: `  ${runtime}`, tone: "neutral" as const },
 			{ text: `  ${latency}`, tone: "neutral" as const },
 		];
-		const value = `${health} · ${target.id} · ${roleText} · ${runtime} · ${latency}`;
+		const value = `${health} · ${target.id} · ${roleText} · ${runtime} · ${latency}${breakerText}`;
 		const item = settingItem(`targets.${target.id}`, value, {
 			label: target.id,
 			description: `URL: ${target.url ?? "(none)"} · Default model: ${target.defaultModel ?? "(none)"}`,
-			help: `Last probe: ${lastProbe} · Failure reason: ${failureReason}`,
+			help: `Last probe: ${lastProbe} · Failure reason: ${failureReason}${breakerText}`,
 			submenu: targetActionsSubmenu(target.id, options),
 			affordance: options?.connectTarget ? "Enter: use, connect, probe, remove" : "Enter: use, probe, remove",
 			presentationKind: "status",
@@ -2292,9 +1915,11 @@ function targetHealthSegment(status: TargetHealth["status"]): SettingsValueSegme
 }
 
 /** Read-only placement rows: where dispatched workers run, from the live scheduler snapshot. */
-function fleetNodeRows(nodes: ReadonlyArray<FleetNodeSnapshot>): SettingsCenterItem[] {
+export function fleetNodeRows(nodes: ReadonlyArray<FleetNodeSnapshot>): SettingsCenterItem[] {
 	return nodes.map((node) => {
-		const busy = node.maxWorkers > 0 ? `${node.activeWorkers}/${node.maxWorkers} busy` : `${node.activeWorkers} busy`;
+		const bound =
+			node.capacityBound === null ? null : describeLocalCapacity({ limit: node.maxWorkers, bound: node.capacityBound });
+		const busy = `${node.maxWorkers > 0 ? `${node.activeWorkers}/${node.maxWorkers} busy` : `${node.activeWorkers} busy`}${bound ? ` · ${bound}` : ""}`;
 		return settingItem(`fleet.nodes.${node.id}`, `${node.state} · ${busy}`, {
 			label: `node ${node.id}`,
 			description: `${node.kind} · ${node.host}${node.stateReason ? ` · ${node.stateReason}` : ""}${node.lastSeenAt ? ` · seen ${clockLocal(node.lastSeenAt)}` : ""}`,
@@ -2341,12 +1966,29 @@ function fleetEndpointRows(providers: ProvidersContract | undefined): SettingsCe
 	});
 }
 
-function buildSettingsSections(items: readonly SettingsCenterItem[]): SettingsCenterSection[] {
-	return SETTINGS_SECTIONS.map((section) => ({
-		id: section.id,
-		label: section.label,
-		items: items.filter((item) => item.section === section.id),
-	}));
+export function buildSettingsSections(items: readonly SettingsCenterItem[]): SettingsCenterSection[] {
+	return SETTINGS_SECTIONS.map((section) => {
+		const rows = items.filter(
+			(item) => item.section === section.id && (item.id === "targets" || item.presentationKind !== "group-header"),
+		);
+		if (section.id === "targets") return { id: section.id, label: section.label, items: rows };
+		const groups = new Map<string, SettingsCenterItem[]>();
+		for (const item of rows) {
+			const group = settingsGroupForPath(item.configPath ?? item.id);
+			const entries = groups.get(group) ?? [];
+			entries.push(item);
+			groups.set(group, entries);
+		}
+		return {
+			id: section.id,
+			label: section.label,
+			items: [...groups].flatMap(([label, entries], index) =>
+				label
+					? [groupHeader(`settings.group.${section.id}.${index}`, section.id, label, section.description), ...entries]
+					: entries,
+			),
+		};
+	});
 }
 
 function refreshSettingItemsInPlace(items: SettingsCenterItem[], next: readonly SettingsCenterItem[]): void {
@@ -2422,6 +2064,15 @@ function applyDelegationAgentChange(settings: ClioSettings, value: string): void
 }
 
 function applySettingChange(settings: ClioSettings, id: string, value: string): void {
+	if (
+		id.startsWith("setting.") ||
+		settingControl(settingsV2PathForRow(id))?.kind === "number" ||
+		id === "budget.concurrency" ||
+		["modelSelector.favorites", "keybindings", "routing.agentAutomation.activeAgentRoles"].includes(id)
+	) {
+		applyControlValue(settings, settingsV2PathForRow(id), value);
+		return;
+	}
 	if (applyEntrySettingChange(settings, id, value)) return;
 	switch (id) {
 		case "autonomy":
@@ -2847,7 +2498,9 @@ function changedLeafPaths(before: Readonly<ClioSettings>, after: Readonly<ClioSe
 	const visit = (a: unknown, b: unknown, path: string): void => {
 		if (a === b) return;
 		const profileLeaf = path.startsWith("fleet.profiles.") && path.split(".").length === 3;
-		if (!isRecord(a) || !isRecord(b) || profileLeaf) {
+		// These editable JSON maps contain user keys, including dots; commit the collection atomically.
+		const collectionLeaf = path === "interface.keybindings" || path === "fleet.rosters";
+		if (!isRecord(a) || !isRecord(b) || profileLeaf || collectionLeaf) {
 			if (JSON.stringify(a) !== JSON.stringify(b)) out.push(path);
 			return;
 		}
@@ -2867,7 +2520,7 @@ type DeepReadonly<T> = T extends (...args: never[]) => unknown
 			? { readonly [K in keyof T]: DeepReadonly<T[K]> }
 			: T;
 
-export type SettingsPropagationTiming = "now" | "next-dispatch" | "next-session";
+export type SettingsPropagationTiming = "now" | "next-request" | "next-dispatch" | "next-session";
 
 export interface SettingsChangePlan {
 	readonly rowId: EditableSettingId;
@@ -2909,11 +2562,13 @@ function propagationTiming(
 		return path.startsWith("chat.") ? "now" : "next-dispatch";
 	}
 	if (path.startsWith("fleet.")) return "next-dispatch";
+	if (settingsChangeKind(path) === "nextTurn" && !isRoutingPath(path)) return "next-request";
 	return "now";
 }
 
 function impactFor(propagation: SettingsChangePlan["propagation"]): string {
 	const timings = new Set(propagation.map((entry) => entry.timing));
+	if (timings.has("next-request")) return "takes effect on the next relevant request or explicit open";
 	if (timings.has("now") && timings.has("next-dispatch"))
 		return "takes effect for chat now and fleet routing at the next dispatch";
 	if (timings.has("next-session")) return "takes effect next session";
@@ -2921,17 +2576,18 @@ function impactFor(propagation: SettingsChangePlan["propagation"]): string {
 	return "takes effect now";
 }
 
-function createSettingsChangePlan(
+export function createSettingsChangePlan(
 	settings: Readonly<ClioSettings>,
 	item: Pick<SettingsCenterItem, "id" | "label" | "currentValue" | "scope">,
 	selectedValue: string,
 	sessionDestinationAvailable = true,
 ): SettingsChangePlan | null {
-	if (item.id.startsWith("fleet.group.")) return null;
 	const rowId = item.id as EditableSettingId;
 	const original = structuredClone(settings);
 	const proposed = structuredClone(original);
 	applySettingChange(proposed, rowId, selectedValue);
+	const validation = validateSettings(proposed);
+	if (validation.issues.length) throw new SettingsValidationError(validation.issues);
 	const paths = changedLeafPaths(original, proposed);
 	if (paths.length === 0) return null;
 	const restartRequired = item.scope === "restart";
@@ -3357,7 +3013,8 @@ export class SettingsCenter implements Component {
 		};
 	}
 
-	setSelection(sectionId: SettingsSectionId, rowIndex: number, lane: SettingsCenterLane = "rows"): void {
+	setSelection(sectionName: SettingsSectionName, rowIndex: number, lane: SettingsCenterLane = "rows"): void {
+		const sectionId = resolveSettingsSection(sectionName) ?? SETTINGS_SECTIONS[0].id;
 		if (this.sections().some((section) => section.id === sectionId)) this.selectedSectionId = sectionId;
 		const section = this.currentSection();
 		if (section) this.setRowIndex(section, this.selectableRowIndex(section, rowIndex));
@@ -3685,7 +3342,13 @@ export class SettingsCenter implements Component {
 	}
 
 	private prepareScopeConfirm(item: SettingsCenterItem, value: string): void {
-		const plan = this.options.prepareChange(item, value);
+		let plan: SettingsChangePlan | null;
+		try {
+			plan = this.options.prepareChange(item, value);
+		} catch (error) {
+			this.showChangeError(item, value, error);
+			return;
+		}
 		if (!plan) {
 			this.submenuComponent = null;
 			this.pendingValue = null;
@@ -3695,6 +3358,41 @@ export class SettingsCenter implements Component {
 		this.openScopeConfirm(plan);
 	}
 
+	private showChangeError(item: SettingsCenterItem, value: string, error: unknown): void {
+		const list = new SettingsSelectList(
+			[
+				{ value: "edit", label: "Edit value" },
+				{ value: "cancel", label: "Cancel" },
+			],
+			2,
+			DEFAULT_SELECT_THEME,
+		);
+		list.onSelect = (choice) => {
+			this.submenuComponent = null;
+			if (choice.value === "edit") {
+				if (item.submenu)
+					this.submenuComponent = item.submenu(value, (next) => {
+						this.submenuComponent = null;
+						if (next !== undefined) this.prepareScopeConfirm(item, next);
+						this.options.requestRender?.();
+					});
+				else this.activateSelectedItem();
+			}
+			this.options.requestRender?.();
+		};
+		list.onCancel = () => {
+			this.submenuComponent = null;
+			this.options.requestRender?.();
+		};
+		this.submenuComponent = new SubmenuWrapper(
+			"Change not saved",
+			list,
+			buildHint([{ key: "Enter", verb: "choose" }], "back"),
+			error instanceof Error ? error.message : String(error),
+		);
+		this.options.requestRender?.();
+	}
+
 	/** Hold one immutable plan while the operator chooses its destination. */
 	private openScopeConfirm(plan: SettingsChangePlan): void {
 		const options = plan.sessionCapable
@@ -3709,7 +3407,13 @@ export class SettingsCenter implements Component {
 				];
 		const list = new SettingsSelectList(options, options.length, DEFAULT_SELECT_THEME);
 		const finish = (chosen: "session" | "global" | "cancel"): void => {
-			if (chosen === "session" || chosen === "global") this.options.onApply(plan, chosen);
+			try {
+				if (chosen === "session" || chosen === "global") this.options.onApply(plan, chosen);
+			} catch (error) {
+				const item = this.items.find((entry) => entry.id === plan.rowId);
+				if (item) this.showChangeError(item, plan.selectedValue, error);
+				return;
+			}
 			this.submenuComponent = null;
 			this.pendingValue = null;
 			this.options.requestRender?.();
@@ -3915,13 +3619,7 @@ export class SettingsCenter implements Component {
 		const theme = clioTheme();
 		const filtering = this.effectiveFilterQuery().length > 0;
 		const rows: Array<{ line: string; sectionId: SettingsSectionId | null }> = [];
-		let previousGroup: string | null = null;
 		for (const section of this.sections()) {
-			const group = SETTINGS_SECTIONS.find((entry) => entry.id === section.id)?.group;
-			if (group && group !== previousGroup) {
-				rows.push({ line: theme.style("accentDeep", group, { bold: true }), sectionId: null });
-				previousGroup = group;
-			}
 			const selected = section.id === this.selectedSectionId;
 			const cursor = selected && this.level === "sections" ? theme.fg("accent", `${GLYPH.cursor} `) : "  ";
 			const matchCount = section.items.filter((item) => this.isSelectableRow(item)).length;
@@ -4124,6 +3822,7 @@ export class SettingsCenter implements Component {
 	}
 
 	private footerScopeNote(item: SettingsCenterItem): string {
+		if (item.id.startsWith("maintenance.")) return `Run in a terminal: ${item.currentValue}`;
 		if (item.id === "targets.add-cta") return "Run the command shown to open the accepted add wizard";
 		if (item.submenu && (item.presentationKind === "status" || item.presentationKind === "action"))
 			return "Enter opens actions · nothing changes until an action is confirmed";
@@ -4184,10 +3883,11 @@ export interface OpenSettingsOverlayDeps {
 	notice?: (level: SettingsNoticeLevel, text: string, key?: string) => void;
 	onClose: () => void;
 	/** Open focused on this section (deep link from `/settings <section>`). */
-	section?: SettingsSectionId;
+	section?: SettingsSectionName;
 	/** Optional semantic row anchor for command deep links. */
 	rowId?: SettingsCenterRowId;
 	getFleetNodes?: BuildSettingItemsOptions["getFleetNodes"];
+	getRouteBreakers?: BuildSettingItemsOptions["getRouteBreakers"];
 	connectTarget?: BuildSettingItemsOptions["connectTarget"];
 	getInteropProposals?: BuildSettingItemsOptions["getInteropProposals"];
 }
@@ -4229,6 +3929,7 @@ export function openSettingsOverlay(tui: TUI, deps: OpenSettingsOverlayDeps): Se
 	};
 	if (deps.providers) buildOptions.providers = deps.providers;
 	if (deps.getFleetNodes) buildOptions.getFleetNodes = deps.getFleetNodes;
+	if (deps.getRouteBreakers) buildOptions.getRouteBreakers = deps.getRouteBreakers;
 	if (deps.connectTarget) buildOptions.connectTarget = deps.connectTarget;
 	if (deps.getInteropProposals) buildOptions.getInteropProposals = deps.getInteropProposals;
 	const items = buildSettingItems(deps.getSettings(), buildOptions);
@@ -4247,7 +3948,9 @@ export function openSettingsOverlay(tui: TUI, deps: OpenSettingsOverlayDeps): Se
 		requestRender: () => tui.requestRender(),
 	});
 	if (deps.section) {
-		const sectionItems = buildSettingsSections(items).find((section) => section.id === deps.section)?.items ?? [];
+		const sectionItems =
+			buildSettingsSections(items).find((section) => section.id === resolveSettingsSection(deps.section ?? ""))?.items ??
+			[];
 		const rowIndex = deps.rowId ? sectionItems.findIndex((item) => item.id === deps.rowId) : -1;
 		center.setSelection(deps.section, rowIndex >= 0 ? rowIndex : 0);
 	}