one-code-extension 0.5.0 → 0.6.0

package/extensions/mcp/announce.ts

@@ -1,24 +1,21 @@
 /**
- * What to tell the model when MCP state changes after the first request (pure).
+ * What to tell the model when MCP state changes inside an epoch (pure).
  *
  * The MCP instructions and failed-servers reminders are `first-prepend` blocks
- * on message 1. Before the first request they are simply (re)written; after it
- * message 1 is part of every request's cached prefix, so they are FROZEN and
- * changes ride one-shot notices where the model reads next (same rule as the
- * deferred-tools listing, tool-search/announce.ts). `McpAnnounced` records what
- * the model has been told; `mcpDelta` compares it with the live state.
+ * on message 1. A request that opens an epoch renders them from live state;
+ * inside an epoch message 1 is the record (extensions/ledger), so changes ride
+ * notices on the request's tail, decided when the request goes out from what
+ * the epoch has told (the same rule as the deferred-tools listing). What was
+ * told is a whole-text block fact per server (`mcp-instructed:<name>`,
+ * `mcp-failed:<name>`): the hash of the instructions or error last told, or of
+ * the empty text once a drop or a recovery was announced.
  */
 
 import { mcpFailuresReminder, mcpInstructionsReminder } from "./client.ts";
+import type { BlockFact, ToldFact } from "../lib/ledger/records.ts";
+import { toldBlockFact } from "../lib/reminders.ts";
 import { countNoun } from "../lib/tui-render.ts";
 
-export interface McpAnnounced {
-	/** Servers whose instructions the model has been given, with the text it saw. */
-	instructed: Map<string, string>;
-	/** Servers the model has been told failed, with the error it saw. */
-	failed: Map<string, string>;
-}
-
 export interface McpSnapshot {
 	connected: Array<{ name: string; instructions?: string }>;
 	failed: Array<{ name: string; error: string }>;
@@ -33,16 +30,19 @@ export interface McpDelta {
 	recovered: string[];
 	/** Servers whose instructions the model saw that are no longer connected and not reported failed. */
 	dropped: string[];
+	/** What announcing this delta tells, for the request that carries it. */
+	facts: ToldFact[];
 }
 
-export function emptyAnnounced(): McpAnnounced {
-	return { instructed: new Map(), failed: new Map() };
-}
+const INSTRUCTED = "mcp-instructed:";
+const FAILED = "mcp-failed:";
+/** The told hash of "nothing": a drop or a recovery was announced. */
+const NONE = toldBlockFact("", "").hash;
 
 /**
  * Store and compare the exact bounded values the reminder puts on the wire.
  * A changing tail beyond either cap is not a model-visible capability change
- * and must not become a false resume addendum.
+ * and must not become a false notice.
  */
 function displayedInstructions(name: string, instructions: string): string {
 	const rendered = mcpInstructionsReminder([{ server: { name }, instructions }]);
@@ -53,95 +53,60 @@ function displayedFailure(error: string): string {
 	return error.split("\n")[0].slice(0, 300);
 }
 
-/** Maps are serialized as entry arrays so arbitrary server instructions/errors round-trip exactly. */
-export interface McpAnnouncedBaseline { instructed: Array<[string, string]>; failed: Array<[string, string]> }
-export function serializeMcpAnnounced(announced: McpAnnounced): McpAnnouncedBaseline {
-	return { instructed: [...announced.instructed], failed: [...announced.failed] };
-}
-/**
- * Best-effort compatibility reader for stacks written before structured MCP
- * baselines. With the configured server `names`, a section starts only at a
- * `## <name>` heading, so a `## ` heading inside a server's instructions stays
- * part of them instead of reading as a server of its own.
- */
-export function mcpAnnouncedFromReminders(instructions: string | undefined, failures: string | undefined, names?: Iterable<string>): McpAnnounced {
-	const announced = emptyAnnounced();
-	const known = names ? new Set(names) : undefined;
-	const instructionPrefix = "# MCP Server Instructions\n\nThe following MCP servers have provided instructions for how to use their tools and resources:\n\n";
-	if (instructions?.startsWith(instructionPrefix)) {
-		const sections: string[] = [];
-		for (const section of instructions.slice(instructionPrefix.length).split("\n\n## ")) {
-			const normalized = section.startsWith("## ") ? section.slice(3) : section;
-			const newline = normalized.indexOf("\n");
-			const heading = newline > 0 ? normalized.slice(0, newline) : normalized;
-			if (known && sections.length > 0 && !known.has(heading)) sections[sections.length - 1] += `\n\n## ${normalized}`;
-			else sections.push(normalized);
-		}
-		for (const section of sections) {
-			const newline = section.indexOf("\n");
-			if (newline > 0) announced.instructed.set(section.slice(0, newline), section.slice(newline + 1));
-		}
-	}
-	const failurePrefix = "The following MCP servers are configured but failed to connect — their tools (typically named mcp__<server>__*) are unavailable for this session:\n";
-	if (failures?.startsWith(failurePrefix)) {
-		for (const line of failures.slice(failurePrefix.length).split("\n")) {
-			if (!line.startsWith("- ")) break;
-			const colon = line.indexOf(": ", 2);
-			if (colon > 2) announced.failed.set(line.slice(2, colon), line.slice(colon + 2));
-		}
-	}
-	return announced;
-}
+const instructedFact = (name: string, instructions: string): BlockFact => toldBlockFact(INSTRUCTED + name, displayedInstructions(name, instructions));
+const failedFact = (name: string, error: string): BlockFact => toldBlockFact(FAILED + name, displayedFailure(error));
 
-export function mcpAnnouncedBaseline(value: unknown): McpAnnounced | undefined {
-	if (!value || typeof value !== "object" || Array.isArray(value)) return undefined;
-	const input = value as Record<string, unknown>;
-	const pairs = (item: unknown): Array<[string, string]> | undefined =>
-		Array.isArray(item) && item.every((pair) => Array.isArray(pair) && pair.length === 2 && typeof pair[0] === "string" && typeof pair[1] === "string")
-			? item as Array<[string, string]>
-			: undefined;
-	const instructed = pairs(input.instructed);
-	const failed = pairs(input.failed);
-	return instructed && failed ? { instructed: new Map(instructed), failed: new Map(failed) } : undefined;
+/** What message 1's two MCP blocks rendered from `snapshot` tell. */
+export function mcpFacts(snapshot: McpSnapshot): ToldFact[] {
+	return [
+		...snapshot.connected.flatMap((c) => (c.instructions ? [instructedFact(c.name, c.instructions)] : [])),
+		...snapshot.failed.map((f) => failedFact(f.name, f.error)),
+	];
 }
 
-/** What message 1 says after it was (re)written from `snapshot`, before the first request. */
-export function announcedFrom(snapshot: McpSnapshot): McpAnnounced {
-	return {
-		instructed: new Map(
-			snapshot.connected.filter((c) => c.instructions).map((c) => [c.name, displayedInstructions(c.name, c.instructions as string)]),
-		),
-		failed: new Map(snapshot.failed.map((f) => [f.name, displayedFailure(f.error)])),
-	};
-}
-
-export function mcpDelta(announced: McpAnnounced, snapshot: McpSnapshot): McpDelta {
+/**
+ * What changed since the epoch told `told` (whole-text block hashes by key),
+ * and the facts announcing it tells. While the startup connections are still
+ * `settling`, a server not connected yet is not a drop, and neither is one in
+ * `connecting` (a reconnect in flight).
+ */
+export function mcpDelta(told: ReadonlyMap<string, string>, snapshot: McpSnapshot, settling = false, connecting: ReadonlySet<string> = new Set()): McpDelta {
 	const connectedNames = new Set(snapshot.connected.map((c) => c.name));
-	const failedNames = new Set(snapshot.failed.map((f) => f.name));
+	// One failure per server (the latest): two kept errors would alternate as the told fact.
+	const failed = [...new Map(snapshot.failed.map((f) => [f.name, f])).values()];
+	const failedNames = new Set(failed.map((f) => f.name));
+	const toldNames = (prefix: string) => [...told].filter(([key, hash]) => key.startsWith(prefix) && hash !== NONE).map(([key]) => key.slice(prefix.length));
+	const newInstructions = snapshot.connected
+		.filter((c) => c.instructions && told.get(INSTRUCTED + c.name) !== instructedFact(c.name, c.instructions).hash)
+		.map((c) => ({ name: c.name, instructions: displayedInstructions(c.name, c.instructions as string) }));
+	const newFailures = failed
+		.filter((f) => told.get(FAILED + f.name) !== failedFact(f.name, f.error).hash)
+		.map((f) => ({ name: f.name, error: displayedFailure(f.error) }));
+	const recovered = toldNames(FAILED).filter((name) => connectedNames.has(name));
+	const dropped = settling ? [] : toldNames(INSTRUCTED).filter((name) => !connectedNames.has(name) && !failedNames.has(name) && !connecting.has(name));
 	return {
-		newInstructions: snapshot.connected
-			.filter((c) => c.instructions && announced.instructed.get(c.name) !== displayedInstructions(c.name, c.instructions as string))
-			.map((c) => ({ name: c.name, instructions: displayedInstructions(c.name, c.instructions as string) })),
-		newFailures: snapshot.failed
-			.filter((f) => announced.failed.get(f.name) !== displayedFailure(f.error))
-			.map((f) => ({ name: f.name, error: displayedFailure(f.error) })),
-		recovered: [...announced.failed.keys()].filter((name) => connectedNames.has(name)),
-		dropped: [...announced.instructed.keys()].filter((name) => !connectedNames.has(name) && !failedNames.has(name)),
+		newInstructions,
+		newFailures,
+		recovered,
+		dropped,
+		facts: [
+			...newInstructions.map((s) => toldBlockFact(INSTRUCTED + s.name, s.instructions)),
+			...newFailures.map((f) => toldBlockFact(FAILED + f.name, f.error)),
+			...recovered.map((name) => toldBlockFact(FAILED + name, "")),
+			...dropped.map((name) => toldBlockFact(INSTRUCTED + name, "")),
+		],
 	};
 }
 
-export function applyMcpDelta(announced: McpAnnounced, delta: McpDelta): void {
-	for (const s of delta.newInstructions) announced.instructed.set(s.name, s.instructions);
-	for (const f of delta.newFailures) announced.failed.set(f.name, f.error);
-	for (const name of delta.recovered) announced.failed.delete(name);
-	for (const name of delta.dropped) announced.instructed.delete(name);
-}
-
-/** One-shot notice texts for a delta, in the order they should be queued. Empty when nothing changed. */
+/**
+ * The notices for a delta, in the order they go on the tail. Empty when
+ * nothing changed.
+ */
 export function mcpChangeNotices(delta: McpDelta): string[] {
 	const notices: string[] = [];
+	const add = (text: string) => notices.push(text);
 	if (delta.recovered.length > 0) {
-		notices.push(
+		add(
 			`MCP server${delta.recovered.length === 1 ? "" : "s"} ${delta.recovered.join(", ")} ` +
 				"connected after this conversation started (an earlier notice reported a connection failure). " +
 				"The server's tools are available as deferred tools — load them with tool_search.",
@@ -149,17 +114,17 @@ export function mcpChangeNotices(delta: McpDelta): string[] {
 	}
 	if (delta.newInstructions.length > 0) {
 		const names = delta.newInstructions.map((s) => s.name);
-		notices.push(
+		add(
 			`MCP server${names.length === 1 ? "" : "s"} ${names.join(", ")} connected after this conversation started; ` +
 				"the tools are available as deferred tools (load with tool_search). Server instructions:\n\n" +
 				mcpInstructionsReminder(delta.newInstructions.map((s) => ({ server: { name: s.name }, instructions: s.instructions }))),
 		);
 	}
 	if (delta.newFailures.length > 0) {
-		notices.push(mcpFailuresReminder(delta.newFailures));
+		add(mcpFailuresReminder(delta.newFailures));
 	}
 	if (delta.dropped.length > 0) {
-		notices.push(
+		add(
 			`MCP server${delta.dropped.length === 1 ? "" : "s"} ${delta.dropped.join(", ")} disconnected; ` +
 				'their tools answer "not connected" until the server is reconnected (the user can do that in /mcp).',
 		);

package/extensions/mcp/index.ts

@@ -36,7 +36,7 @@ import {
 	readResource,
 	readResourceDir,
 } from "./client.ts";
-import { CONTEXT_ORDER, REMINDER_CHANNEL } from "../lib/reminders.ts";
+import { CONTEXT_ORDER, REMINDER_CHANNEL, RENDER_CHANNEL, type RenderRequest } from "../lib/reminders.ts";
 import { join } from "node:path";
 import {
 	MCP_STATUS_CHANNEL,
@@ -49,8 +49,7 @@ import { readDisabledMcpServers, setMcpServerDisabled } from "../lib/mcp-overrid
 import { boundedDockHeight, safeThemeBold, safeThemePaint, truncateLine } from "../lib/tui-render.ts";
 import { authenticate as runOAuthFlow, silentProvider } from "./oauth/flow.ts";
 import { hasStoredTokens } from "./oauth/store.ts";
-import { announcedFrom, applyMcpDelta, emptyAnnounced, mcpAnnouncedBaseline, mcpAnnouncedFromReminders, mcpChangeNotices, mcpDelta, serializeMcpAnnounced, type McpAnnounced, type McpSnapshot, mcpStartupNotices } from "./announce.ts";
-import { CONTEXT_BASELINE_CHANNEL, restoredContext } from "../lib/context-stack.ts";
+import { mcpChangeNotices, mcpDelta, mcpFacts, type McpSnapshot, mcpStartupNotices } from "./announce.ts";
 import { decodeMcpKey } from "./panel/keys.ts";
 import { type McpEntry, type McpEntryStatus } from "./panel/model.ts";
 import { renderMcpPanel, type McpPaint } from "./panel/render.ts";
@@ -115,16 +114,6 @@ export default function mcpExtension(pi: ExtensionAPI) {
 	// Live tool definitions, shared with in-process subagents so they reach MCP
 	// through these same open connections instead of connecting their own.
 	const sharedTools: ToolDefinition[] = [];
-	// Message 1 carries the MCP instructions and failed-servers reminders. Once a
-	// request has gone out it is part of every later request's cached prefix, so
-	// those blocks are frozen and later changes ride one-shot notices (./announce.ts).
-	let requestSent = false;
-	let announced = emptyAnnounced();
-	/** A resumed snapshot from before structured baselines: its MCP blocks, until the server names are known. */
-	let legacyBlocks: { instructions?: string; failures?: string } | undefined;
-	pi.on("context", () => {
-		requestSent = true;
-	});
 
 	/**
 	 * Where oversized results are persisted — the session dir, matching Claude
@@ -293,10 +282,13 @@ export default function mcpExtension(pi: ExtensionAPI) {
 		if (connection.resources.length > 0 || connection.resourceTemplates?.length) registerResourceTools();
 	};
 
+	/** Servers with a connect in flight (startup, a reconnect, an authenticate): not dropped while it runs. */
+	const connectingNames = new Set<string>();
 	const connectOne = async (server: McpServer): Promise<void> => {
 		failures = failures.filter((f) => f.server.name !== server.name);
 		oauthNeeded.delete(server.name);
 		const provider = server.kind === "http" && hasStoredTokens(server) ? silentProvider(server) : undefined;
+		connectingNames.add(server.name);
 		try {
 			const connection = await connect(server, provider);
 			if (!alive()) {
@@ -308,6 +300,8 @@ export default function mcpExtension(pi: ExtensionAPI) {
 			if (!alive()) return;
 			if (server.kind === "http" && isUnauthorized(error)) oauthNeeded.add(server.name);
 			else failures.push({ server, error: (error as Error).message });
+		} finally {
+			connectingNames.delete(server.name);
 		}
 	};
 
@@ -317,66 +311,53 @@ export default function mcpExtension(pi: ExtensionAPI) {
 	 * which servers failed — otherwise it concludes the tools do not exist or the
 	 * user has no access instead of reporting a connection failure the user can
 	 * fix (review M4). Re-run on every connect, close, reconnect, authenticate,
-	 * enable and disable. Before the first request the two first-prepend blocks on
-	 * message 1 are (re)written; after it they are frozen and only the changes are
-	 * announced (./announce.ts).
+	 * enable and disable. The two first-prepend blocks are live state: what an
+	 * epoch's message 1 says. Inside an epoch the render step below announces
+	 * only what changed since the epoch told it (./announce.ts).
 	 */
-	const publishBaseline = (value: McpAnnounced) => {
-		pi.events.emit(CONTEXT_BASELINE_CHANNEL, { key: "mcp", value: serializeMcpAnnounced(value) });
-	};
+	const liveSnapshot = (): McpSnapshot => ({
+		connected: [...connections.values()].map((c) => ({ name: c.server.name, instructions: c.instructions })),
+		failed: failures.filter((f) => !connections.has(f.server.name)).map((f) => ({ name: f.server.name, error: f.error })),
+	});
 	const emitInstructions = () => {
 		const live = [...connections.values()];
-		const snapshot: McpSnapshot = {
-			connected: live.map((c) => ({ name: c.server.name, instructions: c.instructions })),
-			failed: failures.filter((f) => !connections.has(f.server.name)).map((f) => ({ name: f.server.name, error: f.error })),
-		};
-
-		if (!requestSent) {
-			// Nothing is cached yet: (re)write the standing message-1 blocks.
-			const nextAnnounced = announcedFrom(snapshot);
-			publishBaseline(nextAnnounced);
-			if (snapshot.failed.length === 0) {
-				pi.events.emit(REMINDER_CHANNEL, { scope: "every-turn", key: "mcp-failures", text: "", remove: true });
-			} else {
-				pi.events.emit(REMINDER_CHANNEL, {
-					scope: "every-turn",
-					key: "mcp-failures",
-					text: mcpFailuresReminder(snapshot.failed),
-					placement: "first-prepend",
-					order: CONTEXT_ORDER.mcp + 1,
-				});
-			}
-			const instructions = mcpInstructionsReminder(live);
-			if (instructions) {
-				pi.events.emit(REMINDER_CHANNEL, {
-					scope: "every-turn",
-					key: "mcp-instructions",
-					text: instructions,
-					placement: "first-prepend",
-					order: CONTEXT_ORDER.mcp,
-				});
-			} else {
-				// No server has instructions anymore (e.g. the last one was disabled or
-				// disconnected) — drop the stale every-turn reminder so the model stops
-				// being told to use tools that are gone.
-				pi.events.emit(REMINDER_CHANNEL, { scope: "every-turn", key: "mcp-instructions", text: "", remove: true });
-			}
-			announced = nextAnnounced;
-			return;
+		const snapshot = liveSnapshot();
+		if (snapshot.failed.length === 0) {
+			pi.events.emit(REMINDER_CHANNEL, { key: "mcp-failures", text: "", remove: true });
+		} else {
+			pi.events.emit(REMINDER_CHANNEL, {
+				key: "mcp-failures",
+				text: mcpFailuresReminder(snapshot.failed),
+				placement: "first-prepend",
+				order: CONTEXT_ORDER.mcp + 1,
+				facts: mcpFacts({ connected: [], failed: snapshot.failed }),
+			});
 		}
-
-		// Message 1 is frozen (rewriting it would re-cache the whole conversation):
-		// tell the model only what changed, as one-shots where it reads next.
-		const delta = mcpDelta(announced, snapshot);
-		const notices = mcpChangeNotices(delta);
-		if (notices.length > 0) {
-			const nextAnnounced = { instructed: new Map(announced.instructed), failed: new Map(announced.failed) };
-			applyMcpDelta(nextAnnounced, delta);
-			publishBaseline(nextAnnounced);
+		const instructions = mcpInstructionsReminder(live);
+		if (instructions) {
+			pi.events.emit(REMINDER_CHANNEL, {
+				key: "mcp-instructions",
+				text: instructions,
+				placement: "first-prepend",
+				order: CONTEXT_ORDER.mcp,
+				facts: mcpFacts({ connected: snapshot.connected, failed: [] }),
+			});
+		} else {
+			// No server has instructions anymore (e.g. the last one was disabled or
+			// disconnected) — drop the stale block so an epoch does not tell the
+			// model to use tools that are gone.
+			pi.events.emit(REMINDER_CHANNEL, { key: "mcp-instructions", text: "", remove: true });
 		}
-		for (const text of notices) pi.events.emit(REMINDER_CHANNEL, { text });
-		applyMcpDelta(announced, delta);
 	};
+	// Inside an epoch, what changed since message 1 (or the last notice) rides
+	// the request's tail, decided when the request goes out.
+	pi.events.on(RENDER_CHANNEL, (data) => {
+		const request = data as RenderRequest;
+		if (request.epoch) return;
+		const delta = mcpDelta(request.toldBlocks, liveSnapshot(), !connectSettled, connectingNames);
+		const notices = mcpChangeNotices(delta);
+		notices.forEach((text, i) => request.blocks.push({ text, ...(i === 0 ? { facts: delta.facts } : {}) }));
+	});
 
 	/** Config files that exist but failed to parse (review M11) — shown at startup and in /mcp. */
 	let configErrors: string[] = [];
@@ -407,12 +388,6 @@ export default function mcpExtension(pi: ExtensionAPI) {
 			onNote: (message) => configNotes.push(message),
 			registered: registeredMcpServers(pi),
 		});
-		// An older snapshot stored only the rendered blocks: read them again by the
-		// configured names, before any delta is taken against them.
-		if (legacyBlocks) {
-			announced = mcpAnnouncedFromReminders(legacyBlocks.instructions, legacyBlocks.failures, servers.map((server) => server.name));
-			legacyBlocks = undefined;
-		}
 		const configWarnings = [
 			...(configErrors.length > 0 ? [`MCP config could not be parsed (ignored): ${configErrors.join("; ")}`] : []),
 			...configNotes,
@@ -422,14 +397,9 @@ export default function mcpExtension(pi: ExtensionAPI) {
 			else process.stderr.write(`${text}\n`);
 		}
 		disabledNames = readDisabledMcpServers(ctx.cwd, home);
-		// A resumed first-prepend may describe a server whose configuration was
-		// removed entirely. There is no connection attempt in that case, so make
-		// the frozen-prefix delta explicit rather than leaving the stale capability
-		// silently standing. Fresh empty sessions keep their byte-identical no-op.
-		if (servers.length === 0) {
-			if (requestSent) emitInstructions();
-			return;
-		}
+		// With no server configured there is nothing to connect; a resumed epoch
+		// that told the model about one hears that it dropped at render time.
+		if (servers.length === 0) return;
 
 		// Disabled servers are listed but never connected; a server with an unset
 		// credential env var stays "needs authentication" and is not attempted
@@ -609,15 +579,6 @@ export default function mcpExtension(pi: ExtensionAPI) {
 	};
 
 	pi.on("session_start", async (_event, ctx) => {
-		const restored = restoredContext(pi.events);
-		// The restored stack owns message 1. Its structured state records the exact
-		// arbitrary server text that was shown; a fresh session keeps prior behavior.
-		requestSent = restored !== undefined;
-		const stackText = (key: string) => restored?.stack.find((entry) => (entry as { key?: string }).key === key)?.text;
-		const structured = mcpAnnouncedBaseline(restored?.baselines.mcp);
-		legacyBlocks = structured ? undefined : { instructions: stackText("mcp-instructions"), failures: stackText("mcp-failures") };
-		announced = structured ?? mcpAnnouncedFromReminders(legacyBlocks?.instructions, legacyBlocks?.failures);
-		if (!restored) publishBaseline(announced);
 		// pi awaits session_start handlers serially before the prompt opens, and
 		// remote servers take seconds to answer — awaiting here was the entire
 		// "slow startup" (4.9s → 0.24s measured, findings §15). In the interactive

package/extensions/mcp/trust.ts

@@ -32,6 +32,7 @@ import { readSettingsFile, type SettingsSource, settingsSources } from "../lib/c
 import { claudeSourcesOn } from "../lib/config-mode.ts";
 import { boundConsentItems } from "../lib/consent-preview.ts";
 import { consentStorePath } from "../lib/consent-stores.ts";
+import { processState } from "../lib/process-state.ts";
 import type { McpServer } from "./config.ts";
 import { escapeControlText } from "../lib/terminal-text.ts";
 
@@ -313,8 +314,14 @@ export interface McpTrustOutcome {
 	withheld: { server: McpServer; reason: "declined" | "not-approved" | "disabled-by-claude-settings" }[];
 }
 
-/** Process-lifetime memory per project+server+hash, so /clear (a new session_start) does not re-ask a "No". */
-const sessionDecisions = new Map<string, boolean>();
+/**
+ * Process-lifetime memory per project+server+hash, so /clear (a new
+ * session_start) and /reload do not re-ask a "No". Process state
+ * (lib/process-state.ts), not module scope: pi evaluates this module again
+ * at `/reload` and at a `/resume` into another directory (lifecycle grid
+ * R3-L13).
+ */
+const sessionDecisions = () => processState("mcp:trust-decisions", () => new Map<string, boolean>());
 const pendingPrompts = new Map<string, Promise<string | undefined>>();
 
 /**
@@ -363,7 +370,7 @@ export async function approveMcpServers(
 			approved.push(server);
 			continue;
 		}
-		const remembered = sessionDecisions.get(`${root}:${server.name}:${hash}`);
+		const remembered = sessionDecisions().get(`${root}:${server.name}:${hash}`);
 		if (remembered === true) approved.push(server);
 		else if (remembered === false) withheld.push({ server, reason: "declined" });
 		else pending.push(server);
@@ -400,12 +407,12 @@ export async function approveMcpServers(
 		const root = projectRootOf(server);
 		const decisionKey = `${root}:${server.name}:${hashServerConfig(server)}`;
 		if (choice === CHOICE_ALL || choice === CHOICE_THIS || choice === CHOICE_THESE) {
-			sessionDecisions.set(decisionKey, true);
+			sessionDecisions().set(decisionKey, true);
 			if (choice === CHOICE_ALL) persistEnableAll(root, deps.storePath);
 			persistApproval(root, server, deps.storePath);
 			approved.push(server);
 		} else {
-			sessionDecisions.set(decisionKey, false);
+			sessionDecisions().set(decisionKey, false);
 			withheld.push({ server, reason: "declined" });
 			// An explicit "No" is remembered as a disable; Escape is this session only.
 			if (choice === CHOICE_NO) deps.disable(server);
@@ -419,6 +426,6 @@ export async function approveMcpServers(
 
 /** Test seam. */
 export function resetMcpTrustSessionState(): void {
-	sessionDecisions.clear();
+	sessionDecisions().clear();
 	pendingPrompts.clear();
 }

package/extensions/model-default/index.ts

@@ -21,12 +21,24 @@
  * sessions", and since persisting is what this extension does, the claim is
  * true here too (a failed write announces the switch without it). pi handles
  * `/model` before any extension sees the text, so `model_select` — which also
- * covers ctrl+p cycling — is the one signal; the debounce means only the model
- * the user settles on is announced.
+ * covers ctrl+p cycling — is the one signal.
+ *
+ * The write and the breadcrumb wait for the model the user settles on: the
+ * quiet period after the last switch, or the next prompt, whichever comes
+ * first. So a ctrl+p cycle through ten models writes the settings once and
+ * queues one breadcrumb, which names the write's real outcome. A quit,
+ * /reload, /new or /resume inside the quiet period still writes the settings,
+ * but cannot queue the breadcrumb: system-reminder stops persisting one-shots
+ * in its `session_shutdown` handler, which runs before this extension's. The
+ * choice is recorded on the branch instead, and the next session on that
+ * branch (the reload, a resume) announces it while its model is still the
+ * one chosen.
  */
 
 import { join } from "node:path";
 import { getAgentDir, type ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { isObject } from "../lib/ledger/records.ts";
+import { readState, recordState } from "../lib/ledger/state.ts";
 import { announceLocalCommand } from "../lib/local-command.ts";
 import { readSettingsForWrite, writeSettings } from "../lib/one-code-settings.ts";
 
@@ -44,34 +56,65 @@ export function modelSwitchStdout(displayName: string, saved: boolean): string {
 	return `Set model to \`${displayName}\`${saved ? " and saved as your default for new sessions" : ""}`;
 }
 
-/** Quiet period after the last switch before it is written (ctrl+p cycles fire one event per step). */
+/** Quiet period after the last switch before it is written and announced (ctrl+p cycles fire one event per step). */
 export const PERSIST_DEBOUNCE_MS = 400;
 
+/** The `/model` breadcrumb's pending-entry key: a later switch's breadcrumb replaces an undelivered one. */
+const BREADCRUMB_KEY = "local-command:model";
+
+/**
+ * The `one-code:state` key of a switch not yet announced: recorded at every
+ * switch (`saved` unset until the settings write), so the branch, not this
+ * process's timer, says a breadcrumb is owed; null once announced or dropped.
+ */
+const UNANNOUNCED_STATE = "model-breadcrumb";
+
+/** A settled switch, as announced. */
+interface Settled {
+	provider: string;
+	id: string;
+	name: string;
+	saved: boolean;
+}
+
+/** A switch the branch records, as `model_select` or a shutdown left it. */
+type Unannounced = Omit<Settled, "saved"> & { saved?: boolean };
+
 export default function modelDefaultExtension(pi: ExtensionAPI) {
 	let pending: { provider: string; id: string; name: string; notify: (message: string) => void } | undefined;
 	let timer: ReturnType<typeof setTimeout> | undefined;
+	const announce = (name: string, saved: boolean) => announceLocalCommand(pi, { name: "model", stdout: modelSwitchStdout(name, saved), key: BREADCRUMB_KEY });
 
-	const flush = () => {
-		if (timer !== undefined) clearTimeout(timer);
-		timer = undefined;
-		const choice = pending;
-		pending = undefined;
-		if (!choice) return;
+	/** Save `provider/id` as the default model, and say whether it was saved. */
+	const save = (provider: string, id: string, notify: (message: string) => void): boolean => {
 		const path = join(getAgentDir(), "settings.json");
-		let saved = true;
 		try {
-			writeSettings(path, applyDefaultModel(readSettingsForWrite(path), choice.provider, choice.id));
+			writeSettings(path, applyDefaultModel(readSettingsForWrite(path), provider, id));
+			return true;
 		} catch (error) {
 			// Persisting a preference must not break the model switch itself, but
-			// say why it will be forgotten (typically a malformed settings.json).
-			saved = false;
-			choice.notify(`Could not save ${choice.provider}/${choice.id} as the default model: ${(error as Error).message}`);
+			// say why it will be forgotten.
+			notify(`Could not save ${provider}/${id} as the default model: ${(error as Error).message}`);
+			return false;
 		}
-		announceLocalCommand(pi, { name: "model", stdout: modelSwitchStdout(choice.name, saved) });
 	};
 
-	// Debounced: a ctrl+p cycle emits model_select per step, and only the model
-	// the user settles on should hit the disk (last one wins).
+	/** Write the switch the user settled on, if any, and say whether it was saved. */
+	const settle = (): Settled | undefined => {
+		if (timer !== undefined) clearTimeout(timer);
+		timer = undefined;
+		const choice = pending;
+		pending = undefined;
+		if (!choice) return undefined;
+		return { provider: choice.provider, id: choice.id, name: choice.name, saved: save(choice.provider, choice.id, choice.notify) };
+	};
+	const flush = () => {
+		const settled = settle();
+		if (!settled) return;
+		announce(settled.name, settled.saved);
+		recordState(pi, UNANNOUNCED_STATE, null);
+	};
+
 	pi.on("model_select", (event, ctx) => {
 		const model = event.model as { provider?: string; id?: string; name?: string } | undefined;
 		if (!model?.provider || !model.id) return;
@@ -83,11 +126,35 @@ export default function modelDefaultExtension(pi: ExtensionAPI) {
 				if (ctx.hasUI) ctx.ui.notify(message, "warning");
 			},
 		};
+		// Owed from now on, whatever happens to this process: a fresh one on a
+		// copy of the branch owes the same breadcrumb (lifecycle-grid-hunt oracle).
+		recordState(pi, UNANNOUNCED_STATE, { provider: model.provider, id: model.id, name: pending.name } satisfies Unannounced);
 		if (timer !== undefined) clearTimeout(timer);
 		timer = setTimeout(flush, PERSIST_DEBOUNCE_MS);
 		timer.unref?.();
 	});
 
-	// A quit inside the quiet period must not lose the choice.
-	pi.on("session_shutdown", () => flush());
+	// A prompt sent inside the quiet period carries the switch's breadcrumb, not the request after it.
+	pi.on("before_agent_start", () => flush());
+
+	// A quit inside the quiet period must not lose the choice: the write happens
+	// now, and the breadcrumb waits on the branch for the next session.
+	pi.on("session_shutdown", () => {
+		const settled = settle();
+		if (settled) recordState(pi, UNANNOUNCED_STATE, settled);
+	});
+	// A switch the branch still owes a breadcrumb: announced here when the
+	// session runs that model, saved first if its own process never got to it.
+	pi.on("session_start", (_event, ctx) => {
+		const stored = readState(ctx, UNANNOUNCED_STATE);
+		if (!isObject(stored)) return;
+		recordState(pi, UNANNOUNCED_STATE, null);
+		const { provider, id, name, saved } = stored;
+		if (typeof provider !== "string" || typeof id !== "string" || typeof name !== "string") return;
+		if (ctx.model?.provider !== provider || ctx.model?.id !== id) return;
+		const notify = (message: string) => {
+			if (ctx.hasUI) ctx.ui.notify(message, "warning");
+		};
+		announce(name, typeof saved === "boolean" ? saved : save(provider, id, notify));
+	});
 }