opencode-clm 0.3.0 → 0.4.1

package/src/panel/view.ts

@@ -52,6 +52,7 @@ const EDIT_TONE: Tone = "edit";
 const KEPT_PREVIEW_CHARACTERS = 2_000;
 const MIRROR_TEXT_MAX_LINES = 200;
 const MIRROR_UNAVAILABLE_TEXT = "No mirror: requests carry the raw history plus the continuity annotations; edits are off.";
+const NOTICES_ONLY_TEXT = "Mode notices-only: requests carry the raw history plus the budget notices; no mirror, so the model cannot edit its context (/clm config mode edit).";
 
 /** Body rows available for the page. */
 export function viewportHeight(size: PanelSize): number {
@@ -194,6 +195,8 @@ function overviewLines(model: PanelModel, state: PanelState, width: number, view
 		? text("Projection off: the model sees the raw history (/clm on).", "warning")
 		: model.mirrorUnavailable !== undefined
 		? text(MIRROR_UNAVAILABLE_TEXT, "warning")
+		: model.noticesOnly
+		? text(NOTICES_ONLY_TEXT, "warning")
 		: model.lastOutcome?.kind === "rejected"
 			? text(`Last edit rejected: ${model.lastOutcome.message}`, "warning")
 			: undefined;
@@ -478,12 +481,26 @@ export function settingsPage(model: PanelModel, state: PanelState, width: number
 	const row = settings.rows[selected]!;
 	if (row.description) lines.push([], ...wrapAll([text(row.description, "dim")], width));
 	lines.push([], ...wrapAll([text(row.choices?.length ? "Enter: next value" : "Enter: type a value", "dim")], width));
-	if (state.message) {
-		lines.push(...wrapAll([text(`${state.message.warning ? "⚠" : "✓"} ${state.message.text}`, state.message.warning ? "warning" : "success")], width));
-	}
 	return { lines, focus };
 }
 
+/**
+ * Lines pinned below the scrolling page: the settings page's result message ("✓ Budget:
+ * 20k"), so it stays on screen when the page is longer than the viewport. At most
+ * `viewport` − 1 lines, so one page line always shows.
+ */
+export function pinnedLines(state: PanelState, width: number, viewport: number): Line[] {
+	if (state.page !== "settings" || !state.message) return [];
+	const message = wrapAll([text(`${state.message.warning ? "⚠" : "✓"} ${state.message.text}`, state.message.warning ? "warning" : "success")], width);
+	return message.slice(0, Math.max(0, viewport - 1));
+}
+
+/** Body rows left for the scrolling page once the pinned lines take theirs. */
+export function pageViewport(state: PanelState, size: PanelSize): number {
+	const viewport = viewportHeight(size);
+	return Math.max(1, viewport - pinnedLines(state, contentWidth(size), viewport).length);
+}
+
 // ---- frame ---------------------------------------------------------------------------
 
 /** The whole page at `width` (unclipped; the frame scrolls it). */
@@ -514,7 +531,7 @@ export function helpText(model: PanelModel, state: PanelState, width: number): s
 }
 
 export function maxScroll(model: PanelModel, state: PanelState, size: PanelSize): number {
-	return Math.max(0, pageLines(model, state, contentWidth(size), viewportHeight(size)).length - viewportHeight(size));
+	return Math.max(0, pageLines(model, state, contentWidth(size), viewportHeight(size)).length - pageViewport(state, size));
 }
 
 /** The framed panel, exactly `size.height` lines of `size.width` cells. */
@@ -522,15 +539,18 @@ export function renderPanel(model: PanelModel, state: PanelState, size: PanelSiz
 	const width = Math.max(8, size.width);
 	const inner = width - 2;
 	const content = contentWidth({ width, height: size.height });
-	const viewport = viewportHeight(size);
-	const page = pageLines(model, state, content, viewport);
+	const body = viewportHeight(size);
+	const page = pageLines(model, state, content, body);
+	const pinned = pinnedLines(state, content, body);
+	const viewport = pageViewport(state, size);
 	const scroll = Math.max(0, Math.min(state.scroll, page.length - viewport));
-	const visible = page.slice(scroll, scroll + viewport);
-	while (visible.length < viewport) visible.push([]);
+	// The pinned lines follow the page directly when it fits, else sit at the bottom.
+	const visible = [...page.slice(scroll, scroll + viewport), ...pinned];
+	while (visible.length < body) visible.push([]);
 
 	const border = (value: string) => span(value, "border");
 	const row = (line: Line): Line => normalize([border("│"), span(" "), ...fit(line, inner - 1), border("│")]);
-	const title = ` Live Context Viewer · r${model.revision} `;
+	const title = ` Live Context Viewer · r${model.revision}${model.noticesOnly && model.enabled ? " · notices-only" : ""} `;
 	const titleText = truncate([span(title)], inner, "").map((part) => part.text).join("");
 	const left = Math.max(0, Math.floor((inner - titleText.length) / 2));
 	const right = Math.max(0, inner - titleText.length - left);

package/src/presentation.ts

@@ -98,6 +98,8 @@ export interface ClmStatus {
 	changed?: string;
 	/** Saved settings that could not be used. */
 	settingsWarning?: string;
+	/** Set in `mode notices-only`; absent in `edit`. */
+	mode?: "notices-only";
 }
 
 /** One line for a toast. */
@@ -105,7 +107,8 @@ export function statusLine(status: ClmStatus): string {
 	const size = status.reading
 		? ` · ${formatTokens(status.reading.estimated)} of ${formatTokens(status.reading.budget)} tok`
 		: "";
-	return `CLM r${status.revision} · ${status.accepted} accepted / ${status.rejected} rejected${size}`;
+	const mode = status.mode ? ` · mode ${status.mode}` : "";
+	return `CLM r${status.revision}${mode} · ${status.accepted} accepted / ${status.rejected} rejected${size}`;
 }
 
 /** Multi-line status for `/clm`. */
@@ -113,6 +116,7 @@ export function statusText(status: ClmStatus): string {
 	const lines = [
 		`CLM status for session ${status.sessionID}`,
 		`mirror: ${status.mirrorPath}`,
+		...(status.mode ? ["mode notices-only: budget notices and the overflow guard run; no mirror and no protocol prompt, so the model cannot edit its context"] : []),
 		`revision ${status.revision} · edits accepted ${status.accepted} · rejected ${status.rejected} · gate ${status.gate} · guard ${status.guard}`,
 		status.reading
 			? `${budgetSummaryLine(status.reading)} · model window ${status.modelWindow ? formatTokens(status.modelWindow) : "unknown"}`
@@ -121,7 +125,9 @@ export function statusText(status: ClmStatus): string {
 	if (status.fit) lines.push(budgetFitLine(status.fit));
 	const checkpoint = status.checkpoint;
 	lines.push(
-		checkpoint
+		checkpoint && status.mode
+			? `revision ${checkpoint.revision} kept but not applied in notices-only mode: the model sees the raw history`
+			: checkpoint
 			? `active revision ${checkpoint.revision}: covers ${checkpoint.anchorCount} raw messages; ~${formatTokens(checkpoint.beforeEstimate)}→${formatTokens(checkpoint.afterEstimate)} tokens when accepted`
 			: "no accepted edit: the model sees the raw history",
 	);

package/src/projection.ts

@@ -13,6 +13,15 @@
 // whole messages (ids change) or truncates the parts of a kept message (its toolCall and
 // toolResult disappear, so the digest changes); both still fail closed.
 //
+// One mismatch source is OpenCode's own late writes: it keeps updating message objects
+// after `experimental.chat.messages.transform` returns (an assistant message being
+// finalized, turn diffs attached to a user message). A checkpoint taken mid-turn digests
+// those still-mutable tail messages, and the late write flips the digest. `sourceStamps`
+// (per-message digest + captured `time.updated`) lets `applyProjection` attribute such a
+// mismatch to a post-capture OpenCode write and re-anchor the checkpoint to the stable
+// head instead of dropping the revision (see `reanchorTail`); anything not attributable
+// stays fail-closed.
+//
 // pi-clm's `recoverProjectionFromRetryErrors` is not ported. Pi writes failed assistant
 // responses to its session log but drops them from live state, so a resumed log hashes
 // differently. OpenCode keeps the error on the assistant message (`info.error`), and the
@@ -29,6 +38,19 @@ export const PROJECTION_SHORTER_REASON = "Raw context is shorter than the projec
 
 export type EstimateUnit = "characters" | "tokens";
 
+/** One source message's content digest plus the write time captured with it. */
+export interface SourceStamp {
+	digest: string;
+	updatedAt: number;
+	/**
+	 * Digest of the same message with OpenCode's `<system-reminder>` blocks removed
+	 * (whitespace-normalized). OpenCode appends and removes mode-change reminders on user
+	 * messages between requests without moving any write-time field; a change confined to
+	 * those blocks is attributable against this fingerprint.
+	 */
+	strippedDigest?: string;
+}
+
 export interface ProjectionCheckpoint {
 	version: 1;
 	revision: number;
@@ -38,6 +60,12 @@ export interface ProjectionCheckpoint {
 	sourceIds: string[];
 	/** `digestSourcePrefix` of those messages. */
 	sourceDigest: string;
+	/**
+	 * Per-message digest and captured write time (length is sourceMessageCount). Lets a
+	 * mismatch be attributed to specific messages and a late OpenCode write of the tail be
+	 * re-anchored instead of dropped; absent on checkpoints written by older versions.
+	 */
+	sourceStamps?: SourceStamp[];
 	projectedMessages: LiveContextMessage[];
 	beforeEstimate: number;
 	afterEstimate: number;
@@ -47,11 +75,21 @@ export interface ProjectionCheckpoint {
 	editTrace?: ContextEditTrace;
 }
 
+/** The trimmed anchor returned when a late tail rewrite was re-anchored instead of dropped. */
+export interface ProjectionReanchor {
+	sourceMessageCount: number;
+	sourceIds: string[];
+	sourceStamps: SourceStamp[];
+	sourceDigest: string;
+}
+
 export type ProjectionApplication =
 	| {
 			valid: true;
 			messages: LiveContextMessage[];
 			suffix: LiveContextMessage[];
+			/** Set when the anchor was trimmed to the stable head (see `reanchorTail`). */
+			reanchor?: ProjectionReanchor;
 	  }
 	| {
 			valid: false;
@@ -64,6 +102,60 @@ export function sourceMessageId(message: LiveContextMessage): string {
 	return typeof message.ocMessageID === "string" ? message.ocMessageID : "";
 }
 
+/** The prune-invariant form of one source message (see `digestSourcePrefix`). */
+function sourceDigestForm(message: LiveContextMessage): LiveContextMessage {
+	if (message.role !== "toolResult") return message;
+	return {
+		role: message.role,
+		toolCallId: message.toolCallId,
+		toolName: message.toolName,
+		isError: message.isError,
+		ocMessageID: message.ocMessageID,
+	};
+}
+
+const SYSTEM_REMINDER_RE = /<system-reminder>[\s\S]*?<\/system-reminder>/g;
+
+/** Whitespace-normalized text without OpenCode's reminder blocks, for the stripped fingerprint. */
+function normalizeReminderFingerprint(text: string): string {
+	return text
+		.replace(/\r\n/g, "\n")
+		.replace(SYSTEM_REMINDER_RE, "")
+		.replace(/\n{2,}/g, "\n\n")
+		.trim();
+}
+
+/**
+ * The message with OpenCode's `<system-reminder>` blocks removed from its text parts; parts
+ * that become empty are dropped. OpenCode appends and removes mode-change reminders on user
+ * messages between requests without touching any write-time field, so a digest over this
+ * form tells a reminder-only edit apart from a real content change.
+ */
+export function stripSystemReminders(message: LiveContextMessage): LiveContextMessage {
+	const content = message.content;
+	if (!Array.isArray(content)) return message;
+	const stripped: unknown[] = [];
+	for (const part of content) {
+		if (!part || typeof part !== "object") {
+			stripped.push(part);
+			continue;
+		}
+		const block = part as Record<string, unknown>;
+		if (block.type !== "text" || typeof block.text !== "string") {
+			stripped.push(block);
+			continue;
+		}
+		const text = normalizeReminderFingerprint(block.text);
+		if (text !== "") stripped.push({ ...block, text });
+	}
+	return { ...message, content: stripped };
+}
+
+/** `digestSourceMessage` of the message without OpenCode's system-reminder blocks. */
+export function digestSourceMessageWithoutReminders(message: LiveContextMessage): string {
+	return digestMessages([sourceDigestForm(stripSystemReminders(message))]);
+}
+
 /**
  * Digest a raw source prefix in a form OpenCode's prune cannot change: every `toolResult`
  * keeps only role, toolCallId, toolName, isError and ocMessageID. Content is dropped for
@@ -71,18 +163,22 @@ export function sourceMessageId(message: LiveContextMessage): string {
  * created and may be cleared when it is validated.
  */
 export function digestSourcePrefix(messages: readonly LiveContextMessage[]): string {
-	return digestMessages(
-		messages.map((message) => {
-			if (message.role !== "toolResult") return message;
-			return {
-				role: message.role,
-				toolCallId: message.toolCallId,
-				toolName: message.toolName,
-				isError: message.isError,
-				ocMessageID: message.ocMessageID,
-			};
-		}),
-	);
+	return digestMessages(messages.map(sourceDigestForm));
+}
+
+/** `digestSourcePrefix` of one message: per-message attribution for tail re-anchoring. */
+export function digestSourceMessage(message: LiveContextMessage): string {
+	return digestMessages([sourceDigestForm(message)]);
+}
+
+/** A message's stamp: its content digest, the write time OpenCode last wrote, and the
+ * reminder-stripped fingerprint. */
+export function sourceStamp(message: LiveContextMessage): SourceStamp {
+	return {
+		digest: digestSourceMessage(message),
+		updatedAt: typeof message.updatedAt === "number" ? message.updatedAt : 0,
+		strippedDigest: digestSourceMessageWithoutReminders(message),
+	};
 }
 
 /**
@@ -109,6 +205,7 @@ export function createProjectionCheckpoint(options: {
 		sourceMessageCount: options.sourceMessages.length,
 		sourceIds: options.sourceMessages.map(sourceMessageId),
 		sourceDigest: digestSourcePrefix(options.sourceMessages),
+		sourceStamps: options.sourceMessages.map(sourceStamp),
 		projectedMessages: [...options.projectedMessages],
 		beforeEstimate: options.beforeEstimate,
 		afterEstimate: options.afterEstimate,
@@ -124,7 +221,11 @@ export function createProjectionCheckpoint(options: {
 
 /**
  * Replace the checkpoint's raw source prefix and keep every raw message appended after
- * it. A mismatch fails closed and returns a copy of the untouched raw context.
+ * it. A mismatch fails closed and returns a copy of the untouched raw context — unless the
+ * checkpoint has per-message stamps and every changed message was written by OpenCode after
+ * it was captured (the current turn's tail still being finalized): then the anchor is
+ * trimmed to the stable head, the trimmed tail flows as ordinary suffix, and the caller
+ * persists `reanchor` on the checkpoint.
  */
 export function applyProjection(
 	rawMessages: readonly LiveContextMessage[],
@@ -147,8 +248,50 @@ export function applyProjection(
 		return { valid: false, messages: [...rawMessages], reason: PROJECTION_SOURCE_IDS_REASON };
 	}
 	if (digestSourcePrefix(prefix) !== checkpoint.sourceDigest) {
-		return { valid: false, messages: [...rawMessages], reason: PROJECTION_PREFIX_MISMATCH_REASON };
+		return reanchorTail(rawMessages, prefix, checkpoint) ??
+			{ valid: false, messages: [...rawMessages], reason: PROJECTION_PREFIX_MISMATCH_REASON };
 	}
 	const suffix = rawMessages.slice(checkpoint.sourceMessageCount);
 	return { valid: true, messages: [...checkpoint.projectedMessages, ...suffix], suffix };
 }
+
+/**
+ * A mismatch OpenCode itself caused. Every changed message must be explained by an
+ * OpenCode write: either its write time (`time.completed`/`updated`, not `created`) moved
+ * past the stamp, or the change is confined to OpenCode's `<system-reminder>` mode-change
+ * blocks (verified against the reminder-stripped per-message digest). That is the tail of
+ * the current turn still being finalized or a mode switch — not a revert, a compaction or
+ * a foreign transform, which change ids or content in ways neither check explains and stay
+ * fail-closed. The anchor is trimmed to the last stable message; the trimmed tail becomes
+ * ordinary suffix, the same contract as pi-clm's rebasing for appended messages.
+ */
+function reanchorTail(
+	rawMessages: readonly LiveContextMessage[],
+	prefix: readonly LiveContextMessage[],
+	checkpoint: ProjectionCheckpoint,
+): ProjectionApplication | undefined {
+	const stamps = checkpoint.sourceStamps;
+	if (!Array.isArray(stamps) || stamps.length !== prefix.length) return undefined;
+	const changed = prefix.map((message, index) => digestSourceMessage(message) !== stamps[index]!.digest);
+	const first = changed.indexOf(true);
+	if (first <= 0) return undefined;
+	const attributable = prefix.every((message, index) => {
+		if (!changed[index]) return true;
+		const stamp = stamps[index]!;
+		if (typeof message.updatedAt === "number" && message.updatedAt > stamp.updatedAt) return true;
+		// OpenCode appends and removes `<system-reminder>` blocks (mode changes) on user
+		// messages without moving any write time; a change confined to those blocks is still
+		// an OpenCode edit. Everything else fails closed.
+		return typeof stamp.strippedDigest === "string" && digestSourceMessageWithoutReminders(message) === stamp.strippedDigest;
+	});
+	if (!attributable) return undefined;
+	const stable = prefix.slice(0, first);
+	const reanchor: ProjectionReanchor = {
+		sourceMessageCount: stable.length,
+		sourceIds: stable.map(sourceMessageId),
+		sourceStamps: stable.map(sourceStamp),
+		sourceDigest: digestSourcePrefix(stable),
+	};
+	const suffix = rawMessages.slice(stable.length);
+	return { valid: true, messages: [...checkpoint.projectedMessages, ...suffix], suffix, reanchor };
+}

package/src/settings-table.ts

@@ -10,13 +10,13 @@
  */
 import { basename, resolve } from "node:path";
 
-import { resolveBudgetPolicy } from "./budget.ts";
+import { FALLBACK_BUDGET, formatPercent, resolveBudget, resolveBudgetPolicy, type BudgetPolicyConfig } from "./budget.ts";
 import { MIN_OBSERVATION_CAP, resolveObservationCap } from "./observation.ts";
 import { toEditGate, type EditGate } from "./policy.ts";
-import { HOUSE_STEERING, parseCompaction, parseFlag, parseFractions, parseTokens, type ClmSettings, type CompactionMode } from "./settings.ts";
+import { HOUSE_STEERING, parseBudget, parseCompaction, parseCooldown, parseFlag, parseFractions, parseMode, parseTokens, type ClmMode, type ClmSettings, type CompactionMode } from "./settings.ts";
 
 export type SettingKey =
-	| "editing" | "budget" | "reserve" | "reminders" | "gate" | "guard" | "compaction" | "cap" | "steering" | "oneTool" | "trailer"
+	| "editing" | "budget" | "reserve" | "reminders" | "cooldown" | "gate" | "guard" | "compaction" | "cap" | "steering" | "mode" | "oneTool" | "trailer"
 	| "compactPrompt" | "reasoning";
 
 /**
@@ -26,10 +26,13 @@ export type SettingKey =
  */
 export interface ClmOverrides {
 	editing?: boolean;
-	budget?: number | null;
+	/** Tokens, a share of the model window as text (`"50%"`), or null for the whole window. */
+	budget?: number | BudgetPercent | null;
 	reserve?: number;
 	/** Reminder fractions; empty disables every reminder, the budget − reserve one included. */
 	reminders?: number[];
+	/** Reminder cooldown as a share of the budget; 0 is off. */
+	cooldown?: number;
 	gate?: EditGate;
 	guard?: "withhold" | "off";
 	compaction?: CompactionMode;
@@ -42,8 +45,12 @@ export interface ClmOverrides {
 	reasoning?: boolean;
 	oneTool?: boolean;
 	trailer?: boolean;
+	mode?: ClmMode;
 }
 
+/** A budget percentage as stored in overrides.json: `"50%"`, `"12.5%"`. */
+export type BudgetPercent = `${number}%`;
+
 /** Settings in force for one session: the resolved settings plus whether edits apply. */
 export interface SettingsValues {
 	editing: boolean;
@@ -53,6 +60,8 @@ export interface SettingsValues {
 export interface FormatContext {
 	/** Model context window, shown next to a `window` budget. */
 	modelWindow?: number;
+	/** Model output limit; a percentage budget is a share of the window minus this. */
+	modelOutput?: number;
 }
 
 export interface ParseContext {
@@ -82,6 +91,24 @@ export function compactTokens(value: number): string {
 	return value.toLocaleString("en-US");
 }
 
+const percentText = (fraction: number) => formatPercent(fraction) as BudgetPercent;
+
+/** `"50%"` → 0.5; undefined for anything but a percentage from 1% to 100%. */
+export function budgetPercentFraction(value: unknown): number | undefined {
+	if (typeof value !== "string" || !/^\d+(?:\.\d+)?%$/.test(value)) return undefined;
+	const percent = Number(value.slice(0, -1));
+	return percent >= 1 && percent <= 100 ? percent / 100 : undefined;
+}
+
+/** The budget fields of a policy for a `budget` override. */
+function budgetFields(budget: number | BudgetPercent | null): Pick<BudgetPolicyConfig, "contextBudget" | "contextFraction"> {
+	if (budget === null) return { contextBudget: undefined, contextFraction: undefined };
+	if (typeof budget === "number") return { contextBudget: budget, contextFraction: undefined };
+	const fraction = budgetPercentFraction(budget);
+	if (fraction === undefined) throw new Error(`budget must be a percentage from 1% to 100%, got ${JSON.stringify(budget)}`);
+	return { contextBudget: undefined, contextFraction: fraction };
+}
+
 const onOff = (value: boolean) => (value ? "on" : "off");
 
 function formatReminders(fractions: readonly number[]): string {
@@ -138,19 +165,25 @@ export const SETTINGS_TABLE: readonly SettingDescriptor[] = [
 		key: "budget",
 		name: "budget",
 		label: "Budget",
-		description: "Token budget the reminders, the edit gate and the overflow guard measure against, OpenCode's system prompt and tool schemas included. A number (32k) or \"window\" for the model's context window. Env: CLM_BUDGET.",
-		placeholder: "32k, 1.5m, or window",
+		description: `Token budget the reminders, the edit gate and the overflow guard measure against, OpenCode's system prompt and tool schemas included. A percentage of the model window minus its output limit (50%; ${compactTokens(FALLBACK_BUDGET)} while the window is unknown), a number (32k), or "window" for all of it. Env: CLM_BUDGET.`,
+		placeholder: "50%, 32k, 1.5m, or window",
 		format: (values, context) => {
-			const budget = values.settings.budget.contextBudget;
-			if (budget !== undefined) return compactTokens(budget);
+			const policy = values.settings.budget;
+			if (policy.contextBudget !== undefined) return compactTokens(policy.contextBudget);
+			if (policy.contextFraction !== undefined) {
+				const resolved = context?.modelWindow ? resolveBudget(policy, context.modelWindow, context.modelOutput) : undefined;
+				return `${formatPercent(policy.contextFraction)}${resolved ? ` (${compactTokens(resolved.budget)})` : ""}`;
+			}
 			return `window${context?.modelWindow ? ` (${compactTokens(context.modelWindow)})` : ""}`;
 		},
+		// The settings page pre-fills its prompt with the formatted value: `50% (131,072)`.
 		parse: (text) => {
-			const value = text.trim().toLowerCase();
-			if (value === "window" || value === "model") return { budget: null };
-			const budget = parseTokens(value, "budget");
-			if (budget <= 0) throw new Error(`budget must be a positive number of tokens or "window", got "${text}"`);
-			return { budget };
+			const parsed = parseBudget(text.replace(/\s*\([^)]*\)\s*$/, ""), "budget");
+			switch (parsed.kind) {
+				case "window": return { budget: null };
+				case "fraction": return { budget: percentText(parsed.fraction) };
+				case "tokens": return { budget: parsed.tokens };
+			}
 		},
 	},
 	{
@@ -171,6 +204,17 @@ export const SETTINGS_TABLE: readonly SettingDescriptor[] = [
 		format: (values) => formatReminders(values.settings.budget.remindAtFractions),
 		parse: (text) => ({ reminders: parseReminders(text) }),
 	},
+	{
+		key: "cooldown",
+		// Named after the reminders it governs; `cooldown` is an alias.
+		name: "reminder-cooldown",
+		label: "Reminder cooldown",
+		description: "After an accepted edit, percentage reminders stay silent until the context grows by this share of the budget; tiers crossed meanwhile are skipped. The budget − reserve reminder always fires. A share (10%, 0.1) or off. Env: CLM_REMINDER_COOLDOWN.",
+		choices: ["10%", "25%", "5%", "off"],
+		placeholder: "10%, 0.1, or off",
+		format: (values) => (values.settings.budget.reminderCooldown > 0 ? formatPercent(values.settings.budget.reminderCooldown) : "off"),
+		parse: (text) => ({ cooldown: parseCooldown(text, "reminder-cooldown") }),
+	},
 	{
 		key: "gate",
 		name: "gate",
@@ -223,6 +267,15 @@ export const SETTINGS_TABLE: readonly SettingDescriptor[] = [
 			return { steering: parsePathSetting(text, context.directory, ["none", "off", ""]) };
 		},
 	},
+	{
+		key: "mode",
+		name: "mode",
+		label: "Mode",
+		description: "edit: the model edits its context through the mirror. notices-only: no mirror, no protocol prompt and no edits; budget notices and reminders, the overflow guard, the observation cap and the size trailer still apply, to compare telling the model its budget with letting it edit. An accepted revision is kept but not applied while notices-only is in force. Env: CLM_MODE.",
+		choices: ["edit", "notices-only"],
+		format: (values) => values.settings.mode,
+		parse: (text) => ({ mode: parseMode(text) }),
+	},
 	{
 		key: "oneTool",
 		name: "one-tool",
@@ -270,6 +323,9 @@ const ALIASES: Record<string, SettingKey> = {
 	remind: "reminders",
 	"remind-at": "reminders",
 	remindat: "reminders",
+	cooldown: "cooldown",
+	"reminder-cooldown": "cooldown",
+	remindercooldown: "cooldown",
 	gate: "gate",
 	"edit-gate": "gate",
 	guard: "guard",
@@ -290,6 +346,7 @@ const ALIASES: Record<string, SettingKey> = {
 	"compact-prompt": "compactPrompt",
 	compactprompt: "compactPrompt",
 	reasoning: "reasoning",
+	mode: "mode",
 };
 
 /** Names `/clm config` lists. */
@@ -313,10 +370,13 @@ export function unknownSettingText(name: string): string {
 export function applyOverrides(base: ClmSettings, overrides: ClmOverrides): ClmSettings {
 	const budget = resolveBudgetPolicy({
 		...base.budget,
-		contextBudget: overrides.budget === null ? undefined : overrides.budget ?? base.budget.contextBudget,
+		...(overrides.budget !== undefined
+			? budgetFields(overrides.budget)
+			: { contextBudget: base.budget.contextBudget, contextFraction: base.budget.contextFraction }),
 		reserve: overrides.reserve ?? base.budget.reserve,
 		remindAtFractions: overrides.reminders ?? base.budget.remindAtFractions,
 		remindAtReserve: overrides.reminders !== undefined ? overrides.reminders.length > 0 : base.budget.remindAtReserve,
+		reminderCooldown: overrides.cooldown ?? base.budget.reminderCooldown,
 	});
 	const observationCap = resolveObservationCap({
 		maxCharacters: overrides.cap === null ? undefined : overrides.cap ?? base.observationCap.maxCharacters,
@@ -330,6 +390,7 @@ export function applyOverrides(base: ClmSettings, overrides: ClmOverrides): ClmS
 		compaction: overrides.compaction ?? base.compaction,
 		oneTool: overrides.oneTool ?? base.oneTool,
 		trailer: overrides.trailer ?? base.trailer,
+		mode: overrides.mode ?? base.mode,
 		observationCap,
 		steeringPath: overrides.steering === null ? undefined : overrides.steering ?? base.steeringPath,
 		compactPromptPath: overrides.compactPrompt === null ? undefined : overrides.compactPrompt ?? base.compactPromptPath,
@@ -342,9 +403,11 @@ function baseValue(key: keyof ClmOverrides, values: SettingsValues): unknown {
 	const settings = values.settings;
 	switch (key) {
 		case "editing": return values.editing;
-		case "budget": return settings.budget.contextBudget ?? null;
+		case "budget": return settings.budget.contextBudget ??
+			(settings.budget.contextFraction !== undefined ? percentText(settings.budget.contextFraction) : null);
 		case "reserve": return settings.budget.reserve;
 		case "reminders": return settings.budget.remindAtReserve || settings.budget.remindAtFractions.length > 0 ? [...settings.budget.remindAtFractions] : [];
+		case "cooldown": return settings.budget.reminderCooldown;
 		case "gate": return settings.gate;
 		case "guard": return settings.guard;
 		case "compaction": return settings.compaction;
@@ -355,6 +418,7 @@ function baseValue(key: keyof ClmOverrides, values: SettingsValues): unknown {
 		case "steering": return settings.steeringPath ?? null;
 		case "compactPrompt": return settings.compactPromptPath ?? null;
 		case "reasoning": return settings.reasoning;
+		case "mode": return settings.mode;
 	}
 }
 
@@ -366,7 +430,7 @@ function baseValue(key: keyof ClmOverrides, values: SettingsValues): unknown {
  */
 export function settingsAsOverrides(settings: ClmSettings): ClmOverrides {
 	const values: SettingsValues = { editing: true, settings };
-	const keys: Array<keyof ClmOverrides> = ["budget", "reserve", "reminders", "gate", "guard", "compaction", "cap", "capHead", "steering", "oneTool", "trailer", "compactPrompt", "reasoning"];
+	const keys: Array<keyof ClmOverrides> = ["budget", "reserve", "reminders", "cooldown", "gate", "guard", "compaction", "cap", "capHead", "steering", "mode", "oneTool", "trailer", "compactPrompt", "reasoning"];
 	return Object.fromEntries(keys.map((key) => [key, baseValue(key, values)])) as ClmOverrides;
 }
 
@@ -385,9 +449,10 @@ const isPath = (value: unknown) => value === null || (typeof value === "string"
 const VALID: Record<keyof ClmOverrides, (value: unknown) => boolean> = {
 	editing: (value) => typeof value === "boolean",
 	// Integers: state.json's budget check stores them as counts.
-	budget: (value) => value === null || (Number.isInteger(value) && (value as number) > 0),
+	budget: (value) => value === null || (Number.isInteger(value) && (value as number) > 0) || budgetPercentFraction(value) !== undefined,
 	reserve: (value) => Number.isInteger(value) && (value as number) >= 0,
 	reminders: (value) => Array.isArray(value) && value.every((fraction) => isNumber(fraction) && fraction > 0 && fraction < 1),
+	cooldown: (value) => isNumber(value) && value >= 0 && value < 1,
 	gate: (value) => value === "fit" || value === "shrink" || value === "none",
 	guard: (value) => value === "withhold" || value === "off",
 	compaction: (value) => value === "auto" || value === "off" || value === "on",
@@ -398,6 +463,7 @@ const VALID: Record<keyof ClmOverrides, (value: unknown) => boolean> = {
 	steering: isPath,
 	compactPrompt: isPath,
 	reasoning: (value) => typeof value === "boolean",
+	mode: (value) => value === "edit" || value === "notices-only",
 };
 
 /**