opencode-clm 0.3.0 → 0.4.0

package/src/clm.ts

@@ -7,6 +7,12 @@
  * during step k is read back and committed at the start of step k+1's transform, right
  * before the request it affects. As in pi-clm, the file content at that moment wins.
  *
+ * `mode notices-only` (`noticesOnly`) skips steps 1, 2 and 4: the accepted revision, if any,
+ * stays in state.json but is not applied, nothing is rendered or committed, and the request
+ * carries the raw history (reasoning view, cap and guard still apply) with every notice.
+ * Switching back to `edit` applies the kept revision again while it still matches the
+ * history; a mismatch then takes the usual restore-or-reset path.
+ *
  *   transform(raw)  0. pinned = everything up to and including the first user message;
  *                      source = flatten(rest), the raw prefix a checkpoint digests
  *                   1. commit: read the mirror; if it differs from the last render,
@@ -200,6 +206,12 @@ export class ClmSession {
 	accepted = 0;
 	rejected = 0;
 	limits: ModelLimits = {};
+	/**
+	 * Set once the system transform has seen the model, with or without a window. Until then
+	 * a fallback budget is provisional: the guard, fit gate, reminders and trailer stand down.
+	 * A model that reports no window keeps the fallback, which then applies in full.
+	 */
+	limitsKnown = false;
 	scope: RequestScope = {};
 	/** Set by `experimental.session.compacting`: the next transform carries OpenCode's compaction input. */
 	compacting = false;
@@ -306,6 +318,11 @@ export class ClmSession {
 		return this.overrides.editing ?? this.state.enabled;
 	}
 
+	/** `mode notices-only`: notices and the guard run, the model cannot edit its context. */
+	get noticesOnly(): boolean {
+		return this.settings.mode === "notices-only";
+	}
+
 	/** Base and effective values, for the settings table. */
 	settingsValues(): { base: SettingsValues; effective: SettingsValues } {
 		return {
@@ -321,7 +338,7 @@ export class ClmSession {
 			base: this.baseSettings,
 			baseEditing: this.state.enabled,
 			projectDirectory,
-			format: { modelWindow: this.limits.context },
+			format: { modelWindow: this.limits.context, modelOutput: this.limits.output },
 		};
 	}
 
@@ -378,18 +395,26 @@ export class ClmSession {
 		const before = this.settings.budget;
 		const after = staged.settings.budget;
 		const wasEnabled = this.enabled;
+		const wasMode = this.settings.mode;
 		const changed = JSON.stringify(this.overrides) !== JSON.stringify(overrides);
 		this.settings = staged.settings;
 		this.steering = staged.steering;
 		this.overrides = overrides;
-		if (before.contextBudget !== after.contextBudget || before.reserve !== after.reserve ||
+		if (before.contextBudget !== after.contextBudget || before.contextFraction !== after.contextFraction || before.reserve !== after.reserve ||
 			before.remindAtFractions.join(",") !== after.remindAtFractions.join(",") || before.remindAtReserve !== after.remindAtReserve) {
 			this.tracker.reset();
 		}
 		if (wasEnabled !== this.enabled) {
 			this.baseline = undefined;
+			this.tracker.clearCooldown();
 			if (!this.enabled) this.continuitySize.observe(0);
 		}
+		if (wasMode !== this.settings.mode) {
+			// The render the baseline holds no longer describes what the model is sent.
+			this.baseline = undefined;
+			this.lastSnapshot = undefined;
+			this.tracker.clearCooldown();
+		}
 		if (changed) await this.log({ event: "settings", overrides });
 	}
 
@@ -454,10 +479,10 @@ export class ClmSession {
 	}
 
 	/**
-	 * The budget in force: the configured one (or the model window), raised when the
+	 * The budget in force: the resolved one (`resolveBudget`), raised when the
 	 * session's budget check found it too small for OpenCode's fixed overhead (`budgetFit`).
 	 */
-	resolvedBudget(): Pick<BudgetReading, "budget" | "reserve" | "source" | "raisedFrom"> | undefined {
+	resolvedBudget(): Pick<BudgetReading, "budget" | "reserve" | "source" | "fraction" | "raisedFrom"> | undefined {
 		const base = resolveBudget(this.settings.budget, this.limits.context, this.limits.output);
 		if (!base) return undefined;
 		const fit = budgetFit(base.budget, base.reserve, this.state.budgetCheck?.overhead, this.windowCap());
@@ -466,7 +491,7 @@ export class ClmSession {
 
 	/** Model window minus its output limit, when known: the ceiling for a raised budget. */
 	private windowCap(): number | undefined {
-		return resolveBudget({ ...this.settings.budget, contextBudget: undefined }, this.limits.context, this.limits.output)?.budget;
+		return resolveBudget({ ...this.settings.budget, contextBudget: undefined, contextFraction: undefined }, this.limits.context, this.limits.output)?.budget;
 	}
 
 	/**
@@ -478,10 +503,19 @@ export class ClmSession {
 		return base ? budgetFit(base.budget, base.reserve, this.state.budgetCheck?.overhead, this.windowCap()) : undefined;
 	}
 
-	/** budget − reserve, or undefined while the budget is unknown. */
+	/**
+	 * budget − reserve: the limit the overflow guard enforces. Undefined while the budget is
+	 * unknown or a fallback (`FALLBACK_BUDGET`, model window not yet known): the guard then
+	 * withholds nothing.
+	 */
+	/** A fallback budget read before the model's limits arrived (see `limitsKnown`). */
+	private provisional(resolved: Pick<BudgetReading, "source">): boolean {
+		return resolved.source === "fallback" && !this.limitsKnown;
+	}
+
 	guardLimit(): number | undefined {
 		const resolved = this.resolvedBudget();
-		return resolved ? overflowGuardLimit(resolved.budget, resolved.reserve) : undefined;
+		return resolved && !this.provisional(resolved) ? overflowGuardLimit(resolved.budget, resolved.reserve) : undefined;
 	}
 
 	/**
@@ -555,7 +589,7 @@ export class ClmSession {
 			...(previous ? { replaces: previous.source, previousOverhead: previous.overhead } : {}),
 		});
 		if (!warn) return undefined;
-		this.pendingNotices.push(budgetTooSmallNoticeText(fit));
+		this.pendingNotices.push(budgetTooSmallNoticeText(fit, { noticesOnly: this.noticesOnly }));
 		return budgetTooSmallAlertText(fit);
 	}
 
@@ -597,6 +631,7 @@ export class ClmSession {
 	async setEnabled(enabled: boolean): Promise<void> {
 		await this.updateState((state) => ({ ...state, enabled }));
 		this.baseline = undefined;
+		this.tracker.clearCooldown();
 		if (!enabled) this.continuitySize.observe(0);
 	}
 
@@ -649,7 +684,7 @@ export class ClmSession {
 	 * calls that only read it or do not touch it.
 	 */
 	receipt(tool: string, args: Record<string, unknown> | undefined, cwd: string): string | undefined {
-		if (!this.settings.enabled || !this.enabled) return undefined;
+		if (!this.settings.enabled || !this.enabled || this.noticesOnly) return undefined;
 		if (classifyMirrorToolCall(tool, args ?? {}, cwd, this.mirrorPath) !== "write") return undefined;
 		const check = this.validateMirror(this.store.readSync());
 		if (!check) return undefined;
@@ -661,13 +696,15 @@ export class ClmSession {
 
 	/**
 	 * `setting trailer`: the size trailer for one tool result (the last reading plus the
-	 * result's calibrated estimate, against the budget in force); undefined when off.
+	 * result's calibrated estimate, against the budget in force); undefined when off or while
+	 * the budget is unknown or a provisional fallback.
 	 */
 	sizeTrailer(output: string): string | undefined {
 		if (!this.settings.enabled || !this.enabled || !this.settings.trailer || this.mirrorUnavailable !== undefined) return undefined;
-		const budget = this.resolvedBudget()?.budget;
-		if (!budget) return undefined;
-		return sizeTrailer(this.lastReading?.estimated ?? 0, this.calibrator.apply(this.textTokens(output)), budget);
+		const resolved = this.resolvedBudget();
+		// A fallback budget is a placeholder: "~N of 32,000" would report a limit nothing enforces.
+		if (!resolved || this.provisional(resolved)) return undefined;
+		return sizeTrailer(this.lastReading?.estimated ?? 0, this.calibrator.apply(this.textTokens(output)), resolved.budget);
 	}
 
 	/**
@@ -678,7 +715,7 @@ export class ClmSession {
 	 */
 	async commitBeforeCompaction(): Promise<void> {
 		await this.refreshSettings();
-		if (!this.settings.enabled || !this.enabled) return;
+		if (!this.settings.enabled || !this.enabled || this.noticesOnly) return;
 		await this.commit();
 	}
 
@@ -689,6 +726,7 @@ export class ClmSession {
 
 	/** The mirror block the model last saw, for continuity annotations. */
 	blockSource(blockId: string): ContinuityBlockSource | undefined {
+		if (this.noticesOnly) throw new Error("CLM runs in notices-only mode: there is no context mirror, so no block can be annotated.");
 		const snapshot = this.lastSnapshot;
 		const block = snapshot?.blocks.find((candidate) => candidate.id === blockId);
 		return snapshot && block ? { message: block.source, revision: snapshot.revision } : undefined;
@@ -761,6 +799,7 @@ export class ClmSession {
 			return;
 		}
 		this.accepted += 1;
+		this.tracker.editAccepted();
 		await this.remember({ version: 1, checkpoint, contentDigest: digestSourceContent(baseline.rawMessages) });
 		const revisions = join(this.store.directory, "revisions");
 		await mkdir(revisions, { recursive: true, mode: 0o700 }).catch(() => undefined);
@@ -1148,6 +1187,7 @@ export class ClmSession {
 			return { messages: raw, notices: [], ...this.drainAlerts() };
 		}
 		if (this.mirrorUnavailable !== undefined) return await this.transformWithoutMirror(raw);
+		const noticesOnly = this.noticesOnly;
 		const pinned = pinnedCount(raw);
 		const pinnedMessages = raw.slice(0, pinned);
 		const context = this.context(raw);
@@ -1158,15 +1198,23 @@ export class ClmSession {
 		// A pending edit was committed by `commitBeforeCompaction` just before.
 		if (this.compacting) {
 			this.compacting = false;
+			// notices-only: the summary is made from the history the model was sent, the raw one.
+			if (noticesOnly) return { messages: raw, notices: [], ...this.drainAlerts() };
 			const projection = applyProjection(flatten(raw.slice(pinned)), this.state.checkpoint);
 			if (!projection.valid || !this.state.checkpoint) return { messages: raw, notices: [], ...this.drainAlerts() };
 			return { messages: [...pinnedMessages, ...unflatten(projection.messages, context)], notices: [], ...this.drainAlerts() };
 		}
 
-		await this.commit();
+		if (noticesOnly) {
+			// No render to commit against; a mirror written meanwhile is never applied.
+			this.baseline = undefined;
+			this.lastSnapshot = undefined;
+		} else await this.commit();
 		this.requests += 1;
-		const compacted = this.compacted;
-		this.compacted = false;
+		// notices-only leaves a compaction signal pending: back in `edit`, the kept revision
+		// rebases onto the summary as it would have at the time.
+		const compacted = noticesOnly ? false : this.compacted;
+		if (!noticesOnly) this.compacted = false;
 
 		// The raw source prefix is digested as flattened, before any view, cap or guard.
 		const source = flatten(raw.slice(pinned));
@@ -1179,13 +1227,16 @@ export class ClmSession {
 		// overhead (built-in tool schemas) as undercounting; start calibration over.
 		if (measured?.source === "provider") this.calibrator.reset();
 
-		let projection = applyProjection(source, this.state.checkpoint);
+		// notices-only: the kept revision is ignored, not dropped (see the header comment).
+		let projection = applyProjection(source, noticesOnly ? undefined : this.state.checkpoint);
 		// A late or repeated compaction signal must not swallow a later revert: rebase only
 		// onto a summary the active checkpoint does not already cover.
 		const summaryId = compacted ? compactionSummaryId(raw) : undefined;
 		const rebase = summaryId !== undefined && !projection.valid && this.state.checkpoint !== undefined &&
 			!this.state.checkpoint.sourceIds.includes(summaryId);
-		if (rebase) {
+		if (noticesOnly) {
+			// Raw history: nothing to rebase, restore or reset.
+		} else if (rebase) {
 			await this.rebaseAfterCompaction(summaryId);
 			projection = applyProjection(source, undefined);
 		} else if (!projection.valid && (await this.restoreAfterMismatch(source, projection.reason))) {
@@ -1194,6 +1245,8 @@ export class ClmSession {
 			projection = applyProjection(source, this.state.checkpoint);
 		} else if (!projection.valid) {
 			const dropped = this.state.checkpoint?.revision;
+			// The edit the cooldown measures from no longer applies.
+			this.tracker.clearCooldown();
 			this.invalidationStreak += 1;
 			const reason = projection.reason;
 			await this.updateState((state) => resetProjectionState(state, reason), true).catch(() => undefined);
@@ -1213,10 +1266,10 @@ export class ClmSession {
 		}
 		const origin = this.forkOrigin;
 		this.forkOrigin = undefined;
-		if (origin && !this.state.checkpoint && this.state.revision === 0 && (await this.restoreFromFork(origin, source))) {
+		if (origin && !noticesOnly && !this.state.checkpoint && this.state.revision === 0 && (await this.restoreFromFork(origin, source))) {
 			projection = applyProjection(source, this.state.checkpoint);
 		}
-		const checkpoint = this.state.checkpoint;
+		const checkpoint = noticesOnly ? undefined : this.state.checkpoint;
 		const suffixLength = projection.valid ? projection.suffix.length : 0;
 
 		let effective = projection.messages;
@@ -1229,7 +1282,13 @@ export class ClmSession {
 			formatContinuityMessage({ annotations, effectiveMessages: messages });
 		const pinnedTokens = this.estimate(flatten(pinnedMessages));
 		const resolved = this.resolvedBudget();
-		const limit = resolved ? overflowGuardLimit(resolved.budget, resolved.reserve) : undefined;
+		// Model limits arrive one request late, so the first request of a process reads the
+		// FALLBACK_BUDGET placeholder. Withholding, reminding or refusing an edit against it is
+		// undone on the next request (a prompt-cache miss, a spurious notice, an edit the real
+		// budget would accept), so none acts on a fallback: `guardLimit()` is undefined, which
+		// also leaves the fit gate unlimited, as with no budget at all.
+		const limit = this.guardLimit();
+		const provisional = resolved !== undefined && this.provisional(resolved);
 		const { systemTokens, toolTokens } = this.scope;
 		const { measuredOverhead, scopeTokens } = this.scopeSize();
 		const excluded = measuredOverhead !== undefined ? [] : [
@@ -1253,7 +1312,7 @@ export class ClmSession {
 			if (guarded.withheld.length > 0) {
 				effective = guarded.messages;
 				withheldCount = guarded.withheld.length;
-				this.pendingNotices.push(overflowNoticeText(guarded, limit));
+				this.pendingNotices.push(overflowNoticeText(guarded, limit, { noticesOnly }));
 				await this.log({
 					event: "overflow-guard",
 					withheld: guarded.withheld.map((record) => ({ id: record.toolCallId, tokens: record.tokens, file: record.file })),
@@ -1268,30 +1327,33 @@ export class ClmSession {
 			this.pendingNotices.push(continuitySizeNoticeText(this.textTokens(continuity ?? "")));
 		}
 
-		const snapshot = renderContextDocument(effective, {
+		// notices-only: no mirror is rendered or written, so no edit can be validated or applied.
+		const snapshot = noticesOnly ? undefined : renderContextDocument(effective, {
 			revision: this.state.revision,
 			protectedIndexes: new Set<number>(),
 			// Constant until the next accepted edit or reset, so header ids read on one call
 			// remain valid on the next; bodies are escaped accordingly.
 			documentSeed: `${this.sessionID}:${this.nonce}:${checkpoint?.sourceDigest ?? "raw"}`,
 		});
-		try {
-			await this.store.write(snapshot.text);
-			this.refreshFailing = false;
-			this.lastSnapshot = snapshot;
-			this.baseline = {
-				rawMessages: source,
-				effectiveMessages: effective,
-				snapshot,
-				// The fit gate measures the editable context alone; the system prompt, tool
-				// schemas, pinned task and continuity message take their share of budget − reserve first.
-				limit: limit === undefined ? undefined : Math.max(1, limit - scopeTokens - pinnedTokens - continuityTokens),
-			};
-		} catch (error) {
-			this.baseline = undefined;
-			this.pendingNotices.push(`[CLM] Could not refresh the mirror: ${describe(error)}`);
-			if (!this.refreshFailing) this.pendingErrors.push(`could not refresh the mirror, edits are off until it can be written: ${describe(error)}`);
-			this.refreshFailing = true;
+		if (snapshot) {
+			try {
+				await this.store.write(snapshot.text);
+				this.refreshFailing = false;
+				this.lastSnapshot = snapshot;
+				this.baseline = {
+					rawMessages: source,
+					effectiveMessages: effective,
+					snapshot,
+					// The fit gate measures the editable context alone; the system prompt, tool
+					// schemas, pinned task and continuity message take their share of budget − reserve first.
+					limit: limit === undefined ? undefined : Math.max(1, limit - scopeTokens - pinnedTokens - continuityTokens),
+				};
+			} catch (error) {
+				this.baseline = undefined;
+				this.pendingNotices.push(`[CLM] Could not refresh the mirror: ${describe(error)}`);
+				if (!this.refreshFailing) this.pendingErrors.push(`could not refresh the mirror, edits are off until it can be written: ${describe(error)}`);
+				this.refreshFailing = true;
+			}
 		}
 
 		const conversationTokens = pinnedTokens + this.estimate(effective) + continuityTokens;
@@ -1307,10 +1369,16 @@ export class ClmSession {
 				// The measured request was answered inside the prefix the active revision replaced.
 				observedStale: observed !== undefined && checkpoint !== undefined && checkpoint.sourceIds.includes(observed.messageID),
 			};
-			const tier = this.tracker.observe(reading, budgetTiers(this.settings.budget, resolved.budget, resolved.reserve));
+			// A fallback reading skips the tracker: no tier fires or is marked fired, and a pending
+			// cooldown waits, so reminders start from the real budget once the window is known.
+			const { tier, suppressed, cooldownUntil } = provisional ? { tier: undefined, suppressed: [] } : this.tracker.check(
+				reading, budgetTiers(this.settings.budget, resolved.budget, resolved.reserve), this.settings.budget.reminderCooldown);
+			for (const skipped of suppressed) {
+				await this.log({ event: "budget-notice-suppressed", tier: skipped.label, estimated: reading.estimated, cooldownUntil });
+			}
 			if (tier) {
 				// With the guard off nothing is withheld, so the notice must not describe it.
-				this.pendingNotices.push(budgetNoticeText(reading, tier, this.mirrorPath, this.settings.guard === "off" ? null : limit));
+				this.pendingNotices.push(budgetNoticeText(reading, tier, noticesOnly ? undefined : this.mirrorPath, this.settings.guard === "off" ? null : limit, { noticesOnly }));
 				await this.log({ event: "budget-notice", tier: tier.label, estimated: reading.estimated });
 			}
 			this.lastReading = reading;
@@ -1338,7 +1406,7 @@ export class ClmSession {
 		}
 
 		this.previousRequest = { rawCount: raw.length, conversation: conversationTokens + this.calibrator.apply(this.noticeTokens(notices)) };
-		this.lastRequest = { rawMessages: raw.length, sentMessages: messages.length, mirrorBlocks: snapshot.blocks.length };
+		this.lastRequest = { rawMessages: raw.length, sentMessages: messages.length, mirrorBlocks: snapshot?.blocks.length ?? 0 };
 		if (this.settings.dumpRequests) {
 			const directory = join(this.store.directory, "requests");
 			await mkdir(directory, { recursive: true, mode: 0o700 }).catch(() => undefined);
@@ -1365,7 +1433,8 @@ export class ClmSession {
 			users: raw.filter((message) => message.info.role === "user").length,
 			raw: raw.length,
 			sent: messages.length,
-			blocks: snapshot.blocks.length,
+			blocks: snapshot?.blocks.length ?? 0,
+			...(noticesOnly ? { mode: "notices-only" } : {}),
 			withheld: withheldCount,
 			estimated: reading?.estimated ?? requestTokens,
 			observedPrevious: observed?.tokens,
@@ -1399,12 +1468,15 @@ export class ClmSession {
 	status(steering: SteeringDocument | undefined = this.steering): ClmStatus {
 		const checkpoint = this.state.checkpoint;
 		const { base, effective } = this.settingsValues();
-		const changed = changedSummary(base, effective, { modelWindow: this.limits.context });
+		const changed = changedSummary(base, effective, { modelWindow: this.limits.context, modelOutput: this.limits.output });
 		return {
 			...(changed ? { changed } : {}),
 			...(this.settingsWarning ? { settingsWarning: this.settingsWarning } : {}),
 			sessionID: this.sessionID,
-			mirrorPath: this.mirrorUnavailable === undefined ? this.mirrorPath : `unavailable, requests carry the raw history (${this.mirrorUnavailable})`,
+			mirrorPath: this.mirrorUnavailable !== undefined
+				? `unavailable, requests carry the raw history (${this.mirrorUnavailable})`
+				: this.noticesOnly ? "not used (mode notices-only)" : this.mirrorPath,
+			...(this.noticesOnly ? { mode: "notices-only" as const } : {}),
 			revision: this.state.revision,
 			accepted: this.accepted,
 			rejected: this.rejected,

package/src/compaction.ts

@@ -35,15 +35,20 @@ export function applyCompactionMode(config: { compaction?: { auto?: boolean } },
 }
 
 /** Toast after OpenCode compacted a session on its own. */
-export function nativeCompactionText(overflow: boolean, mode: CompactionMode): string {
+export function nativeCompactionText(overflow: boolean, mode: CompactionMode, noticesOnly = false): string {
 	const why = overflow ? "after the provider reported a context overflow" : "at its token threshold";
-	const hint = mode === "off" ? "" : " Set /clm config compaction off to keep the model's own edits instead.";
+	// In notices-only the model makes no edits a compaction could replace.
+	const hint = mode === "off" || noticesOnly ? "" : " Set /clm config compaction off to keep the model's own edits instead.";
 	return `OpenCode compacted this session ${why}; CLM continues from the summary.${hint}`;
 }
 
 /** Model notice when a provider overflow was not compacted because `compaction.auto` was false. */
-export function overflowNotCompactedText(mirrorPath: string): string {
-	return `[CLM] The provider rejected the last request as too long, and OpenCode's automatic compaction is off, so nothing was compacted. Shrink the context by editing ${mirrorPath}, or ask the user to run /compact.`;
+export function overflowNotCompactedText(mirrorPath: string | undefined): string {
+	const head = "[CLM] The provider rejected the last request as too long, and OpenCode's automatic compaction is off, so nothing was compacted.";
+	// undefined: `mode notices-only`, no mirror to edit.
+	return mirrorPath === undefined
+		? `${head} Ask the user to run /compact.`
+		: `${head} Shrink the context by editing ${mirrorPath}, or ask the user to run /compact.`;
 }
 
 /**
@@ -214,8 +219,11 @@ export function thresholdPausedText(count: number, usable: number, guardLimit: n
 }
 
 /** Model notice when `off` cancelled a threshold compaction (pi: notice and toast). */
-export function thresholdCancelledNoticeText(mirrorPath: string): string {
-	return `[CLM] OpenCode's automatic compaction (threshold) was cancelled: CLM manages this context. Free space by editing ${mirrorPath}.`;
+export function thresholdCancelledNoticeText(mirrorPath: string | undefined): string {
+	// undefined: `mode notices-only`, no mirror to edit.
+	return mirrorPath === undefined
+		? "[CLM] OpenCode's automatic compaction (threshold) was cancelled: CLM's compaction setting is off."
+		: `[CLM] OpenCode's automatic compaction (threshold) was cancelled: CLM manages this context. Free space by editing ${mirrorPath}.`;
 }
 
 /** Toast when `off` cancelled a threshold compaction. */

package/src/overflow.ts

@@ -195,7 +195,8 @@ export function applyOverflowGuard(messages: LiveContextMessage[], options: Appl
 	return { messages: current, withheld, estimated };
 }
 
-export function overflowNoticeText(result: OverflowGuardResult, limit: number): string {
+/** `noticesOnly` (`mode notices-only`): no mirror, so the text names no edit. */
+export function overflowNoticeText(result: OverflowGuardResult, limit: number, options: { noticesOnly?: boolean } = {}): string {
 	const count = result.withheld.length;
 	const files = result.withheld.filter((record) => record.file).length;
 	const list = result.withheld
@@ -205,8 +206,10 @@ export function overflowNoticeText(result: OverflowGuardResult, limit: number):
 	return (
 		`[CLM BUDGET] Overflow guard: the request would have exceeded the limit of ${limit.toLocaleString("en-US")} tokens, so ${count} tool result${count === 1 ? "" : "s"} ` +
 		`${count === 1 ? "was" : "were"} withheld from your context and replaced by notes${files > 0 ? " with file paths" : ""}: ${list}. ` +
-		`Estimated request is now ${result.estimated.toLocaleString("en-US")} tokens${fits ? "" : " and still over the limit; edit your context now"}. ` +
+		`Estimated request is now ${result.estimated.toLocaleString("en-US")} tokens${fits ? "" : options.noticesOnly ? " and still over the limit" : " and still over the limit; edit your context now"}. ` +
 		"Nothing was re-run; the full outputs are in the files named in the notes and in the session history. " +
-		"Free space by editing the context mirror, then re-read only the parts you need, e.g. with sed -n or grep."
+		(options.noticesOnly
+			? "Re-read only the parts you need, e.g. with sed -n or grep."
+			: "Free space by editing the context mirror, then re-read only the parts you need, e.g. with sed -n or grep.")
 	);
 }

package/src/panel/keys.ts

@@ -13,6 +13,7 @@ import {
 	effectiveZoom,
 	markerSelection,
 	maxScroll,
+	pageViewport,
 	revisionIndex,
 	settingsPage,
 	viewportHeight,
@@ -116,7 +117,7 @@ function clampSetting(model: PanelModel, index: number): number {
 
 function revealSetting(state: PanelState, model: PanelModel, size: PanelSize): PanelState {
 	const { focus } = settingsPage(model, state, contentWidth(size));
-	const viewport = viewportHeight(size);
+	const viewport = pageViewport(state, size);
 	let scroll = state.scroll;
 	if (focus < scroll) scroll = focus;
 	else if (focus >= scroll + viewport) scroll = focus - viewport + 1;
@@ -226,6 +227,15 @@ function step(state: PanelState, key: Key, model: PanelModel, size: PanelSize):
 	return { state };
 }
 
+/**
+ * The settings page with a result message pinned below it. The message takes body rows, so
+ * the selected row is scrolled back into view if the message would cover it.
+ */
+export function withMessage(state: PanelState, message: PanelState["message"], model: PanelModel, size: PanelSize): PanelState {
+	const next = { ...state, message };
+	return next.page === "settings" ? revealSetting(next, model, size) : next;
+}
+
 /** Applies one key. The result's scroll is clamped to the page. */
 export function reduce(state: PanelState, key: Key, model: PanelModel, size: PanelSize): ReduceResult {
 	const result = step(state, ALIASES[key] ?? key, model, size);

package/src/panel/model.ts

@@ -92,7 +92,7 @@ export interface BudgetView {
 	reserve?: number;
 	/** Overflow-guard limit (budget − reserve), from snapshot.json. */
 	limit?: number;
-	/** Where the budget came from (`config`, `model-window`). */
+	/** Where the budget came from (`config`, `model-window`, `window-fraction`, `fallback`). */
 	source?: string;
 	/** Fixed overhead per request (system prompt + tool schemas), tokens. */
 	overhead?: number;
@@ -130,6 +130,8 @@ export interface PanelModel {
 	mirrorPath: string;
 	/** The newest `mirror-unavailable` event's reason: the session runs without a mirror. */
 	mirrorUnavailable?: string;
+	/** The session runs `mode notices-only` (set by the caller from the settings in force). */
+	noticesOnly?: boolean;
 	/** Problems reading the files (corrupt JSON, skipped event lines). */
 	warnings: string[];
 }

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",
 	);