@iowarp/clio-coder 0.3.9 → 0.4.1

package/src/interactive/overlays/settings.ts

@@ -3,10 +3,19 @@ import {
 	type ClioSettings,
 	removeFleetProfileFromSettings,
 	removeTargetFromSettings,
+	SETTINGS_V1_PATH_MOVES,
 	setFleetProfileInSettings,
 	useTargetInSettings,
 } from "../../core/config.js";
-import { DEFAULT_SETTINGS, THINKING_LEVELS } from "../../core/defaults.js";
+import {
+	ACTIVE_ROUTING_POSTURES,
+	ACTIVE_ROUTING_ROLES,
+	type ActiveRoutingPosture,
+	type ActiveRoutingRole,
+	DEFAULT_SETTINGS,
+	THINKING_LEVELS,
+	type WorkerEscalationSettings,
+} 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";
@@ -48,14 +57,15 @@ import { clockLocal } from "../format-time.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%";
 export const SETTINGS_OVERLAY_MARGIN = {
 	top: 1,
-	right: 2,
+	right: 0,
 	bottom: 1,
-	left: 2,
+	left: 0,
 } as const;
 
 const SECTION_LANE_WIDTH = 24;
@@ -80,19 +90,19 @@ const ULTRAWIDE_LAYOUT_MIN_WIDTH = 112;
  */
 const WIDE_LAYOUT_MIN_WIDTH = 72;
 const DROP_PATH_COLUMN_WIDTH = 52;
-/**
- * Terminal width below which Settings drops its two-cell side margins.
- *
- * The engine composites an overlay only across the columns its region covers,
- * and a left/right margin shrinks that region, so at 40 columns four of them
- * kept showing the transcript beside a modal that owns the keyboard. Above this
- * width the margins are cheap and the box reads better inset; below it the
- * overlay claims every terminal column instead.
- */
-const ULTRA_NARROW_TERMINAL_WIDTH = 60;
 /** Shown when no runtime is resolvable, so it offers the full vocabulary. */
 const FALLBACK_THINKING_VALUES: ReadonlyArray<string> = THINKING_LEVELS;
 const ROW_GAP = "  ";
+/**
+ * `workers.escalation` and `workers.resilienceCooldownMs` are optional keys, so
+ * the row that shows them and the mutation that writes them both need a
+ * definite shipped value to fall back to.
+ */
+const SHIPPED_ESCALATION: WorkerEscalationSettings = DEFAULT_SETTINGS.fleet.permissions.escalation ?? {
+	timeoutMs: 120_000,
+	fallback: "deny",
+};
+const SHIPPED_RESILIENCE_COOLDOWN_MS = DEFAULT_SETTINGS.fleet.retry.routeCooldownMs ?? 15_000;
 /**
  * The product's cut marker, as the help center and every list overlay use it.
  *
@@ -126,36 +136,27 @@ const RESTART_REQUIRED_IDS = new Set<string>([
 	"runtimePlugins",
 	"terminal.tuiMode",
 	"terminal.fullscreenScrollbar",
+	// The mux domain runs its detection ladder once, at boot, from the value this
+	// key held then. Changing the rung mid-session would leave the contract on
+	// the rung it resolved to, so the row says restart rather than lying.
+	"panes.enabled",
 ]);
 
-export const SETTINGS_SECTIONS = [
-	{ id: "safety", label: "Autonomy & Safety", group: "CORE" },
-	{ id: "orchestrator", label: "Orchestrator", group: "CORE" },
-	{ id: "fleet", label: "Fleet", group: "ROUTING" },
-	{ id: "targets", label: "Targets", group: "ROUTING" },
-	{ id: "models", label: "Models", group: "ROUTING" },
-	{ id: "budget", label: "Budget", group: "RUNTIME" },
-	{ id: "compaction", label: "Compaction", group: "RUNTIME" },
-	{ id: "retry", label: "Retry", group: "RUNTIME" },
-	{ id: "terminal", label: "Terminal", group: "EXPERIENCE" },
-	{ id: "watchdog", label: "Watchdog", group: "EXPERIENCE" },
-	{ id: "advanced", label: "Advanced", group: "EXPERIENCE" },
-] as const;
-
-export type SettingsSectionId = (typeof SETTINGS_SECTIONS)[number]["id"];
+export { SETTINGS_SECTIONS, type SettingsSectionId };
 
 const SETTINGS_SECTION_DESCRIPTIONS = {
-	safety: "How freely Clio acts, and how delegated agents' tools are governed.",
-	orchestrator: "Interactive chat routing and the optional proactive-memory model plane.",
-	fleet: "Defaults, profiles, and agent bindings applied to dispatched workers, and where they run.",
+	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 Alt+J / Alt+K cycling.",
-	budget: "Cost ceiling, per-turn output budget, and worker concurrency.",
-	compaction: "When and how the context window is summarized under pressure.",
-	retry: "Automatic recovery from transient provider and network errors.",
+	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, and links to other surfaces.",
+	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 = {
@@ -165,6 +166,8 @@ export const SETTINGS_LABELS_BY_ID = {
 	// 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",
@@ -174,31 +177,56 @@ export const SETTINGS_LABELS_BY_ID = {
 	"orchestrator.model": "Model",
 	"background.target": "Memory target",
 	"background.model": "Memory model",
-	"background.thinkingLevel": "Memory thinking level",
 	"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": "Yazi 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)",
 	"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.excludeLastTurns": "Protected recent turns",
 	"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)",
 	"terminal.showTerminalProgress": "Terminal progress badges",
 	"terminal.outputVerbosity": "Output detail",
 	"terminal.tuiMode": "TUI mode",
@@ -208,7 +236,6 @@ export const SETTINGS_LABELS_BY_ID = {
 	"watchdog.enabled": "Turn-end watchdog",
 	"watchdog.target": "Watchdog target",
 	"watchdog.cadenceToolCalls": "Watchdog cadence (tools)",
-	theme: "Theme",
 	runtimePlugins: "Runtime plugins",
 	"compaction.model": "Compaction model",
 	"compaction.systemPrompt": "Compaction prompt",
@@ -218,6 +245,10 @@ export const SETTINGS_LABELS_BY_ID = {
 	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;
 
 /**
@@ -231,9 +262,20 @@ type EntrySettingId =
 	| `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 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 TargetsCtaId = "targets.add-cta";
-export type SettingsCenterRowId = EditableSettingId | FleetGroupHeaderId | TargetsCtaId;
+export type SettingsCenterRowId = EditableSettingId | GroupHeaderId | TargetsCtaId;
 const REMOVE_PROFILE_CHOICE = "(remove profile)";
 const UNBIND_CHOICE = "(unbind)";
 const AUTO_PLACEMENT_CHOICE = "(auto placement)";
@@ -244,6 +286,8 @@ export const SETTINGS_SECTION_ROWS = {
 	safety: [
 		"autonomy",
 		"workers.onPermission",
+		"workers.escalation.timeoutMs",
+		"workers.escalation.fallback",
 		"delegation.defaults.toolGovernance",
 		"skills.trustProjectCompatRoots",
 		"safetyNet",
@@ -254,25 +298,52 @@ export const SETTINGS_SECTION_ROWS = {
 		"orchestrator.model",
 		"background.target",
 		"background.model",
-		"background.thinkingLevel",
 		"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", "budget.concurrency"],
-	compaction: ["compaction.auto", "compaction.threshold", "compaction.excludeLastTurns"],
-	retry: ["retry.enabled", "retry.maxRetries", "retry.baseDelayMs", "retry.maxDelayMs"],
+	budget: [
+		"budget.sessionCeilingUsd",
+		"defaults.maxTokens",
+		"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"],
 	terminal: [
 		"terminal.showTerminalProgress",
 		"terminal.outputVerbosity",
@@ -280,7 +351,11 @@ export const SETTINGS_SECTION_ROWS = {
 		"terminal.fullscreenScrollbar",
 		"terminal.smoothStreaming",
 		"terminal.notify",
-		"theme",
+		"panes.yazi.enabled",
+		"panes.yazi.mode",
+		"panes.yazi.profile",
+		"panes.yazi.followCwd",
+		"panes.yazi.ratio",
 	],
 	watchdog: ["watchdog.enabled", "watchdog.target", "watchdog.cadenceToolCalls"],
 	advanced: [
@@ -293,6 +368,10 @@ export const SETTINGS_SECTION_ROWS = {
 		"delegation.defaults.permissionTimeoutMs",
 		"keybindings",
 		"delegation.agents",
+		"library.catalog",
+		"library.remote",
+		"library.confirmedRemote",
+		"library.sync",
 	],
 	targets: ["targets"],
 } as const satisfies Record<SettingsSectionId, readonly EditableSettingId[]>;
@@ -301,6 +380,8 @@ 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":
@@ -311,31 +392,58 @@ const SETTINGS_DESCRIPTIONS_BY_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.",
-	"background.thinkingLevel": "Unused: memory steps always request thinking off.",
 	"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 `/panes open yazi` may open the files pane or one-shot chooser.",
+	"panes.yazi.mode": "Keep Yazi beside the conversation, or close it after one selection.",
+	"panes.yazi.profile": "Use Clio's managed pick profile or leave the operator's Yazi profile untouched.",
+	"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: "Alt+J and Alt+K model cycle 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.",
 	"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.excludeLastTurns": "Recent user turns protected from observation masking.",
 	"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.",
 	"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.",
@@ -346,7 +454,6 @@ const SETTINGS_DESCRIPTIONS_BY_ID = {
 	"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.",
-	theme: "Color palette. Clio ships a single tuned palette.",
 	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.",
@@ -356,6 +463,10 @@ const SETTINGS_DESCRIPTIONS_BY_ID = {
 	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. */
@@ -366,6 +477,37 @@ const SETTINGS_HELP_BY_ID: Partial<Record<EditableSettingId, string>> = {
 		"Clamped down to each model's max-output cap and the remaining context window. Set 0 to use per-model caps only.",
 	"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. Env override CLIO_CODER_TURN_TOOL_CALL_BUDGET beats this value.",
+	"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. Env override CLIO_CODER_WORKER_TOOL_CALL_CAP beats this value.",
+	"guardrails.maxDispatchRuns":
+		"Runs leaving the ring also lose their event journal directory. Whole number of at least 1 · default: 1000. Env override CLIO_CODER_MAX_DISPATCH_RUNS beats this value.",
+	"guardrails.readMaxBytes":
+		"Clamped up to a 1KB floor at use. Whole number of bytes, at least 1 · default: 51200 (50KB). Env override CLIO_CODER_READ_MAX_BYTES beats this value.",
+	"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). Env override CLIO_CODER_OBSERVATION_TURN_BUDGET_BYTES beats this value.",
+	"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). Env override CLIO_CODER_INTERNAL_DISPATCH_TIMEOUT_MS beats this value.",
+	"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).",
+	"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 sizes to your machine. A fixed number caps how many workers run at once.",
 	"skills.trustProjectCompatRoots":
 		"Project roots like .claude/skills and .codex/skills are untrusted by default; enabling exposes them to the model.",
@@ -373,10 +515,24 @@ const SETTINGS_HELP_BY_ID: Partial<Record<EditableSettingId, string>> = {
 		"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-policy gates the agent through Clio's safety net; agent-managed trusts the agent; deny-all blocks every tool.",
+		"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. Alt+J / Alt+K step the chat target through this list.",
 	runtimePlugins: "Comma-separated package names, loaded at startup. Restart Clio after changing.",
 	"terminal.notify":
@@ -408,8 +564,28 @@ const SETTINGS_VALUE_HELP_BY_ID: Partial<Record<EditableSettingId, Record<string
 		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-policy": "Clio's safety policy gates the delegated agent's tools",
+		"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",
 	},
@@ -417,6 +593,16 @@ const SETTINGS_VALUE_HELP_BY_ID: Partial<Record<EditableSettingId, Record<string
 		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, and a row
+	// that offered it beside two working values read as a third working value.
+	// It stays selectable, because refusing it outright would break a settings
+	// file that names it, but nothing here lets an operator pick it believing
+	// they will get panes.
+	"panes.enabled": {
+		auto: "detect a herdr session and join it as a guest; no pane host, no panes",
+		embedded: "NOT IMPLEMENTED (ships in phase 5): this session gets no panes at all, guest mode included",
+		off: "never detect or open a pane",
+	},
 	"retry.enabled": {
 		true: "retry transient provider errors automatically",
 		false: "surface transient errors immediately without retrying",
@@ -491,7 +677,7 @@ export interface SettingsCenterItem extends SettingItem {
 	label: string;
 	description: string;
 	section: SettingsSectionId;
-	configPath: SettingsCenterRowId;
+	configPath: string;
 	affordance: string;
 	scope: SettingScope;
 	readOnly: boolean;
@@ -589,7 +775,7 @@ function delegationAgentsAffordance(
 		submenu: selectListSubmenu(
 			"Delegation agents",
 			choices,
-			"An added peer runs under clio-policy governance and inherits projectContext: none.",
+			"An added peer runs under clio-coder-policy governance and inherits projectContext: none.",
 		),
 	};
 }
@@ -733,6 +919,19 @@ const NUMBER_SETTING_RULES = {
 	"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 },
+	// The escalation deadline is armed as a timer, so it shares the delegation
+	// bounds; the rest mirror the config validator's own integer bounds.
+	"workers.escalation.timeoutMs": { min: 1, max: MAX_TIMER_DELAY_MS, integer: true },
+	"workers.resilienceCooldownMs": { min: 0, integer: true },
+	"guardrails.turnToolCallBudget": { min: 1, integer: true },
+	"guardrails.workerToolCallCap": { min: 1, integer: true },
+	"guardrails.maxDispatchRuns": { min: 1, integer: true },
+	"guardrails.readMaxBytes": { min: 1, integer: true },
+	"guardrails.observationTurnBudgetBytes": { min: 1, integer: true },
+	"guardrails.internalDispatchTimeoutMs": { min: 1, integer: true },
+	// The config validator's bounds for both dock shares; half the axis is the cap.
+	"panes.workers.ratio": { min: 0.05, max: 0.5, integer: false },
+	"panes.yazi.ratio": { min: 0.05, max: 0.5, integer: false },
 } as const satisfies Partial<Record<EditableSettingId, NumberSettingRule>>;
 
 export type NumberSettingId = keyof typeof NUMBER_SETTING_RULES;
@@ -768,16 +967,6 @@ function parseNumberSetting(value: string, rule: NumberSettingRule): NumberSetti
 	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" : "";
@@ -818,6 +1007,51 @@ function editNumberSubmenu(title: string, id: NumberSettingId): SettingSubmenuBu
 	};
 }
 
+/**
+ * The comma-separated set an activation list holds, refused in place when an
+ * entry is not one of the legal values. Silently dropping the unknown entry
+ * would leave the operator looking at a list they thought they had activated,
+ * so the editor stays open and names both the entry and the vocabulary.
+ */
+function parseEnumListSetting(value: string, legal: readonly string[]): { values: string[] } | { refusal: string } {
+	const entries = value
+		.split(",")
+		.map((entry) => entry.trim())
+		.filter((entry) => entry.length > 0);
+	const unknown = entries.find((entry) => !legal.includes(entry));
+	if (unknown !== undefined) {
+		return { refusal: `Not applied: '${unknown}' is not one of ${legal.join(", ")}.` };
+	}
+	const duplicate = entries.find((entry, index) => entries.indexOf(entry) !== index);
+	if (duplicate !== undefined) return { refusal: `Not applied: '${duplicate}' is listed twice.` };
+	return { values: entries };
+}
+
+function editEnumListSubmenu(title: string, legal: readonly string[]): SettingSubmenuBuilder {
+	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"),
+			`Comma-separated, from ${legal.join(", ")}; blank activates none.`,
+		);
+		input.onSubmit = (val) => {
+			const outcome = parseEnumListSetting(val, legal);
+			if ("refusal" in outcome) {
+				wrapper.setProblem(outcome.refusal);
+				return;
+			}
+			wrapper.setProblem(null);
+			done(outcome.values.join(", "));
+		};
+		input.onEscape = () => done();
+		return wrapper;
+	};
+}
+
 function selectListSubmenu(
 	title: string,
 	items: ReadonlyArray<{
@@ -1126,7 +1360,7 @@ function profileTargetChoices(
 }
 
 function profileNameChoices(live: () => Readonly<ClioSettings>): Array<{ value: string; label: string }> {
-	const names = Object.keys(live().workers.profiles).sort();
+	const names = Object.keys(live().fleet.profiles).sort();
 	return names.map((name) => ({ value: name, label: name }));
 }
 
@@ -1240,13 +1474,45 @@ function scopeForId(id: EditableSettingId): SettingScope {
 
 /** Shipped default as a display string, for the "default: X" hint and the modified marker. */
 function defaultValueFor(id: EditableSettingId): string | undefined {
-	if (isRoutingPath(id)) return undefined;
-	const raw = getAtPath(DEFAULT_SETTINGS, id);
+	const path = settingsV2PathForRow(id);
+	if (isRoutingPath(path)) return undefined;
+	const raw = getAtPath(DEFAULT_SETTINGS, path);
 	if (raw === null || raw === undefined || typeof raw === "object") return undefined;
 	if (id === "attribution.gitCommits") return raw === true ? "enabled" : "disabled";
 	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;
+}
+
 function settingItem(
 	id: EditableSettingId,
 	currentValue: string,
@@ -1269,7 +1535,7 @@ function settingItem(
 		currentValue,
 		description: options.description ?? SETTINGS_DESCRIPTIONS_BY_ID[id as keyof typeof SETTINGS_LABELS_BY_ID],
 		section: sectionForSetting(id),
-		configPath: id,
+		configPath: settingsV2PathForRow(id),
 		affordance: options.affordance ?? (options.values ? cycleAffordance(options.values) : "opens picker"),
 		scope: scopeForId(id),
 		readOnly: options.readOnly ?? false,
@@ -1288,13 +1554,23 @@ function settingItem(
 	return item;
 }
 
-function fleetGroupHeader(id: FleetGroupHeaderId, label: string): SettingsCenterItem {
+/**
+ * A heading row that names the block of settings under it. The id carries the
+ * section it belongs to, so one builder serves every section that groups its
+ * rows rather than a near-duplicate per section.
+ */
+function groupHeader(
+	id: GroupHeaderId,
+	section: SettingsSectionId,
+	label: string,
+	description: string,
+): SettingsCenterItem {
 	return {
 		id,
 		label,
 		currentValue: "",
-		description: `${label} in the Fleet workbench.`,
-		section: "fleet",
+		description,
+		section,
 		configPath: id,
 		affordance: "group heading",
 		scope: "live",
@@ -1304,6 +1580,14 @@ function fleetGroupHeader(id: FleetGroupHeaderId, label: string): SettingsCenter
 	};
 }
 
+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",
@@ -1324,7 +1608,7 @@ function thinkingChoices(
 	providers: ProvidersContract | undefined,
 	target: string | null,
 	model: string | null,
-	level: ClioSettings["orchestrator"]["thinkingLevel"],
+	level: ClioSettings["chat"]["thinkingLevel"],
 ): { display: string; values: readonly string[] } {
 	const resolved = providers
 		? resolveModelRuntimeCapabilitiesForProviders(providers, target, model, level ?? "off")?.thinking
@@ -1341,36 +1625,28 @@ function thinkingChoices(
  * read-only pointer rows (targets, keybindings, favorites, safety net) name the
  * surface that owns them so the Center has no dead-but-tappable rows.
  */
-export function buildSettingItems(
-	settings: Readonly<ClioSettings>,
-	options?: BuildSettingItemsOptions,
-): SettingsCenterItem[] {
+function buildSettingItems(settings: Readonly<ClioSettings>, options?: BuildSettingItemsOptions): SettingsCenterItem[] {
 	const live = options?.getSettings ?? ((): Readonly<ClioSettings> => settings);
-	const scopeList = settings.scope ?? [];
+	const scopeList = settings.chat.modelPicker.cycleSet ?? [];
 	const scopeText = scopeList.length > 0 ? scopeList.join(", ") : "(empty)";
-	const compaction = settings.compaction;
-	const retry = settings.retry;
-	const terminal = settings.terminal;
-	const watchdog = settings.watchdog;
+	const compaction = settings.context.compaction;
+	const retry = settings.chat.retry;
+	const terminal = settings.interface;
+	const watchdog = settings.safety.review;
+	const panes = settings.interface.panes;
 	const orchestratorThinking = thinkingChoices(
 		options?.providers,
-		settings.orchestrator.target,
-		settings.orchestrator.model,
-		settings.orchestrator.thinkingLevel,
+		settings.chat.target,
+		settings.chat.model,
+		settings.chat.thinkingLevel,
 	);
 	const workerThinking = thinkingChoices(
 		options?.providers,
-		settings.workers.default.target,
-		settings.workers.default.model,
-		settings.workers.default.thinkingLevel,
+		settings.fleet.default.target,
+		settings.fleet.default.model,
+		settings.fleet.default.thinkingLevel,
 	);
-	const backgroundThinking = thinkingChoices(
-		options?.providers,
-		settings.background.target,
-		settings.background.model,
-		settings.background.thinkingLevel,
-	);
-	const profileCount = Object.keys(settings.workers.profiles ?? {}).length;
+	const profileCount = Object.keys(settings.fleet.profiles ?? {}).length;
 	const addProfileSubmenu = chainSubmenus(
 		textInputSubmenu("New profile name"),
 		() => selectListSubmenu("Select the profile's target", profileTargetChoices(live, options?.providers)),
@@ -1383,31 +1659,48 @@ export function buildSettingItems(
 	);
 	const targetSubmenu = options?.providers ? selectTargetSubmenu(options.providers) : editTextSubmenu("Type target id");
 	const orchestratorModelSubmenu = options?.providers
-		? selectModelSubmenu(options.providers, () => live().orchestrator.target ?? undefined)
+		? selectModelSubmenu(options.providers, () => live().chat.target ?? undefined)
 		: editTextSubmenu("Type model name");
 	const workerModelSubmenu = options?.providers
-		? selectModelSubmenu(options.providers, () => live().workers.default.target ?? undefined)
+		? selectModelSubmenu(options.providers, () => live().fleet.default.target ?? undefined)
 		: editTextSubmenu("Type model name");
 	const backgroundTargetSubmenu = options?.providers
 		? selectOptionalBackgroundTargetSubmenu(options.providers)
 		: editTextSubmenu("Type memory target id", "Leave blank for rules-only memory.");
 	const backgroundModelSubmenu = options?.providers
-		? selectModelSubmenu(options.providers, () => live().background.target ?? undefined)
+		? selectModelSubmenu(options.providers, () => live().context.memory.target ?? undefined)
 		: editTextSubmenu("Type memory model name");
-	const favorites = settings.modelSelector?.favorites ?? [];
-	const agents = settings.delegation?.agents ?? [];
-	const keybindingCount = Object.keys(settings.keybindings ?? {}).length;
+	// Both are optional in the settings type, so the row falls back to the
+	// shipped value rather than rendering a blank for a key that is in force.
+	const escalation = settings.fleet.permissions.escalation ?? SHIPPED_ESCALATION;
+	const resilienceCooldownMs = settings.fleet.retry.routeCooldownMs ?? SHIPPED_RESILIENCE_COOLDOWN_MS;
+	const workingSet = settings.context.workingSet;
+	const safetyLimits = settings.safety.limits;
+	const fleetLimits = settings.fleet.limits;
+	const routing = settings.fleet.adaptiveRouting;
+	const library = settings.integrations.library;
+	const activeAgentRoles = routing.agentRoles;
+	const favorites = settings.chat.modelPicker?.favorites ?? [];
+	const agents = settings.integrations.externalAgents?.entries ?? [];
+	const keybindingCount = Object.keys(settings.interface.keybindings ?? {}).length;
 	return [
-		settingItem("autonomy", settings.autonomy, {
+		settingItem("autonomy", settings.safety.autonomy, {
 			values: ["read-only", "suggest", "auto-edit", "full-auto"],
 		}),
-		settingItem("workers.onPermission", settings.workers.onPermission ?? "deny", {
+		settingItem("workers.onPermission", settings.fleet.permissions.mode ?? "deny", {
 			values: ["deny", "fail", "escalate"],
 		}),
-		settingItem("delegation.defaults.toolGovernance", settings.delegation.defaults.toolGovernance, {
-			values: ["clio-policy", "agent-managed", "deny-all"],
+		settingItem("workers.escalation.timeoutMs", String(escalation.timeoutMs), {
+			submenu: editNumberSubmenu("Edit escalation timeout (ms)", "workers.escalation.timeoutMs"),
+			affordance: "free text",
+		}),
+		settingItem("workers.escalation.fallback", escalation.fallback, {
+			values: ["deny", "fail"],
+		}),
+		settingItem("delegation.defaults.toolGovernance", settings.integrations.externalAgents.defaults.toolGovernance, {
+			values: ["clio-coder-policy", "agent-managed", "deny-all"],
 		}),
-		settingItem("skills.trustProjectCompatRoots", String(settings.skills.trustProjectCompatRoots), {
+		settingItem("skills.trustProjectCompatRoots", String(settings.integrations.projectResources.trustProjectImports), {
 			values: ["false", "true"],
 		}),
 		settingItem("safetyNet", "always on", {
@@ -1417,55 +1710,59 @@ export function buildSettingItems(
 		settingItem("orchestrator.thinkingLevel", orchestratorThinking.display, {
 			values: orchestratorThinking.values,
 		}),
-		settingItem("orchestrator.target", settings.orchestrator.target ?? "(unset)", {
+		settingItem("orchestrator.target", settings.chat.target ?? "(unset)", {
 			submenu: targetSubmenu,
 			affordance: options?.providers ? "opens picker" : "free text",
 		}),
-		settingItem("orchestrator.model", settings.orchestrator.model ?? "(unset)", {
+		settingItem("orchestrator.model", settings.chat.model ?? "(unset)", {
 			submenu: orchestratorModelSubmenu,
 			affordance: options?.providers ? "opens picker" : "free text",
 		}),
-		settingItem("background.target", settings.background.target ?? "(unset — rules-only)", {
+		settingItem("background.target", settings.context.memory.target ?? "(unset — rules-only)", {
 			submenu: backgroundTargetSubmenu,
 			affordance: options?.providers ? "opens picker" : "free text",
 		}),
-		settingItem("background.model", settings.background.model ?? "(unset)", {
+		settingItem("background.model", settings.context.memory.model ?? "(unset)", {
 			submenu: backgroundModelSubmenu,
 			affordance: options?.providers ? "opens picker" : "free text",
 		}),
-		settingItem("background.thinkingLevel", backgroundThinking.display, {
-			values: backgroundThinking.values,
-		}),
-		settingItem("memory.intervention.enabled", String(settings.memory.intervention.enabled), {
+		settingItem("memory.intervention.enabled", String(settings.context.memory.enabled), {
 			values: ["true", "false"],
 		}),
-		settingItem("memory.intervention.everyNTools", String(settings.memory.intervention.everyNTools), {
+		settingItem("memory.intervention.everyNTools", String(settings.context.memory.cadenceToolCalls), {
 			values: ["5", "10", "20", "30"],
 		}),
-		settingItem("memory.intervention.windowSteps", String(settings.memory.intervention.windowSteps), {
+		settingItem("memory.intervention.windowSteps", String(settings.context.memory.trajectorySteps), {
 			values: ["4", "8", "12", "20"],
 		}),
-		settingItem("memory.intervention.maxTokens", String(settings.memory.intervention.maxTokens), {
+		settingItem("memory.intervention.maxTokens", String(settings.context.memory.maxOutputTokens), {
 			values: ["100", "200", "400", "800"],
 		}),
-		settingItem("memory.intervention.timeoutMs", String(settings.memory.intervention.timeoutMs), {
+		settingItem("memory.intervention.timeoutMs", String(settings.context.memory.timeoutMs), {
 			values: ["5000", "10000", "20000", "30000", "60000"],
 		}),
+		settingItem("prewarm.enabled", String(settings.chat.prewarm), {
+			values: ["true", "false"],
+		}),
 		fleetGroupHeader("fleet.group.defaults", "Defaults"),
-		settingItem("workers.default.target", settings.workers.default.target ?? "(unset)", {
+		settingItem("workers.default.target", settings.fleet.default.target ?? "(unset)", {
 			submenu: targetSubmenu,
 			affordance: options?.providers ? "opens picker" : "free text",
 		}),
-		settingItem("workers.default.model", settings.workers.default.model ?? "(unset)", {
+		settingItem("workers.default.model", settings.fleet.default.model ?? "(unset)", {
 			submenu: workerModelSubmenu,
 			affordance: options?.providers ? "opens picker" : "free text",
 		}),
 		settingItem("workers.default.thinkingLevel", workerThinking.display, {
 			values: workerThinking.values,
 		}),
-		settingItem("workers.maxRetries", String(settings.workers.maxRetries), {
+		settingItem("workers.maxRetries", String(settings.fleet.retry.maxRetries), {
 			values: ["0", "1", "2", "3", "5", "8"],
 		}),
+		settingItem("workers.resilienceCooldownMs", String(resilienceCooldownMs), {
+			submenu: editNumberSubmenu("Edit resilience cooldown (ms)", "workers.resilienceCooldownMs"),
+			affordance: "free text",
+		}),
 		fleetGroupHeader("fleet.group.profiles", "Profiles"),
 		...fleetProfileRows(settings, live, options),
 		settingItem("workers.profiles", "", {
@@ -1484,9 +1781,36 @@ export function buildSettingItems(
 			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(", ")}`,
+			editValue: routing.roles.join(", "),
+		}),
+		settingItem("routing.activePostures", routing.postures.length > 0 ? routing.postures.join(", ") : "(none)", {
+			submenu: editEnumListSubmenu("Edit active routing postures", ACTIVE_ROUTING_POSTURES),
+			affordance: `free text from ${ACTIVE_ROUTING_POSTURES.join(", ")}`,
+			editValue: routing.postures.join(", "),
+		}),
+		settingItem(
+			"routing.agentAutomation.activeAgentRoles",
+			activeAgentRoles.length > 0
+				? activeAgentRoles.map((pair) => `${pair.agentId}/${pair.executionRole}`).join(", ")
+				: "(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.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"), {
+			submenu: editNumberSubmenu("Edit workers dock share (0.05–0.5)", "panes.workers.ratio"),
+			affordance: "free text",
+		}),
+		settingItem("panes.journal", String(settings.fleet.history.journal), { values: ["true", "false"] }),
 		settingItem("targets", "", {
 			description: "Live inference target inventory and routing roles.",
 			affordance: "column heading",
@@ -1500,32 +1824,80 @@ export function buildSettingItems(
 			submenu: scopedModelsSubmenu(scopeList, options?.providers),
 			affordance: "opens provider-backed checklist",
 		}),
-		settingItem("modelSelector.recentLimit", String(settings.modelSelector.recentLimit), {
+		settingItem("modelSelector.recentLimit", String(settings.chat.modelPicker.recentLimit), {
 			values: ["6", "12", "20", "50"],
 		}),
 		settingItem("modelSelector.favorites", favorites.length > 0 ? `${favorites.length} pinned` : "(none)", {
 			affordance: "manage in /model",
 			readOnly: true,
 		}),
-		settingItem("budget.sessionCeilingUsd", String(settings.budget.sessionCeilingUsd), {
+		settingItem("budget.sessionCeilingUsd", String(settings.safety.limits.sessionCostUsd), {
 			submenu: editNumberSubmenu("Edit session cost ceiling USD", "budget.sessionCeilingUsd"),
 			affordance: "free text",
 		}),
-		settingItem("defaults.maxTokens", String(settings.defaults.maxTokens), {
+		settingItem("defaults.maxTokens", String(settings.chat.maxOutputTokens), {
 			values: ["0", "4096", "8192", "16384", "32768", "65536", "131072"],
 		}),
-		settingItem("budget.concurrency", String(settings.budget.concurrency), {
+		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",
+		}),
+		settingItem("guardrails.workerToolCallCap", String(fleetLimits.toolCallsPerRun), {
+			submenu: editNumberSubmenu("Edit worker tool-call cap", "guardrails.workerToolCallCap"),
+			affordance: "free text",
+		}),
+		settingItem("guardrails.maxDispatchRuns", String(settings.fleet.history.maxRuns), {
+			submenu: editNumberSubmenu("Edit run ledger retention", "guardrails.maxDispatchRuns"),
+			affordance: "free text",
+		}),
+		settingItem("guardrails.readMaxBytes", String(safetyLimits.readBytesPerCall), {
+			submenu: editNumberSubmenu("Edit read byte cap", "guardrails.readMaxBytes"),
+			affordance: "free text",
+		}),
+		settingItem("guardrails.observationTurnBudgetBytes", String(safetyLimits.observationBytesPerTurn), {
+			submenu: editNumberSubmenu("Edit observation byte pool", "guardrails.observationTurnBudgetBytes"),
+			affordance: "free text",
+		}),
+		settingItem("guardrails.internalDispatchTimeoutMs", String(fleetLimits.internalRunTimeoutMs), {
+			submenu: editNumberSubmenu("Edit internal dispatch timeout (ms)", "guardrails.internalDispatchTimeoutMs"),
+			affordance: "free text",
+		}),
 		settingItem("compaction.auto", String(compaction.auto), {
 			values: ["true", "false"],
 		}),
 		settingItem("compaction.threshold", formatThreshold(compaction.threshold), {
 			values: ["0.7", "0.8", "0.85", "0.9"],
 		}),
-		settingItem("compaction.excludeLastTurns", String(compaction.excludeLastTurns), {
+		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"],
+		}),
+		settingItem("context.workingSet.policy", workingSet.policy, {
+			values: ["structural-v1", "age-horizon"],
+		}),
+		settingItem("context.workingSet.target", formatThreshold(workingSet.target, "0.6"), {
+			values: ["0.4", "0.5", "0.6", "0.7"],
+		}),
+		settingItem("context.workingSet.protectLastTurns", String(workingSet.protectLastTurns), {
 			values: ["3", "6", "10", "15"],
 		}),
+		settingItem("context.workingSet.minEvictableTokens", String(workingSet.minEvictableTokens), {
+			values: ["0", "100", "200", "500", "1000"],
+		}),
 		settingItem("retry.enabled", String(retry.enabled), {
 			values: ["true", "false"],
 		}),
@@ -1538,13 +1910,16 @@ export function buildSettingItems(
 		settingItem("retry.maxDelayMs", String(retry.maxDelayMs), {
 			values: ["10000", "30000", "60000", "120000", "300000"],
 		}),
-		settingItem("terminal.showTerminalProgress", String(terminal.showTerminalProgress), {
+		settingItem("retry.streamStallMs", String(retry.streamStallMs), {
+			values: ["60000", "120000", "180000", "300000", "600000"],
+		}),
+		settingItem("terminal.showTerminalProgress", String(terminal.terminalProgress), {
 			values: ["false", "true"],
 		}),
-		settingItem("terminal.outputVerbosity", terminal.outputVerbosity, {
+		settingItem("terminal.outputVerbosity", terminal.outputDetail, {
 			values: ["minimal", "default", "verbose"],
 		}),
-		settingItem("terminal.tuiMode", terminal.tuiMode, {
+		settingItem("terminal.tuiMode", terminal.mode, {
 			values: ["regular", "fullscreen"],
 		}),
 		settingItem("terminal.fullscreenScrollbar", terminal.fullscreenScrollbar, {
@@ -1553,12 +1928,17 @@ export function buildSettingItems(
 		settingItem("terminal.smoothStreaming", terminal.smoothStreaming, {
 			values: ["off", "auto", "on"],
 		}),
-		settingItem("terminal.notify", String(terminal.notify), {
+		settingItem("terminal.notify", String(terminal.desktopNotifications), {
 			values: ["false", "true"],
 		}),
-		settingItem("theme", settings.theme, {
-			affordance: "single clio-coder palette",
-			readOnly: 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"] }),
+		settingItem("panes.yazi.followCwd", String(panes.files.followCwd), { values: ["true", "false"] }),
+		settingItem("panes.yazi.ratio", formatThreshold(panes.files.ratio, "0.3"), {
+			submenu: editNumberSubmenu("Edit files dock share (0.05–0.5)", "panes.yazi.ratio"),
+			affordance: "free text",
 		}),
 		settingItem("watchdog.enabled", String(watchdog.enabled), {
 			values: ["false", "true"],
@@ -1583,11 +1963,15 @@ export function buildSettingItems(
 				editValue: watchdog.cadenceToolCalls === undefined ? "" : String(watchdog.cadenceToolCalls),
 			},
 		),
-		settingItem("runtimePlugins", settings.runtimePlugins.length > 0 ? settings.runtimePlugins.join(", ") : "(none)", {
-			submenu: editTextSubmenu("Edit runtime plugins comma-separated list", "Restart Clio to load changes."),
-			affordance: "free text",
-		}),
-		settingItem("attribution.gitCommits", settings.attribution.gitCommits ? "enabled" : "disabled", {
+		settingItem(
+			"runtimePlugins",
+			settings.integrations.runtimePlugins.length > 0 ? settings.integrations.runtimePlugins.join(", ") : "(none)",
+			{
+				submenu: editTextSubmenu("Edit runtime plugins comma-separated list", "Restart Clio to load changes."),
+				affordance: "free text",
+			},
+		),
+		settingItem("attribution.gitCommits", settings.integrations.git.commitAttribution ? "enabled" : "disabled", {
 			values: ["enabled", "disabled"],
 		}),
 		settingItem("compaction.model", compaction.model ?? "(orchestrator target)", {
@@ -1598,24 +1982,61 @@ export function buildSettingItems(
 			submenu: editTextSubmenu("Edit compaction prompt path; blank uses the built-in"),
 			affordance: "free text",
 		}),
-		settingItem("delegation.defaults.connectTimeoutMs", String(settings.delegation.defaults.connectTimeoutMs), {
-			submenu: editNumberSubmenu("Edit delegate connect timeout (ms)", "delegation.defaults.connectTimeoutMs"),
-			affordance: "free text",
+		settingItem(
+			"delegation.defaults.connectTimeoutMs",
+			String(settings.integrations.externalAgents.defaults.connectTimeoutMs),
+			{
+				submenu: editNumberSubmenu("Edit delegate connect timeout (ms)", "delegation.defaults.connectTimeoutMs"),
+				affordance: "free text",
+			},
+		),
+		settingItem(
+			"delegation.defaults.turnTimeoutMs",
+			String(settings.integrations.externalAgents.defaults.turnTimeoutMs),
+			{
+				submenu: editNumberSubmenu("Edit delegate turn timeout (ms)", "delegation.defaults.turnTimeoutMs"),
+				affordance: "free text",
+			},
+		),
+		settingItem(
+			"delegation.defaults.permissionTimeoutMs",
+			String(settings.integrations.externalAgents.defaults.permissionTimeoutMs),
+			{
+				submenu: editNumberSubmenu("Edit delegate permission timeout (ms)", "delegation.defaults.permissionTimeoutMs"),
+				affordance: "free text",
+			},
+		),
+		settingItem("keybindings", keybindingCount > 0 ? `${keybindingCount} override(s)` : "(defaults)", {
+			affordance: "edit settings.yaml",
+			readOnly: true,
 		}),
-		settingItem("delegation.defaults.turnTimeoutMs", String(settings.delegation.defaults.turnTimeoutMs), {
-			submenu: editNumberSubmenu("Edit delegate turn timeout (ms)", "delegation.defaults.turnTimeoutMs"),
+		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",
+			editValue: library.catalog ?? "",
 		}),
-		settingItem("delegation.defaults.permissionTimeoutMs", String(settings.delegation.defaults.permissionTimeoutMs), {
-			submenu: editNumberSubmenu("Edit delegate permission timeout (ms)", "delegation.defaults.permissionTimeoutMs"),
+		settingItem("library.remote", library.remote ?? "(local only)", {
+			submenu: editTextSubmenu("Edit library remote URL; blank keeps the library local"),
 			affordance: "free text",
+			editValue: library.remote ?? "",
 		}),
-		settingItem("keybindings", keybindingCount > 0 ? `${keybindingCount} override(s)` : "(defaults)", {
-			affordance: "edit settings.yaml",
+		// Confirming a remote from the settings row would be the trust record
+		// confirming itself, so this row reports what the confirm flow wrote.
+		settingItem("library.confirmedRemote", library.confirmedRemote ?? "(unconfirmed)", {
+			affordance: "set by `clio-coder library` on confirmation",
 			readOnly: true,
 		}),
-		settingItem("delegation.agents", agents.length > 0 ? `${agents.length} agent(s)` : "(none)", {
-			...delegationAgentsAffordance(agents, options?.getInteropProposals?.() ?? []),
+		settingItem("library.sync", String(library.sync), {
+			values: ["true", "false"],
 		}),
 	];
 }
@@ -1626,7 +2047,7 @@ function fleetProfileRows(
 	options: BuildSettingItemsOptions | undefined,
 ): SettingsCenterItem[] {
 	const providers = options?.providers;
-	return Object.entries(settings.workers.profiles)
+	return Object.entries(settings.fleet.profiles)
 		.sort(([a], [b]) => a.localeCompare(b))
 		.map(([name, profile]) => {
 			const thinking = thinkingChoices(providers, profile.target, profile.model, profile.thinkingLevel);
@@ -1636,7 +2057,7 @@ function fleetProfileRows(
 			const summary = `${target}/${model}  ${thinking.display}  ${placement}`;
 			const compactThinking = truncateProfileFact(thinking.display, 7);
 			const compactPlacement = truncateProfileFact(placement, 7);
-			const route = target === settings.workers.default.target ? model : `${target}/${model}`;
+			const route = target === settings.fleet.default.target ? model : `${target}/${model}`;
 			const routeBudget = Math.max(
 				8,
 				PROFILE_SUMMARY_VALUE_BUDGET -
@@ -1648,7 +2069,7 @@ function fleetProfileRows(
 			return settingItem(`workers.profiles.${name}`, summary, {
 				label: name,
 				description: `Profile ${name}. Enter to edit its target, model, thinking level, placement, or remove it.`,
-				help: ["target", "model", "thinkingLevel", "node"].map((field) => `workers.profiles.${name}.${field}`).join(" · "),
+				help: ["target", "model", "thinkingLevel", "node"].map((field) => `fleet.profiles.${name}.${field}`).join(" · "),
 				submenu: profileWorkbenchSubmenu(name, settings, live, options),
 				affordance: "Enter: drill into profile fields",
 				valueSegments: [
@@ -1684,7 +2105,7 @@ function profileWorkbenchSubmenu(
 				done();
 				return;
 			}
-			const profile = live().workers.profiles[name];
+			const profile = live().fleet.profiles[name];
 			if (!profile) {
 				done();
 				return;
@@ -1705,7 +2126,7 @@ function profileWorkbenchSubmenu(
 			}
 			if (field === "model") {
 				const submenu = options?.providers
-					? selectModelSubmenu(options.providers, () => live().workers.profiles[name]?.target ?? undefined)
+					? selectModelSubmenu(options.providers, () => live().fleet.profiles[name]?.target ?? undefined)
 					: editTextSubmenu("Type model name");
 				active = submenu(profile.model ?? "(unset)", finish);
 				return;
@@ -1753,10 +2174,10 @@ function profileNodeChoices(
 }
 
 function agentBindingRows(settings: Readonly<ClioSettings>, live: () => Readonly<ClioSettings>): SettingsCenterItem[] {
-	return Object.entries(settings.workers.agentBindings)
+	return Object.entries(settings.fleet.agentProfiles)
 		.sort(([a], [b]) => a.localeCompare(b))
 		.map(([agentId, profileName]) => {
-			const missing = !settings.workers.profiles[profileName];
+			const missing = !settings.fleet.profiles[profileName];
 			return settingItem(`workers.agentBindings.${agentId}`, profileName, {
 				label: `${agentId} · profile`,
 				description: missing
@@ -1779,9 +2200,9 @@ function targetRows(
 	return settings.targets.map((target) => {
 		const status = statuses.get(target.id);
 		const roles = [
-			settings.orchestrator.target === target.id ? "chat" : null,
-			settings.workers.default.target === target.id ? "fleet" : null,
-			settings.background.target === target.id ? "memory" : null,
+			settings.chat.target === target.id ? "chat" : null,
+			settings.fleet.default.target === target.id ? "fleet" : null,
+			settings.context.memory.target === target.id ? "memory" : null,
 		].filter((role) => role !== null);
 		const health = status?.health.status ?? "unknown";
 		const operation = options?.getTargetOperation?.(target.id) ?? null;
@@ -1894,7 +2315,7 @@ function fleetEndpointRows(providers: ProvidersContract | undefined): SettingsCe
 	});
 }
 
-export function buildSettingsSections(items: readonly SettingsCenterItem[]): SettingsCenterSection[] {
+function buildSettingsSections(items: readonly SettingsCenterItem[]): SettingsCenterSection[] {
 	return SETTINGS_SECTIONS.map((section) => ({
 		id: section.id,
 		label: section.label,
@@ -1935,8 +2356,8 @@ function refreshSettingItemsInPlace(items: SettingsCenterItem[], next: readonly
 	}
 }
 
-function formatThreshold(value: number): string {
-	return Number.isFinite(value) ? String(value) : "0.8";
+function formatThreshold(value: number, fallback = "0.8"): string {
+	return Number.isFinite(value) ? String(value) : fallback;
 }
 
 function applyNonNegativeInteger(value: string, set: (next: number) => void): void {
@@ -1961,48 +2382,48 @@ function applyNumberSetting(id: NumberSettingId, value: string, set: (next: numb
 function applyDelegationAgentChange(settings: ClioSettings, value: string): void {
 	if (value.startsWith(DELEGATION_REMOVE_PREFIX)) {
 		const id = value.slice(DELEGATION_REMOVE_PREFIX.length);
-		settings.delegation.agents = settings.delegation.agents.filter((agent) => agent.id !== id);
+		settings.integrations.externalAgents.entries = settings.integrations.externalAgents.entries.filter(
+			(agent) => agent.id !== id,
+		);
 		return;
 	}
 	if (!value.startsWith(DELEGATION_ADD_PREFIX)) return;
 	const kind = interopAgentKind(value.slice(DELEGATION_ADD_PREFIX.length) as InteropAgentId);
 	if (kind?.acp === undefined) return;
-	const entry = delegationEntryForKind(kind, settings.delegation.defaults);
-	if (settings.delegation.agents.some((agent) => agent.id === entry.id)) return;
-	settings.delegation.agents.push(entry);
+	const entry = delegationEntryForKind(kind, settings.integrations.externalAgents.defaults);
+	if (settings.integrations.externalAgents.entries.some((agent) => agent.id === entry.id)) return;
+	settings.integrations.externalAgents.entries.push(entry);
 }
 
-export function applySettingChange(settings: ClioSettings, id: string, value: string): void {
+function applySettingChange(settings: ClioSettings, id: string, value: string): void {
 	if (applyEntrySettingChange(settings, id, value)) return;
 	switch (id) {
 		case "autonomy":
 			if (value === "read-only" || value === "suggest" || value === "auto-edit" || value === "full-auto")
-				settings.autonomy = value;
+				settings.safety.autonomy = value;
 			return;
 		case "workers.onPermission":
-			if (value === "deny" || value === "fail" || value === "escalate") settings.workers.onPermission = value;
+			if (value === "deny" || value === "fail" || value === "escalate") settings.fleet.permissions.mode = value;
 			return;
 		case "delegation.defaults.toolGovernance":
-			if (value === "clio-policy" || value === "agent-managed" || value === "deny-all")
-				settings.delegation.defaults.toolGovernance = value;
+			if (value === "clio-coder-policy" || value === "agent-managed" || value === "deny-all")
+				settings.integrations.externalAgents.defaults.toolGovernance = value;
 			return;
 		case "delegation.agents":
 			applyDelegationAgentChange(settings, value);
 			return;
 		case "skills.trustProjectCompatRoots":
-			if (value === "true" || value === "false") settings.skills.trustProjectCompatRoots = value === "true";
+			if (value === "true" || value === "false")
+				settings.integrations.projectResources.trustProjectImports = value === "true";
 			return;
 		case "attribution.gitCommits":
-			if (value === "enabled" || value === "disabled") settings.attribution.gitCommits = value === "enabled";
+			if (value === "enabled" || value === "disabled") settings.integrations.git.commitAttribution = value === "enabled";
 			return;
 		case "orchestrator.thinkingLevel":
-			settings.orchestrator.thinkingLevel = thinkingLevelFromChoiceLabel(value) ?? settings.orchestrator.thinkingLevel;
-			return;
-		case "background.thinkingLevel":
-			settings.background.thinkingLevel = thinkingLevelFromChoiceLabel(value) ?? settings.background.thinkingLevel;
+			settings.chat.thinkingLevel = thinkingLevelFromChoiceLabel(value) ?? settings.chat.thinkingLevel;
 			return;
 		case "memory.intervention.enabled":
-			if (value === "true" || value === "false") settings.memory.intervention.enabled = value === "true";
+			if (value === "true" || value === "false") settings.context.memory.enabled = value === "true";
 			return;
 		case "memory.intervention.everyNTools":
 		case "memory.intervention.windowSteps":
@@ -2010,102 +2431,139 @@ export function applySettingChange(settings: ClioSettings, id: string, value: st
 		case "memory.intervention.timeoutMs":
 			applyNonNegativeInteger(value, (next) => {
 				if (next >= 1) {
-					const key = id.slice("memory.intervention.".length) as "everyNTools" | "windowSteps" | "maxTokens" | "timeoutMs";
-					settings.memory.intervention[key] = next;
+					// The v1 row ids are the presentation vocabulary; the v2 fields they
+					// write have their own names.
+					const key = (
+						{
+							"memory.intervention.everyNTools": "cadenceToolCalls",
+							"memory.intervention.windowSteps": "trajectorySteps",
+							"memory.intervention.maxTokens": "maxOutputTokens",
+							"memory.intervention.timeoutMs": "timeoutMs",
+						} as const
+					)[id];
+					if (key) settings.context.memory[key] = next;
 				}
 			});
 			return;
 		case "workers.default.thinkingLevel":
-			settings.workers.default.thinkingLevel =
-				thinkingLevelFromChoiceLabel(value) ?? settings.workers.default.thinkingLevel;
+			settings.fleet.default.thinkingLevel = thinkingLevelFromChoiceLabel(value) ?? settings.fleet.default.thinkingLevel;
 			return;
 		case "workers.maxRetries":
 			applyNonNegativeInteger(value, (next) => {
-				settings.workers.maxRetries = next;
+				settings.fleet.retry.maxRetries = next;
+			});
+			return;
+		case "panes.enabled":
+			if (value === "auto" || value === "embedded" || value === "off") settings.interface.panes.enabled = value;
+			return;
+		case "panes.notifications":
+			if (value === "failures" || value === "all" || value === "off") settings.interface.panes.notifications = value;
+			return;
+		case "panes.layout":
+			if (value === "off" || value === "workers" || value === "cockpit") settings.interface.panes.layout = value;
+			return;
+		case "panes.workers.ratio":
+			applyNumberSetting(id, value, (next) => {
+				if (next !== null) settings.interface.panes.workers.ratio = next;
 			});
 			return;
+		case "panes.yazi.ratio":
+			applyNumberSetting(id, value, (next) => {
+				if (next !== null) settings.interface.panes.files.ratio = next;
+			});
+			return;
+		case "panes.journal":
+			if (value === "true" || value === "false") settings.fleet.history.journal = value === "true";
+			return;
+		case "panes.yazi.enabled":
+			if (value === "true" || value === "false") settings.interface.panes.files.enabled = value === "true";
+			return;
+		case "panes.yazi.mode":
+			if (value === "companion" || value === "chooser") settings.interface.panes.files.mode = value;
+			return;
+		case "panes.yazi.profile":
+			if (value === "managed" || value === "user") settings.interface.panes.files.profile = value;
+			return;
+		case "panes.yazi.followCwd":
+			if (value === "true" || value === "false") settings.interface.panes.files.followCwd = value === "true";
+			return;
 		case "modelSelector.recentLimit":
 			applyNonNegativeInteger(value, (next) => {
-				if (next >= 1) settings.modelSelector.recentLimit = next;
+				if (next >= 1) settings.chat.modelPicker.recentLimit = next;
 			});
 			return;
 		case "defaults.maxTokens":
 			applyNonNegativeInteger(value, (next) => {
-				settings.defaults.maxTokens = next;
+				settings.chat.maxOutputTokens = next;
 			});
 			return;
 		case "budget.concurrency": {
 			if (value === "auto") {
-				settings.budget.concurrency = "auto";
+				settings.fleet.concurrency = "auto";
 				return;
 			}
 			applyNonNegativeInteger(value, (next) => {
-				if (next >= 1) settings.budget.concurrency = next;
+				if (next >= 1) settings.fleet.concurrency = next;
 			});
 			return;
 		}
 		case "compaction.auto":
-			if (value === "true" || value === "false") settings.compaction.auto = value === "true";
-			return;
-		case "compaction.excludeLastTurns":
-			applyNonNegativeInteger(value, (next) => {
-				if (next > 0) settings.compaction.excludeLastTurns = next;
-			});
+			if (value === "true" || value === "false") settings.context.compaction.auto = value === "true";
 			return;
 		case "compaction.threshold": {
 			const parsed = Number(value);
-			if (Number.isFinite(parsed) && parsed >= 0 && parsed <= 1) settings.compaction.threshold = parsed;
+			if (Number.isFinite(parsed) && parsed >= 0 && parsed <= 1) settings.context.compaction.threshold = parsed;
 			return;
 		}
 		case "compaction.model": {
 			const trimmed = value.trim();
-			if (trimmed) settings.compaction.model = trimmed;
-			else delete settings.compaction.model;
+			if (trimmed) settings.context.compaction.model = trimmed;
+			else delete settings.context.compaction.model;
 			return;
 		}
 		case "compaction.systemPrompt": {
 			const trimmed = value.trim();
-			if (trimmed) settings.compaction.systemPrompt = trimmed;
-			else delete settings.compaction.systemPrompt;
+			if (trimmed) settings.context.compaction.systemPrompt = trimmed;
+			else delete settings.context.compaction.systemPrompt;
 			return;
 		}
 		case "retry.enabled":
-			if (value === "true" || value === "false") settings.retry.enabled = value === "true";
+			if (value === "true" || value === "false") settings.chat.retry.enabled = value === "true";
 			return;
 		case "retry.maxRetries":
 			applyNonNegativeInteger(value, (next) => {
-				settings.retry.maxRetries = next;
+				settings.chat.retry.maxRetries = next;
 			});
 			return;
 		case "retry.baseDelayMs":
 			applyNonNegativeInteger(value, (next) => {
-				settings.retry.baseDelayMs = next;
+				settings.chat.retry.baseDelayMs = next;
 			});
 			return;
 		case "retry.maxDelayMs":
 			applyNonNegativeInteger(value, (next) => {
-				settings.retry.maxDelayMs = next;
+				settings.chat.retry.maxDelayMs = next;
 			});
 			return;
 		case "terminal.showTerminalProgress":
-			if (value === "true" || value === "false") settings.terminal.showTerminalProgress = value === "true";
+			if (value === "true" || value === "false") settings.interface.terminalProgress = value === "true";
 			return;
 		case "terminal.outputVerbosity":
-			if (value === "minimal" || value === "default" || value === "verbose") settings.terminal.outputVerbosity = value;
+			if (value === "minimal" || value === "default" || value === "verbose") settings.interface.outputDetail = value;
 			return;
 		case "terminal.tuiMode":
-			if (value === "regular" || value === "fullscreen") settings.terminal.tuiMode = value;
+			if (value === "regular" || value === "fullscreen") settings.interface.mode = value;
 			return;
 		case "terminal.fullscreenScrollbar":
 			if (value === "hidden" || value === "auto" || value === "always") {
-				settings.terminal.fullscreenScrollbar = value;
+				settings.interface.fullscreenScrollbar = value;
 			}
 			return;
 		case "terminal.notify":
-			if (value === "true" || value === "false") settings.terminal.notify = value === "true";
+			if (value === "true" || value === "false") settings.interface.desktopNotifications = value === "true";
 			return;
 		case "watchdog.enabled":
-			if (value === "true" || value === "false") settings.watchdog.enabled = value === "true";
+			if (value === "true" || value === "false") settings.safety.review.enabled = value === "true";
 			return;
 		// Both watchdog options are absent-by-default, and an empty submission is
 		// how the operator says "go back to the default" from a text row. Deleting
@@ -2113,82 +2571,80 @@ export function applySettingChange(settings: ClioSettings, id: string, value: st
 		// config validator accepts.
 		case "watchdog.target": {
 			const trimmed = value.trim();
-			if (trimmed) settings.watchdog.target = trimmed;
-			else delete settings.watchdog.target;
+			if (trimmed) settings.safety.review.target = trimmed;
+			else delete settings.safety.review.target;
 			return;
 		}
 		case "watchdog.cadenceToolCalls":
 			applyNumberSetting("watchdog.cadenceToolCalls", value, (next) => {
-				if (next === null) delete settings.watchdog.cadenceToolCalls;
-				else settings.watchdog.cadenceToolCalls = next;
+				if (next === null) delete settings.safety.review.cadenceToolCalls;
+				else settings.safety.review.cadenceToolCalls = next;
 			});
 			return;
 		case "terminal.smoothStreaming":
-			if (value === "off" || value === "auto" || value === "on") settings.terminal.smoothStreaming = value;
+			if (value === "off" || value === "auto" || value === "on") settings.interface.smoothStreaming = value;
 			return;
 		case "runtimePlugins":
-			settings.runtimePlugins = value
+			settings.integrations.runtimePlugins = value
 				.split(",")
 				.map((entry) => entry.trim())
 				.filter(Boolean);
 			return;
 		case "delegation.defaults.connectTimeoutMs":
 			applyNumberSetting("delegation.defaults.connectTimeoutMs", value, (next) => {
-				if (next !== null) settings.delegation.defaults.connectTimeoutMs = next;
+				if (next !== null) settings.integrations.externalAgents.defaults.connectTimeoutMs = next;
 			});
 			return;
 		case "delegation.defaults.turnTimeoutMs":
 			applyNumberSetting("delegation.defaults.turnTimeoutMs", value, (next) => {
-				if (next !== null) settings.delegation.defaults.turnTimeoutMs = next;
+				if (next !== null) settings.integrations.externalAgents.defaults.turnTimeoutMs = next;
 			});
 			return;
 		case "delegation.defaults.permissionTimeoutMs":
 			applyNumberSetting("delegation.defaults.permissionTimeoutMs", value, (next) => {
-				if (next !== null) settings.delegation.defaults.permissionTimeoutMs = next;
+				if (next !== null) settings.integrations.externalAgents.defaults.permissionTimeoutMs = next;
 			});
 			return;
 		case "orchestrator.target": {
 			const target = value === "(unset)" || value === "" ? null : value;
 			// Switching targets re-bases the model on the new target default.
-			if (target !== settings.orchestrator.target) {
-				settings.orchestrator.model = target
-					? (settings.targets.find((entry) => entry.id === target)?.defaultModel ?? null)
-					: null;
+			if (target !== settings.chat.target) {
+				settings.chat.model = target ? (settings.targets.find((entry) => entry.id === target)?.defaultModel ?? null) : null;
 			}
-			settings.orchestrator.target = target;
+			settings.chat.target = target;
 			return;
 		}
 		case "orchestrator.model":
-			settings.orchestrator.model = value === "(unset)" || value === "" ? null : value;
+			settings.chat.model = value === "(unset)" || value === "" ? null : value;
 			return;
 		case "background.target": {
 			const target = value.startsWith("(unset") || value === "" ? null : value;
-			if (target !== settings.background.target) {
-				settings.background.model = target
+			if (target !== settings.context.memory.target) {
+				settings.context.memory.model = target
 					? (settings.targets.find((entry) => entry.id === target)?.defaultModel ?? null)
 					: null;
 			}
-			settings.background.target = target;
+			settings.context.memory.target = target;
 			return;
 		}
 		case "background.model":
-			settings.background.model = value === "(unset)" || value === "" ? null : value;
+			settings.context.memory.model = value === "(unset)" || value === "" ? null : value;
 			return;
 		case "workers.default.target": {
 			const target = value === "(unset)" || value === "" ? null : value;
-			if (target !== settings.workers.default.target) {
-				settings.workers.default.model = target
+			if (target !== settings.fleet.default.target) {
+				settings.fleet.default.model = target
 					? (settings.targets.find((entry) => entry.id === target)?.defaultModel ?? null)
 					: null;
 			}
-			settings.workers.default.target = target;
+			settings.fleet.default.target = target;
 			return;
 		}
 		case "workers.default.model":
-			settings.workers.default.model = value === "(unset)" || value === "" ? null : value;
+			settings.fleet.default.model = value === "(unset)" || value === "" ? null : value;
 			return;
 		case "scope":
-			settings.scope =
+			settings.chat.modelPicker.cycleSet =
 				parseScopedModelSelection(value) ??
 				value
 					.split(",")
@@ -2197,9 +2653,98 @@ export function applySettingChange(settings: ClioSettings, id: string, value: st
 			return;
 		case "budget.sessionCeilingUsd":
 			applyNumberSetting("budget.sessionCeilingUsd", value, (next) => {
-				if (next !== null) settings.budget.sessionCeilingUsd = next;
+				if (next !== null) settings.safety.limits.sessionCostUsd = next;
+			});
+			return;
+		case "workers.escalation.timeoutMs":
+			applyNumberSetting("workers.escalation.timeoutMs", value, (next) => {
+				if (next === null) return;
+				settings.fleet.permissions.escalation = {
+					...(settings.fleet.permissions.escalation ?? SHIPPED_ESCALATION),
+					timeoutMs: next,
+				};
+			});
+			return;
+		case "workers.escalation.fallback": {
+			if (value !== "deny" && value !== "fail") return;
+			settings.fleet.permissions.escalation = {
+				...(settings.fleet.permissions.escalation ?? SHIPPED_ESCALATION),
+				fallback: value,
+			};
+			return;
+		}
+		case "workers.resilienceCooldownMs":
+			applyNumberSetting("workers.resilienceCooldownMs", value, (next) => {
+				if (next !== null) settings.fleet.retry.routeCooldownMs = next;
+			});
+			return;
+		case "routing.activeRoles": {
+			const outcome = parseEnumListSetting(value, ACTIVE_ROUTING_ROLES);
+			if ("values" in outcome) settings.fleet.adaptiveRouting.roles = outcome.values as ActiveRoutingRole[];
+			return;
+		}
+		case "routing.activePostures": {
+			const outcome = parseEnumListSetting(value, ACTIVE_ROUTING_POSTURES);
+			if ("values" in outcome) settings.fleet.adaptiveRouting.postures = outcome.values as ActiveRoutingPosture[];
+			return;
+		}
+		case "prewarm.enabled":
+			if (value === "true" || value === "false") settings.chat.prewarm = value === "true";
+			return;
+		case "guardrails.turnToolCallBudget":
+		case "guardrails.workerToolCallCap":
+		case "guardrails.maxDispatchRuns":
+		case "guardrails.readMaxBytes":
+		case "guardrails.observationTurnBudgetBytes":
+		case "guardrails.internalDispatchTimeoutMs":
+			applyNumberSetting(id, value, (next) => {
+				if (next === null) return;
+				if (id === "guardrails.turnToolCallBudget") settings.safety.limits.chatToolCallsPerTurn = next;
+				else if (id === "guardrails.workerToolCallCap") settings.fleet.limits.toolCallsPerRun = next;
+				else if (id === "guardrails.maxDispatchRuns") settings.fleet.history.maxRuns = next;
+				else if (id === "guardrails.readMaxBytes") settings.safety.limits.readBytesPerCall = next;
+				else if (id === "guardrails.observationTurnBudgetBytes") settings.safety.limits.observationBytesPerTurn = next;
+				else settings.fleet.limits.internalRunTimeoutMs = next;
+			});
+			return;
+		case "context.workingSet.enabled":
+			if (value === "true" || value === "false") settings.context.workingSet.enabled = value === "true";
+			return;
+		case "context.workingSet.policy":
+			if (value === "structural-v1" || value === "age-horizon") settings.context.workingSet.policy = value;
+			return;
+		case "context.workingSet.target": {
+			// The validator's bound is exclusive at both ends, so an eviction target
+			// of 0 or 1 is refused here rather than written and rejected at boot.
+			const parsed = Number(value);
+			if (Number.isFinite(parsed) && parsed > 0 && parsed < 1) settings.context.workingSet.target = parsed;
+			return;
+		}
+		case "context.workingSet.protectLastTurns":
+			applyNonNegativeInteger(value, (next) => {
+				if (next >= 1) settings.context.workingSet.protectLastTurns = next;
+			});
+			return;
+		case "context.workingSet.minEvictableTokens":
+			applyNonNegativeInteger(value, (next) => {
+				settings.context.workingSet.minEvictableTokens = next;
 			});
 			return;
+		case "retry.streamStallMs":
+			applyNonNegativeInteger(value, (next) => {
+				settings.chat.retry.streamStallMs = next;
+			});
+			return;
+		case "library.catalog":
+		case "library.remote": {
+			const key = id.slice("library.".length) as "catalog" | "remote";
+			const trimmed = value.trim();
+			settings.integrations.library[key] = trimmed.length > 0 ? trimmed : null;
+			return;
+		}
+		case "library.sync":
+			if (value === "true" || value === "false") settings.integrations.library.sync = value === "true";
+			return;
 	}
 }
 
@@ -2219,11 +2764,11 @@ function applyEntrySettingChange(settings: ClioSettings, id: string, value: stri
 		const legacySegments = id.split(".");
 		const legacyField = legacySegments.at(-1);
 		const usesLegacyField =
-			!settings.workers.profiles[summaryName] && ["target", "model", "thinkingLevel", "node"].includes(legacyField ?? "");
+			!settings.fleet.profiles[summaryName] && ["target", "model", "thinkingLevel", "node"].includes(legacyField ?? "");
 		const field = usesLegacyField ? legacyField : encoded.shift();
 		const name = usesLegacyField ? legacySegments.slice(2, -1).join(".") : summaryName;
 		const fieldValue = usesLegacyField ? value : encoded.join(PROFILE_FIELD_SEPARATOR);
-		const profile = settings.workers.profiles[name];
+		const profile = settings.fleet.profiles[name];
 		if (!profile) return true;
 		if (value === REMOVE_PROFILE_CHOICE) {
 			removeFleetProfileFromSettings(settings, name);
@@ -2241,7 +2786,7 @@ function applyEntrySettingChange(settings: ClioSettings, id: string, value: stri
 	}
 	if (id.startsWith("workers.agentBindings.")) {
 		const agentId = id.slice("workers.agentBindings.".length);
-		if (value === UNBIND_CHOICE) delete settings.workers.agentBindings[agentId];
+		if (value === UNBIND_CHOICE) delete settings.fleet.agentProfiles[agentId];
 		else bindAgentProfileInSettings(settings, agentId, value);
 		return true;
 	}
@@ -2265,7 +2810,7 @@ function changedLeafPaths(before: Readonly<ClioSettings>, after: Readonly<ClioSe
 		v !== null && typeof v === "object" && !Array.isArray(v);
 	const visit = (a: unknown, b: unknown, path: string): void => {
 		if (a === b) return;
-		const profileLeaf = path.startsWith("workers.profiles.") && path.split(".").length === 3;
+		const profileLeaf = path.startsWith("fleet.profiles.") && path.split(".").length === 3;
 		if (!isRecord(a) || !isRecord(b) || profileLeaf) {
 			if (JSON.stringify(a) !== JSON.stringify(b)) out.push(path);
 			return;
@@ -2325,9 +2870,9 @@ function propagationTiming(
 	if (restartRequired) return "next-session";
 	if (id.startsWith("targets.")) {
 		if (selectedValue === "remove") return "next-dispatch";
-		return path.startsWith("orchestrator.") ? "now" : "next-dispatch";
+		return path.startsWith("chat.") ? "now" : "next-dispatch";
 	}
-	if (path.startsWith("workers.")) return "next-dispatch";
+	if (path.startsWith("fleet.")) return "next-dispatch";
 	return "now";
 }
 
@@ -2340,7 +2885,7 @@ function impactFor(propagation: SettingsChangePlan["propagation"]): string {
 	return "takes effect now";
 }
 
-export function createSettingsChangePlan(
+function createSettingsChangePlan(
 	settings: Readonly<ClioSettings>,
 	item: Pick<SettingsCenterItem, "id" | "label" | "currentValue" | "scope">,
 	selectedValue: string,
@@ -3135,8 +3680,8 @@ export class SettingsCenter implements Component {
 		list.onCancel = () => finish("cancel");
 		const title = (width: number): string => formatScopeConfirmTitle(plan, width);
 		const affectedBindings = plan.leaves
-			.filter((leaf) => leaf.path.startsWith("workers.agentBindings."))
-			.map((leaf) => leaf.path.slice("workers.agentBindings.".length));
+			.filter((leaf) => leaf.path.startsWith("fleet.agentProfiles."))
+			.map((leaf) => leaf.path.slice("fleet.agentProfiles.".length));
 		const bindingPreflight =
 			plan.selectedValue === REMOVE_PROFILE_CHOICE
 				? `Affected agent routes: ${affectedBindings.length > 0 ? affectedBindings.join(", ") : "none"} · `
@@ -3145,10 +3690,10 @@ export class SettingsCenter implements Component {
 			if (!plan.rowId.startsWith("targets.") || plan.selectedValue !== "remove") return "";
 			const paths = (prefix: string): string[] =>
 				plan.leaves.filter((leaf) => leaf.path.startsWith(prefix)).map((leaf) => leaf.path);
-			const profiles = paths("workers.profiles.").map((path) => path.slice("workers.profiles.".length));
+			const profiles = paths("fleet.profiles.").map((path) => path.slice("fleet.profiles.".length));
 			const describe = (label: string, affected: readonly string[]): string =>
 				`Affected ${label}: ${affected.length > 0 ? affected.join(", ") : "none"}`;
-			return `${describe("chat route", paths("orchestrator."))} · ${describe("fleet route", paths("workers.default."))} · ${describe("memory route", paths("background."))} · ${describe("profiles", profiles)} · `;
+			return `${describe("chat route", paths("chat."))} · ${describe("fleet route", paths("fleet.default."))} · ${describe("memory route", paths("context.memory."))} · ${describe("profiles", profiles)} · `;
 		})();
 		const note = `${bindingPreflight}${targetRemovalPreflight}Affects ${plan.leaves.map((leaf) => leaf.path).join(", ")} · ${plan.impact}`;
 		this.submenuComponent = new SubmenuWrapper(title, list, buildHint([{ key: "Enter", verb: "choose" }], "back"), note);
@@ -3297,12 +3842,15 @@ export class SettingsCenter implements Component {
 	}
 
 	/**
-	 * The footer is help, and the list is the work. A fixed six-line ceiling spent
-	 * a third of a 20-row body on prose, so the budget is what the body can spare
-	 * once the list keeps six rows.
+	 * The footer is the selected setting's detail surface at two-lane widths, so
+	 * it may use every row the list does not need. A fixed four-line ceiling left
+	 * a dozen blank body rows at an 80-column terminal while cutting the autonomy
+	 * explanation after its first sentence. Keeping six list rows makes the full
+	 * prose reachable when height is available and still degrades to no footer on
+	 * a short terminal.
 	 */
 	private footerBudget(bodyHeight: number): number {
-		return Math.min(4, Math.max(0, bodyHeight - 6));
+		return Math.max(0, bodyHeight - 6);
 	}
 
 	private renderSectionLane(width: number, height: number): string[] {
@@ -3468,15 +4016,27 @@ export class SettingsCenter implements Component {
 		const query = this.filterQuery.trim().length > 0 ? `  ${theme.fg("accent", `/${this.filterQuery}`)}` : "";
 		const positionText = `${theme.fg("dim", `section ${position}/${sections.length}`)}${query}`;
 
+		// The note is prose the operator acts on ("choose session, global, or
+		// cancel"), so it wraps under the same rule as the description above it. A
+		// truncated instruction is the one line in this footer that cannot afford
+		// to be a fragment.
+		const noteLines = (text: string, tone: "dim" | "muted"): string[] =>
+			wrapTextWithAnsi(theme.fg(tone, text), safeWidth);
+
 		if (this.level === "sections") {
 			const breadcrumb = `${screenTitle(theme, section.label)}  ${theme.fg("dim", "·")}  ${positionText}`;
 			const body = wrapTextWithAnsi(theme.fg("muted", SETTINGS_SECTION_DESCRIPTIONS[section.id]), safeWidth);
-			const note = theme.fg("dim", "Tab or → to edit its settings");
-			return this.assembleFooter([separator, breadcrumb], body, note, maxFooterLines, safeWidth);
+			return this.assembleFooter(
+				[separator, breadcrumb],
+				body,
+				noteLines(this.footerNoteText(), "dim"),
+				maxFooterLines,
+				safeWidth,
+			);
 		}
 
 		if (!item) {
-			return this.assembleFooter([separator], [], theme.fg("muted", "No setting selected."), maxFooterLines, safeWidth);
+			return this.assembleFooter([separator], [], noteLines(this.footerNoteText(), "muted"), maxFooterLines, safeWidth);
 		}
 
 		const breadcrumb = `${screenTitle(theme, section.label)} ${theme.fg("dim", "›")} ${theme.style("accent", item.label, { bold: true })}  ${theme.fg("dim", "·")}  ${positionText}`;
@@ -3485,8 +4045,27 @@ export class SettingsCenter implements Component {
 		if (item.help) contentLines.push(...wrapTextWithAnsi(theme.fg("dim", item.help), safeWidth));
 		const detail = this.footerDetail(item, theme);
 		if (detail) contentLines.push(...wrapTextWithAnsi(detail, safeWidth));
-		const note = theme.fg("dim", truncateToWidth(this.footerScopeNote(item), safeWidth, ELLIPSIS, true));
-		return this.assembleFooter([separator, breadcrumb], contentLines, note, maxFooterLines, safeWidth);
+		return this.assembleFooter(
+			[separator, breadcrumb],
+			contentLines,
+			noteLines(this.footerScopeNote(item), "dim"),
+			maxFooterLines,
+			safeWidth,
+		);
+	}
+
+	/**
+	 * The note text renderFooter will show, without theming. `footerBudget` needs
+	 * its wrapped height before the footer is rendered, so both read it here and
+	 * the ceiling can never disagree with what lands.
+	 */
+	private footerNoteText(): string {
+		const section = this.currentSection();
+		if (!section) return "";
+		if (this.level === "sections") return "Tab or → to edit its settings";
+		const item = this.selectedItem();
+		if (!item) return "No setting selected.";
+		return this.footerScopeNote(item);
 	}
 
 	private footerDetail(item: SettingsCenterItem, theme: ReturnType<typeof clioTheme>): string {
@@ -3523,7 +4102,7 @@ export class SettingsCenter implements Component {
 	private assembleFooter(
 		top: readonly string[],
 		middle: readonly string[],
-		note: string,
+		note: readonly string[],
 		maxFooterLines: number,
 		width: number,
 	): string[] {
@@ -3532,7 +4111,11 @@ export class SettingsCenter implements Component {
 		if (maxFooterLines <= top.length) {
 			out = top.slice(0, maxFooterLines).map(fit);
 		} else {
-			const middleBudget = Math.max(0, maxFooterLines - top.length - 1);
+			// The note owns the rows it wrapped to, up to whatever is left under the
+			// breadcrumb; the explanation fills the rest. Dropping a wrapped note
+			// line loses less than cutting the sentence mid-word did.
+			const noteKept = note.slice(0, Math.max(1, maxFooterLines - top.length));
+			const middleBudget = Math.max(0, maxFooterLines - top.length - noteKept.length);
 			// The explanation is wrapped, so a short terminal drops whole lines off
 			// its end rather than cutting one. At 40 columns the autonomy help
 			// stopped at "read-only observes; suggest" and read as the whole
@@ -3541,7 +4124,7 @@ export class SettingsCenter implements Component {
 			const last = kept.at(-1);
 			const marked =
 				middle.length > kept.length && last !== undefined ? [...kept.slice(0, -1), `${last}${ELLIPSIS}`] : kept;
-			out = [...top.map(fit), ...marked.map(fit), fit(note)];
+			out = [...top.map(fit), ...marked.map(fit), ...noteKept.map(fit)];
 		}
 		while (out.length < maxFooterLines) out.push("");
 		return out.slice(0, maxFooterLines);
@@ -3635,25 +4218,22 @@ export function openSettingsOverlay(tui: TUI, deps: OpenSettingsOverlayDeps): Se
 		center.refreshItems();
 		tui.requestRender();
 	};
-	// The engine composites an overlay across the columns its region covers, and
-	// side margins shrink that region, so this margin is re-read every frame and
-	// drops to zero on an ultra-narrow terminal rather than leaving transcript
-	// columns beside a modal that owns the keyboard.
-	const margin: { top: number; right: number; bottom: number; left: number } = { ...SETTINGS_OVERLAY_MARGIN };
 	const handle = showClioOverlayFrame(tui, center, {
 		anchor: "top-left",
 		width: SETTINGS_OVERLAY_WIDTH,
 		maxHeight: SETTINGS_OVERLAY_MAX_HEIGHT,
-		margin,
-		visible: (terminalWidth) => {
-			const side = terminalWidth < ULTRA_NARROW_TERMINAL_WIDTH ? 0 : SETTINGS_OVERLAY_MARGIN.left;
-			margin.left = side;
-			margin.right = side;
-			return true;
-		},
+		// A capturing overlay must own every horizontal cell. Leaving even a
+		// two-column compositor margin exposes arbitrary transcript and footer
+		// fragments beside the frame, where they read as modal content.
+		margin: SETTINGS_OVERLAY_MARGIN,
+		markerId: "settings",
 		title: "Settings",
-		footerHint: (innerWidth) =>
-			innerWidth < WIDE_LAYOUT_MIN_WIDTH
+		footerHint: (innerWidth) => {
+			// The submenu renders its own authoritative choose/back legend. Keeping
+			// the parent row controls in the outer border at the same time advertises
+			// actions (preview, open, filter) that this input depth does not route.
+			if (center.getSelection().submenuOpen) return undefined;
+			return innerWidth < WIDE_LAYOUT_MIN_WIDTH
 				? buildHint(
 						[
 							{ key: "↑↓", verb: "move" },
@@ -3670,7 +4250,8 @@ export function openSettingsOverlay(tui: TUI, deps: OpenSettingsOverlayDeps): Se
 							{ key: "/", verb: "filter" },
 						],
 						"back",
-					),
+					);
+		},
 	});
 	return Object.assign(handle, { refreshRows });
 }