@iowarp/clio-coder 0.3.6 → 0.3.7

package/src/interactive/overlays/library-install-confirm.ts

@@ -0,0 +1,151 @@
+/**
+ * The resource library's install confirmation, as an overlay.
+ *
+ * `clio-coder library add` prints every destination and SHA-256 hash and writes
+ * nothing until `--yes` is present. This overlay is that same gate for the
+ * Skills Hub: it states every path the install would write and the hash it
+ * would write there, and nothing reaches disk until the operator presses Enter.
+ * Esc leaves the plan unexecuted, so a cancelled confirmation is a run in which
+ * no file changed.
+ *
+ * The body is a pure function of the subject so the wording is testable without
+ * a TUI.
+ */
+
+import {
+	type Component,
+	isKeyRelease,
+	matchesKey,
+	type OverlayHandle,
+	type TUI,
+	truncateToWidth,
+	wrapTextWithAnsi,
+} from "../../engine/tui.js";
+import { buildResponsiveHint, FocusBox, showClioOverlayFrame } from "../overlay-frame.js";
+import { clioTheme, rule } from "../theme/index.js";
+
+export const LIBRARY_INSTALL_CONFIRM_TITLE = "Library install";
+
+const MIN_WIDTH = 48;
+const MAX_WIDTH = 110;
+
+/** One planned write, in the terms `library add` reports it. */
+export interface LibraryInstallWrite {
+	ref: string;
+	path: string;
+	sha256: string;
+}
+
+export interface LibraryInstallConfirmSubject {
+	/** The typed reference the operator asked for, e.g. `fleet:release`. */
+	entryRef: string;
+	/** Every write, in dependency order, the requested entry last. */
+	writes: ReadonlyArray<LibraryInstallWrite>;
+	/** Requirements this confirmation would install alongside the entry. */
+	requirements: ReadonlyArray<string>;
+	/** Requirements already on disk, named so the plan accounts for all of them. */
+	satisfied: ReadonlyArray<string>;
+}
+
+export interface OpenLibraryInstallConfirmOverlayOptions {
+	subject: LibraryInstallConfirmSubject;
+	/** Live terminal width, so the box tracks the window it opened in. */
+	columns: number;
+	/** Enter: perform exactly the writes this body named. */
+	onAccept: () => void;
+	/** Esc: nothing is written. */
+	onCancel: () => void;
+}
+
+function confirmOverlayWidth(columns: number): number {
+	return Math.max(MIN_WIDTH, Math.min(MAX_WIDTH, columns - 4));
+}
+
+/** Render the plan: what is being installed, alongside what, and to where. */
+export function formatLibraryInstallConfirmBody(subject: LibraryInstallConfirmSubject, width: number): string[] {
+	const theme = clioTheme();
+	const contentWidth = Math.max(1, Math.floor(width));
+	const rows: string[] = [];
+
+	const headline =
+		subject.requirements.length > 0
+			? `install ${subject.entryRef} with its requirements: ${subject.requirements.join(", ")}`
+			: `install ${subject.entryRef}`;
+	for (const line of wrapTextWithAnsi(theme.fg("accent", headline), contentWidth)) rows.push(line);
+	rows.push(rule(theme, contentWidth));
+
+	for (const write of subject.writes) {
+		rows.push(theme.fg("muted", truncateToWidth(`${write.ref} → ${write.path}`, contentWidth, "…", false)));
+		rows.push(theme.fg("dim", truncateToWidth(`    sha256 ${write.sha256}`, contentWidth, "…", false)));
+	}
+
+	rows.push(rule(theme, contentWidth));
+	const satisfied = subject.satisfied.length > 0 ? subject.satisfied.join(", ") : "none";
+	for (const line of wrapTextWithAnsi(theme.fg("info", `satisfied requirements: ${satisfied}`), contentWidth)) {
+		rows.push(line);
+	}
+	for (const line of wrapTextWithAnsi(
+		theme.fg("dim", `${subject.writes.length} file or files are written only after Enter; Esc writes nothing`),
+		contentWidth,
+	)) {
+		rows.push(line);
+	}
+	return rows;
+}
+
+class LibraryInstallConfirmBody implements Component {
+	constructor(private readonly subject: LibraryInstallConfirmSubject) {}
+
+	render(width: number): string[] {
+		return formatLibraryInstallConfirmBody(this.subject, width);
+	}
+
+	invalidate(): void {}
+}
+
+export function openLibraryInstallConfirmOverlay(
+	tui: TUI,
+	options: OpenLibraryInstallConfirmOverlayOptions,
+): OverlayHandle {
+	let settled = false;
+
+	const accept = (): void => {
+		if (settled) return;
+		settled = true;
+		options.onAccept();
+	};
+	const cancel = (): void => {
+		if (settled) return;
+		settled = true;
+		options.onCancel();
+	};
+
+	const focus = new FocusBox(new LibraryInstallConfirmBody(options.subject), {
+		// Keys are matched by name, never by raw bytes: under the kitty keyboard
+		// protocol Esc arrives as CSI 27 u, and a byte comparison against "\x1b"
+		// left the overlay unanswerable. Everything unmatched is swallowed.
+		onInput: (data: string): void => {
+			if (settled || isKeyRelease(data)) return;
+			if (matchesKey(data, "enter")) {
+				accept();
+				return;
+			}
+			if (matchesKey(data, "escape")) cancel();
+		},
+	});
+
+	const handle = showClioOverlayFrame(tui, focus, {
+		anchor: "center",
+		width: confirmOverlayWidth(options.columns),
+		title: LIBRARY_INSTALL_CONFIRM_TITLE,
+		footerHint: buildResponsiveHint([{ key: "Enter", verb: "install" }], { key: "Esc", verb: "cancel" }),
+	});
+
+	return {
+		...handle,
+		hide(): void {
+			cancel();
+			handle.hide();
+		},
+	};
+}

package/src/interactive/overlays/list-overlay.ts

@@ -32,9 +32,34 @@ export interface ListOverlayItem {
 	detail?: (width: number) => string[];
 }
 
+/**
+ * One tab of a tabbed list overlay.
+ *
+ * A tab owns its own row set and rebuilds it on demand, so switching tabs
+ * re-reads whatever the rows describe rather than serving a snapshot taken when
+ * the overlay opened. The counts drawn in the tab bar come from the same call,
+ * which is why an install that lands on one tab corrects every tab's count.
+ */
+export interface ListOverlayTab {
+	id: string;
+	label: string;
+	items: () => ReadonlyArray<ListOverlayItem>;
+}
+
 export interface ListOverlayOptions {
 	title: string;
 	items: ReadonlyArray<ListOverlayItem>;
+	/**
+	 * Tabs, drawn as a bar above the filter row and switched with ←/→, which is
+	 * the key vocabulary the Settings Center already uses to move between
+	 * sections. Omitted leaves the overlay untabbed and every tab code path
+	 * inert.
+	 */
+	tabs?: ReadonlyArray<ListOverlayTab>;
+	/** Tab the overlay opens on; defaults to the first. */
+	activeTabId?: string;
+	/** Notified after ←/→ changes the active tab. */
+	onTabChange?: (tabId: string) => void;
 	/** Enables the type-to-filter input row. */
 	filterable?: boolean;
 	/** Pre-applied filter text (e.g. /skill <query> in milestone 04). */
@@ -91,6 +116,10 @@ export class ListOverlayView implements Component {
 	private renderMemo: { key: string; lines: string[] } | null = null;
 	/** Bumped on every keystroke routed into the filter input; part of the memo key. */
 	private inputEpoch = 0;
+	/** Active tab id, or the empty string on an untabbed overlay. */
+	private activeTabId = "";
+	/** Row count per tab id, refreshed whenever the tab set is rebuilt. */
+	private tabCounts = new Map<string, number>();
 
 	constructor(
 		private readonly options: ListOverlayOptions,
@@ -104,6 +133,89 @@ export class ListOverlayView implements Component {
 		if (options.initialFilter) {
 			this.input.setValue(options.initialFilter);
 		}
+		const tabs = options.tabs;
+		if (tabs && tabs.length > 0) {
+			const requested = tabs.find((tab) => tab.id === options.activeTabId);
+			this.activeTabId = (requested ?? tabs[0])?.id ?? "";
+			this.refreshTabs();
+		}
+	}
+
+	/** The tab the overlay is on, or undefined when it is untabbed. */
+	activeTab(): ListOverlayTab | undefined {
+		return this.options.tabs?.find((tab) => tab.id === this.activeTabId);
+	}
+
+	/**
+	 * Rebuild every tab's rows, adopt the active tab's, and record each count.
+	 *
+	 * Every tab is rebuilt rather than only the active one because the tab bar
+	 * states each tab's count, and an install performed on one tab can satisfy a
+	 * requirement another tab reports. A stale count there is the same lie a
+	 * stale row is.
+	 */
+	refreshTabs(): void {
+		const tabs = this.options.tabs;
+		if (!tabs || tabs.length === 0) return;
+		const counts = new Map<string, number>();
+		let activeItems: ReadonlyArray<ListOverlayItem> = [];
+		for (const tab of tabs) {
+			const rows = tab.items();
+			counts.set(tab.id, rows.length);
+			if (tab.id === this.activeTabId) activeItems = rows;
+		}
+		this.tabCounts = counts;
+		this.setItems(activeItems);
+	}
+
+	/** Switch tabs and rebuild. A tab id this overlay does not carry is ignored. */
+	setActiveTab(tabId: string): void {
+		const tabs = this.options.tabs;
+		if (!tabs?.some((tab) => tab.id === tabId)) return;
+		this.activeTabId = tabId;
+		this.refreshTabs();
+		// After the rows, not before: setItems re-anchors the cursor on the id it
+		// was on, and on a tab switch that id belongs to a list the operator has
+		// left. A new tab starts at its first row.
+		this.selectedIndex = 0;
+		this.listScrollOffset = 0;
+		this.detailScrollOffset = 0;
+		this.renderMemo = null;
+	}
+
+	/**
+	 * The frame title. A tabbed overlay names the tab it is on, so the border
+	 * and the rows below it describe the same thing.
+	 */
+	title(): string {
+		const tab = this.activeTab();
+		return tab === undefined ? this.options.title : `${this.options.title} · ${tab.label}`;
+	}
+
+	private stepTab(delta: number): boolean {
+		const tabs = this.options.tabs;
+		if (!tabs || tabs.length === 0) return false;
+		const current = tabs.findIndex((tab) => tab.id === this.activeTabId);
+		const next = tabs[((((current === -1 ? 0 : current) + delta) % tabs.length) + tabs.length) % tabs.length];
+		if (!next || next.id === this.activeTabId) return false;
+		this.setActiveTab(next.id);
+		this.options.onTabChange?.(next.id);
+		this.onChange();
+		return true;
+	}
+
+	/** The tab bar: every tab with its count, the active one in the accent token. */
+	private renderTabBar(width: number): string[] {
+		const tabs = this.options.tabs;
+		if (!tabs || tabs.length === 0) return [];
+		const theme = clioTheme();
+		const parts = tabs.map((tab) => {
+			const text = `${tab.label} ${this.tabCounts.get(tab.id) ?? 0}`;
+			return tab.id === this.activeTabId
+				? theme.style("accent", `${GLYPH.cursor} ${text}`, { bold: true })
+				: theme.fg("dim", `  ${text}`);
+		});
+		return [this.padLine(parts.join(theme.fg("frame", " │ ")), width)];
 	}
 
 	/**
@@ -170,12 +282,27 @@ export class ListOverlayView implements Component {
 		this.options.onClose();
 	}
 
+	/**
+	 * The tab entry a tabbed footer carries. The verb names the active tab and
+	 * how many rows it holds, so the count a reader sees is the count of the tab
+	 * they are on rather than of the overlay as a whole.
+	 */
+	private tabHintEntry(): HintEntry | null {
+		const tab = this.activeTab();
+		if (tab === undefined) return null;
+		const count = this.tabCounts.get(tab.id) ?? this.items.length;
+		return { key: "←→", verb: `tab · ${count} ${tab.label.toLowerCase()}`, short: "tab", critical: true };
+	}
+
 	getHint(): string {
+		const tabEntry = this.tabHintEntry();
 		// A list with no rows has no row to select, invoke, or act on. Offering
 		// those keys anyway is the same lie the empty state exists to stop telling.
-		if (this.items.length === 0) return buildHint([], "close");
+		// A tab key is the exception: on an empty tab it is the way to a full one.
+		if (this.items.length === 0) return buildHint(tabEntry ? [tabEntry] : [], "close");
 
 		const hintEntries: HintEntry[] = [];
+		if (tabEntry) hintEntries.push(tabEntry);
 		hintEntries.push({ key: "↑↓", verb: "select" });
 		if (this.options.filterable) {
 			hintEntries.push(FILTER_HINT);
@@ -396,11 +523,14 @@ export class ListOverlayView implements Component {
 			this.detailScrollOffset,
 			this.inputEpoch,
 			this.itemsEpoch,
+			this.activeTabId,
 		].join("|");
 		if (this.renderMemo?.key === memoKey) return this.renderMemo.lines;
 
 		const lines: string[] = [];
 
+		lines.push(...this.renderTabBar(width));
+
 		if (this.options.filterable) {
 			this.input.focused = this.isFilterFocused;
 			const inputLines = this.input.render(width);
@@ -442,6 +572,20 @@ export class ListOverlayView implements Component {
 	}
 
 	handleInput(data: string): void {
+		// ←/→ switch tabs from either pane, ahead of the filter input, which is
+		// the arrangement the Settings Center already uses to move between
+		// sections. On an untabbed overlay both keys fall through untouched.
+		if (this.options.tabs && this.options.tabs.length > 0) {
+			if (matchesKey(data, "left")) {
+				this.stepTab(-1);
+				return;
+			}
+			if (matchesKey(data, "right")) {
+				this.stepTab(1);
+				return;
+			}
+		}
+
 		// PgDn / Ctrl+D and PgUp / Ctrl+U scroll the detail pane, but only
 		// while one is visible; otherwise the keys fall through untouched.
 		if (this.detailPaneVisible()) {
@@ -587,6 +731,15 @@ export interface ListOverlayHandle extends OverlayHandle {
 	 * the frame from before its own change until some other key moves the memo key.
 	 */
 	setItems(items: ReadonlyArray<ListOverlayItem>): void;
+	/**
+	 * Rebuild every tab's rows in place, keeping the active tab and the
+	 * operator's place in it. Inert on an untabbed overlay.
+	 */
+	refreshTabs(): void;
+	/** Switch tabs programmatically. An id this overlay does not carry is ignored. */
+	setActiveTab(tabId: string): void;
+	/** The active tab's id, or the empty string on an untabbed overlay. */
+	activeTabId(): string;
 }
 
 export function openListOverlay(tui: TUI, options: ListOverlayOptions): ListOverlayHandle {
@@ -594,7 +747,9 @@ export function openListOverlay(tui: TUI, options: ListOverlayOptions): ListOver
 	const handle = showClioOverlayFrame(tui, view, {
 		anchor: "center",
 		width: 100,
-		title: options.title,
+		// A function, not the string: on a tabbed overlay the title names the tab
+		// and must be re-read after every switch.
+		title: () => view.title(),
 		footerHint: () => view.getHint(),
 	});
 	return Object.assign(handle, {
@@ -602,5 +757,16 @@ export function openListOverlay(tui: TUI, options: ListOverlayOptions): ListOver
 			view.setItems(items);
 			tui.requestRender();
 		},
+		refreshTabs(): void {
+			view.refreshTabs();
+			tui.requestRender();
+		},
+		setActiveTab(tabId: string): void {
+			view.setActiveTab(tabId);
+			tui.requestRender();
+		},
+		activeTabId(): string {
+			return view.activeTab()?.id ?? "";
+		},
 	});
 }

package/src/interactive/overlays/settings.ts

@@ -135,6 +135,7 @@ export const SETTINGS_SECTIONS = [
 	{ 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;
 
@@ -150,6 +151,7 @@ const SETTINGS_SECTION_DESCRIPTIONS = {
 	compaction: "When and how the context window is summarized under pressure.",
 	retry: "Automatic recovery from transient provider and network 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.",
 } as const satisfies Record<SettingsSectionId, string>;
 
@@ -199,6 +201,10 @@ export const SETTINGS_LABELS_BY_ID = {
 	"terminal.tuiMode": "TUI mode",
 	"terminal.fullscreenScrollbar": "Fullscreen scrollbar",
 	"terminal.smoothStreaming": "Smooth streaming",
+	"terminal.notify": "Desktop notifications",
+	"watchdog.enabled": "Turn-end watchdog",
+	"watchdog.target": "Watchdog target",
+	"watchdog.cadenceToolCalls": "Watchdog cadence (tools)",
 	theme: "Theme",
 	runtimePlugins: "Runtime plugins",
 	"compaction.model": "Compaction model",
@@ -269,8 +275,10 @@ export const SETTINGS_SECTION_ROWS = {
 		"terminal.tuiMode",
 		"terminal.fullscreenScrollbar",
 		"terminal.smoothStreaming",
+		"terminal.notify",
 		"theme",
 	],
+	watchdog: ["watchdog.enabled", "watchdog.target", "watchdog.cadenceToolCalls"],
 	advanced: [
 		"runtimePlugins",
 		"attribution.gitCommits",
@@ -329,6 +337,11 @@ const SETTINGS_DESCRIPTIONS_BY_ID = {
 	"terminal.tuiMode": "Use regular terminal scrollback or a fullscreen transcript with a sticky composer and footer.",
 	"terminal.fullscreenScrollbar": "When the draggable transcript scrollbar is visible in fullscreen mode.",
 	"terminal.smoothStreaming": "Presentation-only pacing for streamed assistant text and thinking.",
+	"terminal.notify":
+		"Content-free desktop notification when a turn ends, a detached batch settles, or an approval parks.",
+	"watchdog.enabled": "When enabled, a turn that changed the tree is reviewed by one read-only verifier run.",
+	"watchdog.target": "Set target to route the run at a cheap local model; blank uses the session's active target.",
+	"watchdog.cadenceToolCalls": "Also fire every N tool calls inside a turn; blank fires at turn end only.",
 	theme: "Color palette. Clio ships a single tuned palette.",
 	runtimePlugins: "npm packages exporting clioRuntimes: RuntimeDescriptor[].",
 	"compaction.model": "Dedicated summarization model; blank uses the orchestrator.",
@@ -362,6 +375,14 @@ const SETTINGS_HELP_BY_ID: Partial<Record<EditableSettingId, string>> = {
 		"clio-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":
+		"OSC 777, or OSC 9 on iTerm2, Windows Terminal, and ConEmu. Interactive TTY runs only; the body never carries prompt text, file paths, or model output.",
+	"watchdog.enabled":
+		"The verifier run is briefed with the turn's coalesced diff and the task board's current scope; its blockers become one transcript notice and nothing else. Headless and ACP runs never fire it.",
+	"watchdog.target":
+		"A watchdog run costs a worker run per mutating turn, so routing it at a local target keeps the review cheap. Leave blank to reuse whatever the session is already talking to.",
+	"watchdog.cadenceToolCalls":
+		"Mid-turn firing is how scope drift becomes visible before the turn ends. Leave blank and the watchdog fires at turn end only.",
 	keybindings:
 		"Renderer controls: Alt+O newest tool or worker details, Ctrl+Alt+O or Alt+Shift+O all of them, Alt+P live tool output, Alt+R latest reasoning, Ctrl+Alt+R or Alt+Shift+R all reasoning. Override these in settings.yaml or use /help.",
 };
@@ -422,6 +443,14 @@ const SETTINGS_VALUE_HELP_BY_ID: Partial<Record<EditableSettingId, Record<string
 		auto: "show the scrollbar while scrolling or dragging",
 		always: "reserve the rightmost column for the scrollbar",
 	},
+	"terminal.notify": {
+		true: "post a content-free desktop notification on turn end, batch settlement, and a parked approval",
+		false: "never post a desktop notification",
+	},
+	"watchdog.enabled": {
+		true: "review every mutating turn with one read-only verifier run",
+		false: "no verifier run; a turn ends without a second opinion",
+	},
 	"terminal.smoothStreaming": {
 		off: "preserve the current immediate 16ms-coalesced streaming behavior",
 		auto: "pace only on a capable local TTY without accessibility or backpressure risk",
@@ -478,6 +507,13 @@ export interface SettingsCenterItem extends SettingItem {
 	help?: string;
 	valueHelp?: Record<string, string>;
 	defaultValue?: string;
+	/**
+	 * What a free-text editor opens with when it differs from the rendered
+	 * value. A row that renders its absence as prose such as `(session target)`
+	 * must not hand that prose to the editor, or the operator's typing lands
+	 * behind it and the placeholder is written into settings.yaml.
+	 */
+	editValue?: string;
 }
 
 export interface SettingsCenterSection {
@@ -657,14 +693,19 @@ function editTextSubmenu(title: string, note?: string): SettingSubmenuBuilder {
 	return textInputSubmenu(title, note);
 }
 
-function editNumberSubmenu(title: string): SettingSubmenuBuilder {
+function editNumberSubmenu(title: string, options: { min?: number; allowBlank?: boolean } = {}): SettingSubmenuBuilder {
+	const min = options.min ?? 0;
 	return (currentValue: string, done: (val?: string) => void) => {
 		const input = new Input();
 		input.setValue(currentValue);
 		input.focused = true;
 		input.onSubmit = (val) => {
+			if (options.allowBlank === true && val.trim().length === 0) {
+				done("");
+				return;
+			}
 			const num = Number(val);
-			if (Number.isFinite(num) && num >= 0) {
+			if (Number.isFinite(num) && num >= min) {
 				done(val);
 			} else {
 				done();
@@ -675,7 +716,9 @@ function editNumberSubmenu(title: string): SettingSubmenuBuilder {
 			title,
 			input,
 			buildHint([{ key: "Enter", verb: "confirm" }], "back"),
-			"Use a non-negative number.",
+			min > 0
+				? `Use a whole number of at least ${min}${options.allowBlank === true ? "; blank clears it" : ""}.`
+				: "Use a non-negative number.",
 		);
 	};
 }
@@ -1122,6 +1165,7 @@ function settingItem(
 		label?: string;
 		description?: string;
 		help?: string;
+		editValue?: string;
 	},
 ): SettingsCenterItem {
 	const item: SettingsCenterItem = {
@@ -1139,6 +1183,7 @@ function settingItem(
 	};
 	const help = options.help ?? SETTINGS_HELP_BY_ID[id];
 	if (help) item.help = help;
+	if (options.editValue !== undefined) item.editValue = options.editValue;
 	const valueHelp = SETTINGS_VALUE_HELP_BY_ID[id];
 	if (valueHelp) item.valueHelp = valueHelp;
 	const def = defaultValueFor(id);
@@ -1211,6 +1256,7 @@ export function buildSettingItems(
 	const compaction = settings.compaction;
 	const retry = settings.retry;
 	const terminal = settings.terminal;
+	const watchdog = settings.watchdog;
 	const orchestratorThinking = thinkingChoices(
 		options?.providers,
 		settings.orchestrator.target,
@@ -1411,10 +1457,36 @@ export function buildSettingItems(
 		settingItem("terminal.smoothStreaming", terminal.smoothStreaming, {
 			values: ["off", "auto", "on"],
 		}),
+		settingItem("terminal.notify", String(terminal.notify), {
+			values: ["false", "true"],
+		}),
 		settingItem("theme", settings.theme, {
 			affordance: "single clio-coder palette",
 			readOnly: true,
 		}),
+		settingItem("watchdog.enabled", String(watchdog.enabled), {
+			values: ["false", "true"],
+		}),
+		// Both optional keys render their absence rather than a fabricated value:
+		// an unset target means the session's own, and an unset cadence means the
+		// watchdog fires at turn end only. Submitting an empty value clears them.
+		settingItem("watchdog.target", watchdog.target ?? "(session target)", {
+			submenu: editTextSubmenu("Edit watchdog target; blank uses the session's active target"),
+			affordance: "free text",
+			editValue: watchdog.target ?? "",
+		}),
+		settingItem(
+			"watchdog.cadenceToolCalls",
+			watchdog.cadenceToolCalls === undefined ? "(turn end only)" : String(watchdog.cadenceToolCalls),
+			{
+				submenu: editNumberSubmenu("Edit watchdog cadence in tool calls; blank fires at turn end only", {
+					min: 1,
+					allowBlank: true,
+				}),
+				affordance: "free text",
+				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",
@@ -1898,6 +1970,31 @@ export function applySettingChange(settings: ClioSettings, id: string, value: st
 				settings.terminal.fullscreenScrollbar = value;
 			}
 			return;
+		case "terminal.notify":
+			if (value === "true" || value === "false") settings.terminal.notify = value === "true";
+			return;
+		case "watchdog.enabled":
+			if (value === "true" || value === "false") settings.watchdog.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
+		// the key rather than storing a blank keeps settings.yaml matching what the
+		// config validator accepts.
+		case "watchdog.target": {
+			const trimmed = value.trim();
+			if (trimmed) settings.watchdog.target = trimmed;
+			else delete settings.watchdog.target;
+			return;
+		}
+		case "watchdog.cadenceToolCalls": {
+			if (value.trim().length === 0) {
+				delete settings.watchdog.cadenceToolCalls;
+				return;
+			}
+			const parsed = Number(value);
+			if (Number.isFinite(parsed) && Math.floor(parsed) >= 1) settings.watchdog.cadenceToolCalls = Math.floor(parsed);
+			return;
+		}
 		case "terminal.smoothStreaming":
 			if (value === "off" || value === "auto" || value === "on") settings.terminal.smoothStreaming = value;
 			return;
@@ -2851,7 +2948,7 @@ export class SettingsCenter implements Component {
 		const item = this.selectedItem();
 		if (!item || item.readOnly) return;
 		if (item.submenu) {
-			this.submenuComponent = item.submenu(item.currentValue, (selectedValue) => {
+			this.submenuComponent = item.submenu(item.editValue ?? item.currentValue, (selectedValue) => {
 				this.submenuComponent = null;
 				if (selectedValue !== undefined) this.prepareScopeConfirm(item, selectedValue);
 				this.options.requestRender?.();