one-code-extension 0.5.0 → 0.6.0

package/extensions/context-management/index.ts

@@ -38,9 +38,8 @@
  * for an anthropic-messages endpoint you have confirmed accepts it.
  */
 
-import { readFileSync, statSync } from "node:fs";
-import { join } from "node:path";
-import { type ExtensionAPI, getAgentDir } from "@earendil-works/pi-coding-agent";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { isAnthropicOAuth } from "../lib/anthropic-auth.ts";
 import { looksLikeAnthropicRequest } from "../lib/anthropic-payload.ts";
 import { CACHE_RETENTION_ENV, mainSessionCacheRetention } from "../lib/cache-retention.ts";
 
@@ -93,9 +92,16 @@ export function anthropicBetas(oauth: boolean, compat: AnthropicModelCompat | un
 // tool-search); re-exported so existing importers keep working.
 export { looksLikeAnthropicRequest } from "../lib/anthropic-payload.ts";
 
-/** The edit is rejected unless thinking is enabled or the model is adaptive. */
+/**
+ * The edit is rejected unless thinking is on: enabled or adaptive in the
+ * request, or left to an adaptive model's default. A request that turns
+ * thinking off (`{ type: "disabled" }`, "off" effort on Opus 5 and Haiku 5.5)
+ * takes no edit, adaptive model or not (round-2 review H3).
+ */
 export function clearThinkingApplies(payload: Record<string, unknown>, forceAdaptiveThinking: boolean): boolean {
-	return payload.thinking !== undefined || forceAdaptiveThinking;
+	const type = (payload.thinking as { type?: unknown } | undefined)?.type;
+	if (type === undefined) return payload.thinking === undefined && forceAdaptiveThinking;
+	return type === "enabled" || type === "adaptive";
 }
 
 export function withClearThinking(payload: Record<string, unknown>): Record<string, unknown> {
@@ -109,29 +115,6 @@ export function withClearThinking(payload: Record<string, unknown>): Record<stri
 	};
 }
 
-/** mtime cache: this runs on every provider request, the hottest path there is. */
-let authCache: { mtimeMs: number; oauth: boolean } | undefined;
-
-/** OAuth logins need pi's identity betas kept in the header we overwrite. */
-export function isAnthropicOAuth(): boolean {
-	// getAgentDir() honours PI_CODING_AGENT_DIR, so an isolated one-code app
-	// reads its own auth.json rather than ~/.pi's.
-	const path = join(getAgentDir(), "auth.json");
-	try {
-		const mtimeMs = statSync(path).mtimeMs;
-		const cached = authCache;
-		if (cached && cached.mtimeMs === mtimeMs) return cached.oauth;
-		const auth = JSON.parse(readFileSync(path, "utf8"));
-		const entry = auth?.anthropic;
-		const oauth = entry?.type === "oauth" || typeof entry?.refresh === "string";
-		authCache = { mtimeMs, oauth };
-		return oauth;
-	} catch {
-		authCache = undefined;
-		return false;
-	}
-}
-
 interface AnthropicishModel {
 	api?: string;
 	provider?: string;

package/extensions/effort/index.ts

@@ -21,12 +21,14 @@
  * same shape the permissions extension uses for plan mode.
  */
 
+import os from "node:os";
 import { join } from "node:path";
 import type { ThinkingLevel } from "@earendil-works/pi-agent-core";
 import { getSupportedThinkingLevels } from "@earendil-works/pi-ai/compat";
 import { getAgentDir, SettingsManager, type ExtensionAPI, type ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { effortSetMessage, isPersistedEffort, type PersistedEffort } from "./settings.ts";
-import { REMINDER_CHANNEL } from "../lib/reminders.ts";
+import { REMINDER_CHANNEL, RENDER_CHANNEL, type RenderRequest, stickyFact, toldBlockFact } from "../lib/reminders.ts";
+import { readState, recordState } from "../lib/ledger/state.ts";
 import { dimRightAlignedWidget, safeThemePaint, truncateLine } from "../lib/tui-render.ts";
 import {
 	acceptedEffortArgs,
@@ -49,6 +51,7 @@ import {
 	ULTRACODE_STATUS_KEY,
 } from "./slider.ts";
 import { registerLocalCommand } from "../lib/local-command.ts";
+import { readWorkflowSettings } from "../lib/one-code-settings.ts";
 import { panelUi } from "../lib/panel-focus.ts";
 import { extendingCompletions } from "../lib/argument-hints.ts";
 
@@ -78,6 +81,28 @@ const ULTRACODE_STANDING_REMINDER =
 	"Token cost is not the constraint here; the most exhaustive correct answer is. " +
 	"Work solo only on conversational turns and trivial mechanical edits.";
 
+/**
+ * Said once when ultracode is off while the model has read its standing block:
+ * the earlier messages keep the block in the record, so without this the model
+ * reads the opt-in as standing (lifecycle-grid-hunt round 3, R3-M21).
+ */
+const ULTRACODE_OFF_REMINDER =
+	"Ultracode mode is off now: the user's standing opt-in to multi-agent orchestration has ended. Run a workflow only when the task calls for one or the user asks.";
+/**
+ * The told key of the standing block: a request that carries its first
+ * delivery records the block's hash under it (system-reminder).
+ */
+const STANDING_TOLD_KEY = stickyFact({ key: REMINDER_KEY, text: "", since: 0 }).key;
+/**
+ * What the off notice tells, under the same key: the model last read "off".
+ * The standing block switched on again is then a first delivery once more,
+ * and a later off is told again only after that delivery.
+ */
+const OFF_TOLD = toldBlockFact(STANDING_TOLD_KEY, ULTRACODE_OFF_REMINDER);
+
+/** The `one-code:state` key ultracode is recorded under on the branch. */
+const ULTRACODE_STATE = "ultracode";
+
 export default function effortExtension(pi: ExtensionAPI) {
 	let ultracodeActive = false;
 	/**
@@ -117,15 +142,22 @@ export default function effortExtension(pi: ExtensionAPI) {
 	pi.on("session_start", cancelEffortNote);
 	pi.on("session_shutdown", cancelEffortNote);
 
-	const setUltracode = (on: boolean, level?: ThinkingLevel) => {
-		const changed = ultracodeActive !== on;
+	/** Whether workflows are on for this session, read with workflow's own settings at session start. */
+	let workflowsOn = true;
+	/** `record` false when the state comes from the branch itself (a resume, a /tree switch). */
+	const setUltracode = (on: boolean, level?: ThinkingLevel, { record = true }: { record?: boolean } = {}) => {
+		const changed = ultracodeActive !== on || (on && ultracodeLevel !== level);
 		ultracodeActive = on;
 		ultracodeLevel = on ? level : undefined;
 		if (changed) pi.events.emit(ULTRACODE_MODE_CHANNEL, { active: on });
-		if (on) {
+		// Ultracode follows the branch: recorded on every change.
+		if (changed && record) recordState(pi, ULTRACODE_STATE, on ? { on, level } : { on });
+		// With workflows turned off (enableWorkflows/disableWorkflows) the block's
+		// "run a workflow for every task" would steer to a tool the session does
+		// not offer, so ultracode is only its reasoning level there (R3-M21).
+		if (on && workflowsOn) {
 			pi.events.emit(REMINDER_CHANNEL, {
 				text: ULTRACODE_STANDING_REMINDER,
-				scope: "every-turn",
 				key: REMINDER_KEY,
 				placement: "sticky-append",
 			});
@@ -134,6 +166,18 @@ export default function effortExtension(pi: ExtensionAPI) {
 		}
 	};
 
+	// The off notice derives from what the epoch told, when a request goes out:
+	// only a model that read the standing block hears it ended, a switch off and
+	// on again before the request says nothing, and the notice's own told fact
+	// keeps a /reload or a resume from saying it twice.
+	pi.events.on(RENDER_CHANNEL, (data) => {
+		const request = data as RenderRequest;
+		if (request.epoch || ultracodeActive) return;
+		const told = request.toldBlocks.get(STANDING_TOLD_KEY);
+		if (told === undefined || told === OFF_TOLD.hash) return;
+		request.blocks.push({ text: ULTRACODE_OFF_REMINDER, facts: [OFF_TOLD] });
+	});
+
 	const canPersist = (ctx: ExtensionContext) => ctx.hasUI && (ctx.mode === "tui" || ctx.mode === "rpc") && !!ctx.model;
 	/** Through pi's own settings writer: its key format, file lock and merge of changed fields. */
 	const persist = async (ctx: ExtensionContext, level: PersistedEffort | undefined): Promise<string | undefined> => {
@@ -250,7 +294,7 @@ export default function effortExtension(pi: ExtensionAPI) {
 						const error = await persist(ctx, undefined);
 						if (error) return report(ctx, error, true);
 					}
-					// getSettings arrived in pi 1.0.1; the package still admits older pi.
+					// getSettings arrived in pi 1.0.1; a 1.0.0 install falls back to pi's default.
 					pi.setThinkingLevel(pi.getSettings?.().defaultThinkingLevel ?? "medium");
 					setUltracode(false);
 					applyStatus(ctx);
@@ -301,7 +345,26 @@ export default function effortExtension(pi: ExtensionAPI) {
 		showEffortNote(ctx, event.level);
 	});
 
-	pi.on("session_start", (_event, ctx) => {
+	/**
+	 * Take the branch's ultracode state (a resume, /reload, a fork, a /tree
+	 * switch). At a session start it is on only while pi's reasoning level,
+	 * which pi restores from the branch itself, is still the level ultracode
+	 * settled on (a launch `--thinking` flag wins). pi restores no level at a
+	 * /tree switch, so there the branch's level is put back with the mode.
+	 * When the branch's model read it on and it resolves off, the next request
+	 * tells it (the RENDER_CHANNEL listener above).
+	 */
+	const followBranch = (ctx: ExtensionContext, tree: boolean) => {
+		const stored = readState(ctx, ULTRACODE_STATE) as { on?: unknown; level?: unknown } | undefined;
+		const storedOn = stored?.on === true && typeof stored.level === "string";
+		const on = storedOn && (tree || stored.level === pi.getThinkingLevel());
+		setUltracode(on, on ? (stored?.level as ThinkingLevel) : undefined, { record: false });
+		if (on && tree && pi.getThinkingLevel() !== stored?.level) pi.setThinkingLevel(stored?.level as ThinkingLevel);
 		applyStatus(ctx);
+	};
+	pi.on("session_start", (_event, ctx) => {
+		workflowsOn = readWorkflowSettings(ctx.cwd, os.homedir()).enabled;
+		followBranch(ctx, false);
 	});
+	pi.on("session_tree", (_event, ctx) => followBranch(ctx, true));
 }

package/extensions/file-tracker/index.ts

@@ -17,6 +17,7 @@
  */
 
 import { CHILD_WROTE_CHANNEL, type ChildWrote } from "../lib/child-writes.ts";
+import { createHash } from "node:crypto";
 import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
@@ -35,7 +36,7 @@ import { REMINDER_CHANNEL, type ReminderPayload } from "../lib/reminders.ts";
 import { resolveToolPath } from "../lib/tool-path.ts";
 import { parseRules, ruleMatches } from "../permissions/matcher.ts";
 import { loadPermissionSettings } from "../permissions/settings.ts";
-import { keptReadPaths, keptShellReadPaths, lastTouchesOnBranch, pathsReadOnBranch, shellCallsOnBranch } from "./replay.ts";
+import { type FileObservation, filesSeenOnBranch, keptReadPaths, keptShellReadPaths, shellCallsOnBranch } from "./replay.ts";
 import { type RestoredRead, restoreBlocks, restoreCandidates } from "./restore.ts";
 import { fileToolResultContent } from "./results.ts";
 import { shellReadPaths, shownInFull } from "./shell-reads.ts";
@@ -158,13 +159,24 @@ function observeShellReads(tracker: FileTracker, before: Map<string, string>, ou
 /** Above this a shell read's output is persisted, not shown, so the file cannot have been seen whole. */
 const MAX_SHELL_READ_BYTES = 256 * 1024;
 
-/** Observe a file's current content together with the stamp it was read at, and return that stamp. */
-function observeFromDisk(tracker: FileTracker, path: string): FileStamp | undefined {
+/**
+ * Observe a file's current content together with the stamp it was read at.
+ * Returns that stamp, and what was seen for the result that read it
+ * (undefined when the file is gone).
+ */
+function observeFromDisk(tracker: FileTracker, path: string): { stamp?: FileStamp; seen?: FileObservation } {
 	const stamp = statIfPresent(path);
 	const current = readIfPresent(path);
-	if (current === undefined) tracker.forget(path);
-	else tracker.observe(path, current, Date.now(), stamp);
-	return stamp;
+	if (current === undefined) {
+		tracker.forget(path);
+		return stamp ? { stamp } : {};
+	}
+	tracker.observe(path, current, Date.now(), stamp);
+	return stamp ? { stamp, seen: { path, size: stamp.size, mtimeMs: stamp.mtimeMs, sha256: sha256(current) } } : {};
+}
+
+function sha256(text: string): string {
+	return createHash("sha256").update(text).digest("hex");
 }
 
 function pathOf(input: unknown, cwd: string): string | undefined {
@@ -183,9 +195,9 @@ function pathOf(input: unknown, cwd: string): string | undefined {
  * The files the context still shows after a compaction, as comparable paths:
  * the context stack (the CLAUDE.md family as claude-context discovers it, what
  * they `@`-import, and the auto-memory index), the plan file, the files a
- * `read` in the kept turns returned (`kept`, as written) and the files a kept
- * bash call showed in full (`keptShell`, absolute). Claude Code's restore
- * skips them; they stay read.
+ * `read` in the kept turns returned (`kept`) and the files a kept bash call
+ * showed in full (`keptShell`), both absolute as recorded. Claude Code's
+ * restore skips them; they stay read.
  */
 function inContextFiles(ctx: ExtensionContext, branch: readonly { type: string; customType?: string; data?: unknown }[], kept: string[], keptShell: string[]): Set<string> {
 	const home = homedir();
@@ -195,7 +207,7 @@ function inContextFiles(ctx: ExtensionContext, branch: readonly { type: string;
 		includeExternal: readExternalIncludesApproval(ctx.cwd, home).approved,
 	}).flatMap((file) => [file.path, ...(file.imported ?? [])]);
 	return new Set(
-		[...stack, autoMemoryEnabled(ctx.cwd) ? join(projectMemoryDir(ctx.cwd, home), "MEMORY.md") : undefined, planFileOnBranch(branch), ...kept.map((path) => resolveToolPath(path, ctx.cwd)), ...keptShell]
+		[...stack, autoMemoryEnabled(ctx.cwd) ? join(projectMemoryDir(ctx.cwd, home), "MEMORY.md") : undefined, planFileOnBranch(branch), ...kept, ...keptShell]
 			.filter((path): path is string => typeof path === "string")
 			.map(comparablePath),
 	);
@@ -255,8 +267,8 @@ export default function fileTrackerExtension(pi: ExtensionAPI) {
 	let sessionId: string | undefined;
 	/**
 	 * Every file a read or write touched on this branch, with its modification
-	 * time as stat'ed then (the transcript time for one replayed after a resume):
-	 * the post-compaction restore's order.
+	 * time as stat'ed then (as the result recorded it, for one replayed after a
+	 * resume): the post-compaction restore's order.
 	 */
 	let touched = new Map<string, number>();
 	/**
@@ -272,15 +284,18 @@ export default function fileTrackerExtension(pi: ExtensionAPI) {
 	/** Observe a file the model read or wrote, and record it as touched at its current modification time. */
 	const touch = (path: string) => {
 		childWrites.delete(path);
-		const stamp = observeFromDisk(tracker, path);
+		const { stamp, seen } = observeFromDisk(tracker, path);
 		if (stamp) touched.set(path, stamp.mtimeMs);
+		return seen;
 	};
 
-	// A resumed session (or a session_tree switch) carries reads the model did
-	// earlier in the transcript; rebuild the tracker from the part of the branch
-	// still in context (since the latest compaction's kept tail) so post-resume
-	// edits are not refused as "never read" (replay.ts). A new session id starts
-	// from an empty tracker.
+	// A resumed session (or a /reload, a fork, a session_tree switch) carries
+	// reads the model did earlier in the transcript; rebuild the tracker from
+	// the part of the branch still in context (since the latest compaction's
+	// kept tail) so later edits are not refused as "never read" (replay.ts).
+	// Everything comes from the branch, as the results and pending entries
+	// recorded it, never from this instance: pi runs the factory again on each
+	// of those. A new session id starts from an empty tracker.
 	const reconstruct = (ctx: ExtensionContext, fresh = false) => {
 		const id = ctx.sessionManager.getSessionId?.() ?? undefined;
 		if (fresh || id !== sessionId) {
@@ -295,8 +310,31 @@ export default function fileTrackerExtension(pi: ExtensionAPI) {
 		} catch {
 			return;
 		}
-		for (const raw of pathsReadOnBranch(entries)) {
-			observeFromDisk(tracker, resolveToolPath(raw, ctx.cwd));
+		// What each result or restore saw, recorded at the time and by the path
+		// the tool resolved: a file that changed since is stale, never taken as
+		// read in its current form (round-2 review H1), and a gone one untracked.
+		const files = filesSeenOnBranch(entries);
+		const changed: Pick<FileObservation, "path" | "sha256">[] = [];
+		for (const [path, { seen, notified }] of files) {
+			const stamp = statIfPresent(path);
+			const current = readIfPresent(path);
+			if (current === undefined) continue;
+			const hash = sha256(current);
+			if (hash === seen.sha256) {
+				tracker.observe(path, current, Date.now(), stamp);
+				continue;
+			}
+			tracker.observeChanged(path, Date.now());
+			// A version a notice already named is not announced again (round-3 review L9).
+			if (!notified.has(hash)) changed.push({ path, sha256: hash });
+		}
+		if (changed.length > 0) {
+			// Unkeyed: a key would let this notice replace an undelivered earlier one
+			// whose versions the branch already counts as told.
+			pi.events.emit(REMINDER_CHANNEL, {
+				text: `These files changed on disk since you last read them in this conversation: ${changed.map((file) => file.path).join(", ")}. Read them again before editing them.`,
+				notified: changed,
+			} satisfies ReminderPayload);
 		}
 		// Shell reads need the bash grammar, which may still be loading this early.
 		const target = tracker;
@@ -309,7 +347,7 @@ export default function fileTrackerExtension(pi: ExtensionAPI) {
 				for (const call of shellCalls) recordShellReads(call.id, observeShellReads(target, shellReadSnapshot(call.command, sessionWorkCwd(entered, ctx.cwd)), call.output));
 			});
 		}
-		touched = new Map([...lastTouchesOnBranch(entries)].map(([raw, at]) => [resolveToolPath(raw, ctx.cwd), at]));
+		touched = new Map([...files].map(([path, { seen }]) => [path, seen.mtimeMs]));
 	};
 	pi.on("session_start", (_event, ctx) => reconstruct(ctx));
 	// A branch switch keeps the session id, but the reads of the branch left
@@ -363,7 +401,8 @@ export default function fileTrackerExtension(pi: ExtensionAPI) {
 
 		// After a read we know the file; after our own write we know it again, so a
 		// successful edit does not make the file look stale to the next edit.
-		if (!event.isError) touch(path);
+		// What the model saw, on the result: a resume compares it with the disk.
+		const observation = event.isError ? undefined : touch(path);
 		const content = fileToolResultContent({
 			toolName: event.toolName,
 			isError: event.isError,
@@ -373,20 +412,27 @@ export default function fileTrackerExtension(pi: ExtensionAPI) {
 			existedBefore,
 			isEmptyFile: () => statIfPresent(path)?.size === 0,
 		});
-		return content ? { content } : undefined;
+		if (!content && !observation) return undefined;
+		return {
+			...(content ? { content } : {}),
+			...(observation ? { details: { ...((event.details as Record<string, unknown> | undefined) ?? {}), oneCodeFile: observation } } : {}),
+		};
 	});
 
 	/**
 	 * Claude Code's post-compaction file restore (`restore.ts`). The
-	 * blocks open the next user message (`user-prepend`); an overflow compaction
-	 * that retries the turn has no such message, so they ride the request's tail
-	 * instead.
+	 * blocks open the next user message (`user-prepend`); a request that opens
+	 * with none (the rest of a run after a mid-turn compaction, an overflow
+	 * retry) carries them on its tail (`orTail`), so the model sees a restored
+	 * file before it can edit it. A later compaction drops an undelivered one
+	 * (`untilCompaction`): it restores for the epoch the one before it opened.
 	 *
 	 * Like Claude Code, the compaction also clears what the session has read:
 	 * the summary no longer holds those files, so an edit needs a fresh read.
 	 * A file the context still shows stays read (a kept turn's read or whole-file
 	 * shell read, the context stack, the plan file), and a restored file counts
-	 * as read and as touched for the next compaction's restore; a note never
+	 * as read and as touched for the next compaction's restore, here and after
+	 * a reload or a resume (its block records what it showed); a note never
 	 * marks its file read. Contents come back only for a file the gate would
 	 * let through without a question (`restoreAllowed`).
 	 */
@@ -416,10 +462,29 @@ export default function fileTrackerExtension(pi: ExtensionAPI) {
 			const candidates = restoreCandidates(before, (path) => shown(path) || !allowed(path));
 			const read = createReadToolDefinition(ctx.cwd);
 			const reads: RestoredRead[] = await Promise.all(candidates.map(async (path) => ({ path, text: await readAgain(read, path, ctx) })));
+			const shownText = new Map(reads.map(({ path, text }) => [path, text]));
 			const { blocks, restored } = restoreBlocks(reads, estimateTextTokens);
-			const placement = event.willRetry ? "last-append" : "user-prepend";
-			for (const text of blocks) pi.events.emit(REMINDER_CHANNEL, { text, placement } satisfies ReminderPayload);
-			for (const path of restored) touch(path);
+			// The block that shows a file records what it showed, so a reload or a
+			// resume counts the file read exactly where the branch holds the block
+			// (replay.ts filesSeenOnBranch). The file counts as read only when the
+			// disk now holds exactly what the block shows: one that changed while
+			// it was read back (even back to where it started) fails safe, and a
+			// fresh read is asked for instead of passing the stale-edit guard.
+			const seen = new Map(
+				restored.map((path) => {
+					const observed = touch(path);
+					const text = shownText.get(path);
+					if (observed && (text === undefined || sha256(text) !== observed.sha256)) {
+						tracker.forget(path);
+						return [path, undefined] as const;
+					}
+					return [path, observed] as const;
+				}),
+			);
+			for (const { text, restores } of blocks) {
+				const observation = restores ? seen.get(restores) : undefined;
+				pi.events.emit(REMINDER_CHANNEL, { text, placement: "user-prepend", orTail: true, untilCompaction: true, ...(observation ? { observations: [observation] } : {}) } satisfies ReminderPayload);
+			}
 		} catch {
 			// The restore is best effort: nothing comes back, and an edit needs a fresh read.
 			tracker = new FileTracker();
@@ -447,12 +512,10 @@ export default function fileTrackerExtension(pi: ExtensionAPI) {
 	 *   (one blocked call plus a re-read per edit for anyone with an asynchronous
 	 *   formatter). Claude Code computes its `edited_text_file` attachments on
 	 *   every tool round, so the model reads the change before its next edit
-	 *   (review M5). The one-shot is pending when the next request goes out and
-	 *   the injector pins it to that tool result — pi runs `tool_result` hooks
-	 *   BEFORE it emits `tool_execution_end` (agent-loop.js
-	 *   finalizeExecutedToolCall → emitToolExecutionEnd), so it cannot be written
-	 *   into the stored result; pinned is the same mechanism tool-search's
-	 *   deferred-tool miss uses. Our own edit/write/read of a file was observed by
+	 *   (review M5). The one-shot is a pending entry when the next request goes
+	 *   out, and the renderer places it on that request's trailing tool result
+	 *   (lib/reminders.ts), the same mechanism tool-search's deferred-tool miss
+	 *   uses; reminders never enter a stored result. Our own edit/write/read of a file was observed by
 	 *   the `tool_result` handler above before this fires, so it is fresh here
 	 *   and never reported as external — but only for a call that ran alone. pi
 	 *   executes a batch of parallel tool calls CONCURRENTLY, so the first edit's
@@ -463,8 +526,10 @@ export default function fileTrackerExtension(pi: ExtensionAPI) {
 	 *   runs only once the batch has fully drained.
 	 */
 	const reportExternalChanges = () => {
-		const detailed: string[] = [];
-		const overflow: string[] = [];
+		// Each notice records the versions it names on its pending entry, so a
+		// reload or a resume does not announce them again (replay.ts).
+		const detailed: { text: string; notified?: Pick<FileObservation, "path" | "sha256"> }[] = [];
+		const overflow: Pick<FileObservation, "path" | "sha256">[] = [];
 		for (const path of tracker.tracked) {
 			// Undefined for a file tracked without content (oversized); an empty
 			// file is compared like any other.
@@ -481,7 +546,7 @@ export default function fileTrackerExtension(pi: ExtensionAPI) {
 			const current = stamp ? readIfPresent(path) : undefined;
 			if (stamp === undefined || current === undefined) {
 				tracker.forget(path);
-				detailed.push(`${path} no longer exists; it was deleted or moved after you last read or wrote it.`);
+				detailed.push({ text: `${path} no longer exists; it was deleted or moved after you last read or wrote it.` });
 				continue;
 			}
 			tracker.recordStamp(path, stamp);
@@ -489,22 +554,24 @@ export default function fileTrackerExtension(pi: ExtensionAPI) {
 			// Don't repeat the same warning every turn…
 			if (tracker.alreadyNotified(path, current)) continue;
 
+			const version = { path, sha256: sha256(current) };
 			if (detailed.length < DETAILED_CHANGE_REMINDERS_PER_TURN) {
 				const excerpt = describeChanges(previous, current);
-				if (excerpt) detailed.push(byChild ? CHILD_CHANGE_REMINDER(path, childAgent, excerpt) : EXTERNAL_CHANGE_REMINDER(path, excerpt));
+				if (excerpt) detailed.push({ text: byChild ? CHILD_CHANGE_REMINDER(path, childAgent, excerpt) : EXTERNAL_CHANGE_REMINDER(path, excerpt), notified: version });
 			} else {
-				overflow.push(path);
+				overflow.push(version);
 			}
 			// …but deliberately do NOT record the new content as seen: the file must
 			// stay stale so the edit guard still forces a re-read. Marking it read
 			// here would announce the change and then permit the clobbering edit.
 			tracker.markNotified(path, current);
 		}
-		for (const text of detailed) pi.events.emit(REMINDER_CHANNEL, { text });
+		for (const { text, notified } of detailed) pi.events.emit(REMINDER_CHANNEL, { text, ...(notified ? { notified: [notified] } : {}) } satisfies ReminderPayload);
 		if (overflow.length > 0) {
 			pi.events.emit(REMINDER_CHANNEL, {
-				text: `${overflow.length} more file(s) you read earlier changed on disk since: ${overflow.join(", ")}. Re-read any of them before editing it.`,
-			});
+				text: `${overflow.length} more file(s) you read earlier changed on disk since: ${overflow.map((file) => file.path).join(", ")}. Re-read any of them before editing it.`,
+				notified: overflow,
+			} satisfies ReminderPayload);
 		}
 	};
 	/**