pi-roundtable 0.24.2 → 0.26.0

package/src/core/identity/profile-picture.ts

@@ -0,0 +1,117 @@
+/** The most a picture may weigh. */
+export const PICTURE_MAX_BYTES = 2 * 1024 * 1024;
+const PICTURE_BUDGET_MS = 5_000;
+
+/** A picture the proxy accepted: its bytes and the type they really are. */
+export interface Picture {
+	bytes: Uint8Array<ArrayBuffer>;
+	type: string;
+}
+
+type Fetch = (input: string, init?: RequestInit) => Promise<Response>;
+
+/** The type a body's first bytes show, for the four accepted formats. */
+function sniff(bytes: Uint8Array): string | undefined {
+	const starts = (...values: number[]) =>
+		values.every((value, i) => bytes[i] === value);
+	if (starts(0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a))
+		return "image/png";
+	if (starts(0xff, 0xd8, 0xff)) return "image/jpeg";
+	if (starts(0x47, 0x49, 0x46, 0x38)) return "image/gif";
+	if (
+		starts(0x52, 0x49, 0x46, 0x46) &&
+		bytes[8] === 0x57 &&
+		bytes[9] === 0x45 &&
+		bytes[10] === 0x42 &&
+		bytes[11] === 0x50
+	)
+		return "image/webp";
+	return undefined;
+}
+
+/** Reads a body up to the cap; undefined when it is longer. */
+async function readCapped(
+	response: Response,
+): Promise<Uint8Array<ArrayBuffer> | undefined> {
+	const length = Number(response.headers.get("content-length"));
+	if (Number.isFinite(length) && length > PICTURE_MAX_BYTES) {
+		await response.body?.cancel().catch(() => undefined);
+		return undefined;
+	}
+	const reader = response.body?.getReader();
+	if (!reader) return undefined;
+	const chunks: Uint8Array[] = [];
+	let total = 0;
+	for (;;) {
+		const { done, value } = await reader.read();
+		if (done) break;
+		total += value.byteLength;
+		if (total > PICTURE_MAX_BYTES) {
+			await reader.cancel().catch(() => undefined);
+			return undefined;
+		}
+		chunks.push(value);
+	}
+	const bytes = new Uint8Array(total);
+	let at = 0;
+	for (const chunk of chunks) {
+		bytes.set(chunk, at);
+		at += chunk.byteLength;
+	}
+	return bytes;
+}
+
+/**
+ * Fetches a picture for the proxy: only an `https` address on one of the allowed hosts, no
+ * redirect followed, only PNG, JPEG, GIF or WebP whose header and first bytes agree (so an SVG is
+ * refused), at most 2 MiB. Undefined for anything else, a failure included.
+ */
+export async function fetchPicture(
+	address: string,
+	hosts: readonly string[],
+	fetchImpl: Fetch = fetch,
+): Promise<Picture | undefined> {
+	const url = URL.parse(address);
+	if (!url) return undefined;
+	if (
+		url.protocol !== "https:" ||
+		url.username !== "" ||
+		url.password !== "" ||
+		url.port !== "" ||
+		!hosts.some((host) => host.toLowerCase() === url.hostname)
+	)
+		return undefined;
+	try {
+		const response = await fetchImpl(url.href, {
+			redirect: "manual",
+			signal: AbortSignal.timeout(PICTURE_BUDGET_MS),
+			headers: { accept: "image/png,image/jpeg,image/gif,image/webp" },
+		});
+		if (response.status !== 200) {
+			await response.body?.cancel().catch(() => undefined);
+			return undefined;
+		}
+		const declared = (response.headers.get("content-type") ?? "")
+			.split(";")[0]
+			?.trim()
+			.toLowerCase();
+		const bytes = await readCapped(response);
+		if (!bytes) return undefined;
+		const type = sniff(bytes);
+		return type && type === declared ? { bytes, type } : undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+/** The proxy's answer: `nosniff`, kept by the one browser for an hour. */
+export function pictureResponse(picture: Picture): Response {
+	return new Response(picture.bytes, {
+		headers: {
+			"content-type": picture.type,
+			"content-length": String(picture.bytes.byteLength),
+			"x-content-type-options": "nosniff",
+			"cache-control": "private, max-age=3600",
+		},
+	});
+}

package/src/core/identity/profiles-view.ts

@@ -0,0 +1,20 @@
+import type { PersonProfiles } from "./profiles.ts";
+
+/**
+ * The directory as plugins get it: the `PersonProfiles` methods and nothing else, so no plugin
+ * reaches the name the core gives agents. Each answer is a frozen copy.
+ */
+export function profilesView(directory: PersonProfiles): PersonProfiles {
+	return Object.freeze({
+		register: (source) => directory.register(source),
+		sources: () =>
+			Object.freeze(directory.sources().map((s) => Object.freeze({ ...s }))),
+		observed: (principalId, provider, name) =>
+			directory.observed(principalId, provider, name),
+		sourceOf: (principalId) => directory.sourceOf(principalId),
+		choose: (principalId, provider) => directory.choose(principalId, provider),
+		of: async (principalId) =>
+			Object.freeze({ ...(await directory.of(principalId)) }),
+		picture: (principalId) => directory.picture(principalId),
+	} satisfies PersonProfiles);
+}

package/src/core/identity/profiles.ts

@@ -0,0 +1,82 @@
+/**
+ * How the core names a person. A person's accounts each carry a name and maybe a picture; the
+ * person picks which account represents them (or the host's `profiles.prefer` order does), and
+ * the core shows that name where it names the person: the web app, transcripts, and, when the
+ * host lists the provider in `profiles.modelVisible`, the `Speaker.name` the agents read.
+ */
+
+/**
+ * Where a provider's names and pictures come from. Example: a support inbox registers a
+ * `github` source that reads a user's public profile.
+ */
+export interface ProfileSource {
+	/** The identity provider the source reads, an open string such as `line`, `discord` or `github`. */
+	provider: string;
+	/** What the person sees when choosing, such as "LINE". */
+	label: string;
+	/**
+	 * The source's own default. It never widens anything on its own: the names reach
+	 * `Speaker.name` only for a provider the host lists in `profiles.modelVisible`.
+	 */
+	modelVisible: boolean;
+	/** The https hosts its pictures come from; the picture proxy fetches only these. */
+	pictureHosts: readonly string[];
+	/**
+	 * The name and picture address of one account, or undefined when the provider knows none. It
+	 * has two seconds; a miss, a failure or a timeout is remembered for ten minutes.
+	 */
+	fetch(
+		subject: string,
+		signal: AbortSignal,
+	): Promise<{ name?: string; pictureUrl?: string } | undefined>;
+}
+
+/** How one person is shown. */
+export interface PersonDisplay {
+	name: string;
+	/** The provider the name comes from; absent when it is the principal's own display name. */
+	source?: string;
+	/** Whether `picture` has one to give. */
+	picture: boolean;
+}
+
+/**
+ * The names and pictures of the people the host serves, provided as `PROFILES` by the `identity`
+ * plugin. Fetched and observed names and picture addresses live in memory for at most an hour and
+ * are never stored; only a person's choice of source is.
+ */
+export interface PersonProfiles {
+	/** Adds a source; call it from a plugin's `setup`. A second source for one provider throws. */
+	register(source: ProfileSource): void;
+	/** The registered sources. */
+	sources(): readonly { provider: string; label: string }[];
+	/**
+	 * A name a signed-in session reported for one of the person's linked identities, such as an
+	 * OIDC `name` claim. It is held in memory for an hour, renewed by each sign-in, and never
+	 * stored, so an identity provider becomes a source without a fetch.
+	 */
+	observed(principalId: string, provider: string, name: string): void;
+	/**
+	 * The provider that names the person: their stored choice while it stays linked, else the
+	 * first `profiles.prefer` provider they have linked, else undefined.
+	 */
+	sourceOf(principalId: string): Promise<string | undefined>;
+	/** Stores the person's choice; the provider must be linked to them. `null` returns to the default. */
+	choose(principalId: string, provider: string | null): Promise<void>;
+	/** How the person is shown; their display name when no source names them. */
+	of(principalId: string): Promise<PersonDisplay>;
+	/**
+	 * The person's picture, fetched through the source's allowed hosts, or undefined: an address
+	 * on another host, a redirect, anything but PNG, JPEG, GIF or WebP, and a body over 2 MiB are
+	 * all refused. The answer is `nosniff` and cacheable for an hour by the one browser.
+	 */
+	picture(principalId: string): Promise<Response | undefined>;
+}
+
+/** The `profiles` key of the host's configuration, filled. */
+export interface ProfileRules {
+	/** Providers in the order that names a person who has not chosen, such as `["line", "oidc:<base64url issuer>"]`. */
+	prefer: readonly string[];
+	/** Providers whose names may become `Speaker.name`, which agents read. */
+	modelVisible: readonly string[];
+}

package/src/core/modules/host-shell/shell-policy.ts

@@ -33,7 +33,22 @@ export type { PushPolicy } from "./git-push.ts";
 export { simpleCommands } from "./shell-lexer.ts";
 export { YOLO_CARDED_SHELL_CLASSES } from "./shell-programs.ts";
 
-const MAX_SHOWN_COMMAND = 600;
+const MAX_SHOWN_COMMAND = 120;
+
+/**
+ * The command as a card's sentence shows it: its first line, cut to a length, in one code span.
+ * The card shows the whole command beside it; a second line or a backtick here would break the
+ * sentence's Markdown (a `# comment` line reads as a heading).
+ */
+function shownCommand(command: string): string {
+	const [line = ""] = command.trim().split("\n", 1);
+	const cut = line.length > MAX_SHOWN_COMMAND;
+	const more = cut || line.length < command.trim().length;
+	const shown = (cut ? line.slice(0, MAX_SHOWN_COMMAND) : line)
+		.replaceAll("`", "'")
+		.trimEnd();
+	return more ? `${shown} …` : shown;
+}
 
 /** Pi's built-in shell and file tools, which agent sessions activate. */
 export const SHELL_TOOLS = Object.freeze([
@@ -382,7 +397,7 @@ function shellHold(
 		let detail = `the ${toolName} call`;
 		try {
 			if (toolName === "bash" && typeof input.command === "string")
-				detail = `the shell command \`${input.command.slice(0, MAX_SHOWN_COMMAND)}\``;
+				detail = `the shell command \`${shownCommand(input.command)}\``;
 		} catch {
 			// The input itself cannot be read; the call is held without showing it.
 		}
@@ -410,7 +425,7 @@ function judge(
 		const [first] = found;
 		return first
 			? {
-					action: `run the shell command \`${command.slice(0, MAX_SHOWN_COMMAND)}\` on the host (${first.reason})`,
+					action: `run the shell command \`${shownCommand(command)}\` on the host (${first.reason})`,
 					classes: [...new Set(found.map((held) => held.class))],
 				}
 			: undefined;

package/src/core/modules/prompts/prompt-documents.ts

@@ -0,0 +1,425 @@
+import type { SQL } from "bun";
+import { isCheckDatabase } from "../../db/check-database.ts";
+import type { Migration } from "../../db/migrations.ts";
+import { AgentError } from "../../domain/errors.ts";
+import { type Logger, silentLogger } from "../../log.ts";
+import {
+	PromptHistory,
+	type PromptVersion,
+	promptHistoryMigration,
+} from "./prompt-history.ts";
+
+export type { PromptAction, PromptVersion } from "./prompt-history.ts";
+
+/** The most characters a document may have unless its spec says otherwise. */
+export const DEFAULT_DOCUMENT_CHARS = 20_000;
+
+const DOCUMENT_ID = /^[a-z0-9-]{1,32}$/;
+
+/** A prompt text the owner may edit, with the text from a file as its default. */
+export interface PromptDocumentSpec {
+	/** Lowercase letters, digits and hyphens; names the document for good. */
+	id: string;
+	/** What the owner sees it called. */
+	label: string;
+	/** One line on where the text is used. */
+	description?: string;
+	/**
+	 * The file version: the text read from a file or the configuration. A function is called each
+	 * time the document is read, so a default that follows a file is current.
+	 */
+	default: string | (() => string);
+	/** Default 20,000. */
+	maxChars?: number;
+}
+
+/** A registered document, read by whoever uses its text. */
+export interface PromptHandle {
+	readonly id: string;
+	/** The text in force now: the owner's override while one is set, else the file version. */
+	text(): string;
+}
+
+/** A document as the owner sees it. */
+export interface PromptDocumentView {
+	id: string;
+	label: string;
+	description?: string;
+	/** The text in force. */
+	text: string;
+	/** The file version. */
+	fileText: string;
+	/** An owner's override is set. */
+	overridden: boolean;
+	/** The override is set and its text is not the file version. */
+	differs: boolean;
+	override?: { by: string; at: Date };
+	maxChars: number;
+	/**
+	 * Why the file version cannot be read, when its `default` throws. The document is then listed
+	 * with an empty `fileText`, `differs` false and the override as `text` (empty with none), and
+	 * `set` and `revert` refuse it until the file reads again. One broken document never blanks
+	 * the others.
+	 */
+	broken?: string;
+}
+
+/**
+ * A change made from a text that is no longer the one in force: someone else changed the document
+ * meanwhile. Nothing was written; `current` is what is in force now.
+ */
+export class PromptConflictError extends Error {
+	override name = "PromptConflictError";
+	constructor(readonly current: PromptDocumentView) {
+		super(
+			`The prompt document "${current.id}" changed while it was being edited.`,
+		);
+	}
+}
+
+/**
+ * Prompt texts the owner edits outside the files: each has a file version, an optional override
+ * stored in the database, and a history. The override wins while it is set and is read at every
+ * turn, so a change applies from the next turn without a restart.
+ */
+export interface PromptDocuments {
+	/**
+	 * Registers a document during a plugin's setup. Throws AgentError for an unusable or repeated
+	 * id, and for a `default` that cannot be read now: the host does not start with it.
+	 */
+	register(spec: PromptDocumentSpec): PromptHandle;
+	/**
+	 * The text in force; throws AgentError for an unknown id, and for a document with no override
+	 * whose file version cannot be read (logged as an error naming the document).
+	 */
+	text(id: string): string;
+	/** Every document, in the order they were registered. */
+	list(): PromptDocumentView[];
+	/** One document, or undefined for an unknown id. */
+	get(id: string): PromptDocumentView | undefined;
+	/**
+	 * Sets the override. The text must have 1 to `maxChars` characters and differ from the text in
+	 * force; text equal to the file version reverts instead. Throws AgentError otherwise.
+	 *
+	 * `base` is the text the change was edited from. When it is given and is not the text in force
+	 * when the write comes up in the queue, nothing is written and PromptConflictError carries the
+	 * document as it is now.
+	 */
+	set(
+		id: string,
+		text: string,
+		by: string,
+		base?: string,
+	): Promise<PromptDocumentView>;
+	/**
+	 * Returns to the file version, dropping the override. Throws AgentError when none is set, and
+	 * PromptConflictError as `set` does when `base` is not the text in force.
+	 */
+	revert(id: string, by: string, base?: string): Promise<PromptDocumentView>;
+	/** The changes of one document, newest first. */
+	history(id: string, limit?: number): Promise<PromptVersion[]>;
+}
+
+interface OverrideRow {
+	name: string;
+	text: string;
+	by_name: string;
+	at: Date;
+}
+
+interface Override {
+	text: string;
+	by: string;
+	at: Date;
+}
+
+interface Registered {
+	spec: PromptDocumentSpec;
+}
+
+const fileText = (spec: PromptDocumentSpec): string =>
+	typeof spec.default === "function" ? spec.default() : spec.default;
+
+/** What reading a document's file version gave: its text, or why it could not be read. */
+type FileRead = { text: string } | { broken: string; error: unknown };
+
+const readFile = (spec: PromptDocumentSpec): FileRead => {
+	try {
+		return { text: fileText(spec) };
+	} catch (error) {
+		return {
+			broken: error instanceof Error ? error.message : String(error),
+			error,
+		};
+	}
+};
+
+/** The documents of one guild (or the local team), with their overrides in PostgreSQL. */
+export class PgPromptDocuments implements PromptDocuments {
+	readonly #sql: SQL;
+	readonly #guild: string;
+	readonly #history: PromptHistory;
+	readonly #logger: Logger;
+	readonly #documents = new Map<string, Registered>();
+	readonly #overrides = new Map<string, Override>();
+	/** The tail of the writes, which run one at a time so none reads an override another is about to change. */
+	#queue: Promise<unknown> = Promise.resolve();
+
+	private constructor(sql: SQL, guildId: string, logger: Logger) {
+		this.#sql = sql;
+		this.#guild = guildId;
+		this.#logger = logger;
+		this.#history = new PromptHistory(sql, guildId);
+	}
+
+	/** The overrides and the history, created beside the agent server's own tables. */
+	static migrations(): Migration[] {
+		return [
+			{
+				name: "prompt-overrides",
+				up: async (sql) => {
+					await sql`
+						CREATE TABLE IF NOT EXISTS prompt_overrides (
+							guild_id text NOT NULL,
+							name text NOT NULL,
+							text text NOT NULL,
+							by_name text NOT NULL,
+							at timestamptz NOT NULL DEFAULT now(),
+							PRIMARY KEY (guild_id, name)
+						)`;
+				},
+			},
+			promptHistoryMigration("prompt-history"),
+		];
+	}
+
+	/**
+	 * The documents over the host's migrated pool, holding the overrides of one guild. A file
+	 * version that cannot be read is logged to `logger` as an error naming the document.
+	 */
+	static async attach(
+		sql: SQL,
+		guildId: string,
+		logger: Logger = silentLogger(),
+	): Promise<PgPromptDocuments> {
+		const documents = new PgPromptDocuments(sql, guildId, logger);
+		// `Roundtable.check()` has no database to read the rows from: nothing is overridden.
+		if (!isCheckDatabase(sql)) await documents.#reload();
+		return documents;
+	}
+
+	async #reload(): Promise<void> {
+		const rows: OverrideRow[] = await this
+			.#sql`SELECT name, text, by_name, at FROM prompt_overrides WHERE guild_id = ${this.#guild}`;
+		this.#overrides.clear();
+		for (const row of rows)
+			this.#overrides.set(row.name, {
+				text: row.text,
+				by: row.by_name,
+				at: new Date(row.at),
+			});
+	}
+
+	#serial<T>(write: () => Promise<T>): Promise<T> {
+		const run = this.#queue.then(write);
+		this.#queue = run.catch(() => undefined);
+		return run;
+	}
+
+	register(spec: PromptDocumentSpec): PromptHandle {
+		if (!DOCUMENT_ID.test(spec.id))
+			throw new AgentError(
+				`"${spec.id}" is not a usable prompt document id: use 1 to 32 lowercase letters, digits and hyphens.`,
+			);
+		if (this.#documents.has(spec.id))
+			throw new AgentError(`A prompt document "${spec.id}" already exists.`);
+		if (!spec.label.trim())
+			throw new AgentError(`The prompt document "${spec.id}" needs a label.`);
+		// A default that cannot be read now stops the host here, not at the first turn that needs it.
+		const read = readFile(spec);
+		if ("broken" in read)
+			throw new AgentError(
+				`The prompt document "${spec.id}" has no readable file version: ${read.broken}`,
+			);
+		this.#documents.set(spec.id, { spec });
+		return { id: spec.id, text: () => this.text(spec.id) };
+	}
+
+	#registered(id: string): PromptDocumentSpec {
+		const found = this.#documents.get(id);
+		if (!found) throw new AgentError(`There is no prompt document "${id}".`);
+		return found.spec;
+	}
+
+	/** The file version, or an AgentError naming the document when it cannot be read; logged either way. */
+	#file(spec: PromptDocumentSpec): string {
+		const read = readFile(spec);
+		if (!("broken" in read)) return read.text;
+		this.#logUnreadable(spec, read.error);
+		throw new AgentError(
+			`The file version of the prompt document "${spec.id}" cannot be read: ${read.broken}`,
+		);
+	}
+
+	#logUnreadable(spec: PromptDocumentSpec, error: unknown): void {
+		this.#logger.error(
+			{ document: spec.id, err: error },
+			"the file version of a prompt document cannot be read",
+		);
+	}
+
+	text(id: string): string {
+		const spec = this.#registered(id);
+		return this.#overrides.get(id)?.text ?? this.#file(spec);
+	}
+
+	#view(spec: PromptDocumentSpec): PromptDocumentView {
+		const read = readFile(spec);
+		const override = this.#overrides.get(spec.id);
+		const common = {
+			id: spec.id,
+			label: spec.label,
+			...(spec.description ? { description: spec.description } : {}),
+			overridden: override !== undefined,
+			...(override ? { override: { by: override.by, at: override.at } } : {}),
+			maxChars: spec.maxChars ?? DEFAULT_DOCUMENT_CHARS,
+		};
+		if ("broken" in read) {
+			this.#logUnreadable(spec, read.error);
+			return {
+				...common,
+				text: override?.text ?? "",
+				fileText: "",
+				differs: false,
+				broken: read.broken,
+			};
+		}
+		return {
+			...common,
+			text: override?.text ?? read.text,
+			fileText: read.text,
+			differs: override !== undefined && override.text !== read.text,
+		};
+	}
+
+	list(): PromptDocumentView[] {
+		return [...this.#documents.values()].map(({ spec }) => this.#view(spec));
+	}
+
+	get(id: string): PromptDocumentView | undefined {
+		const found = this.#documents.get(id);
+		return found ? this.#view(found.spec) : undefined;
+	}
+
+	set(
+		id: string,
+		text: string,
+		by: string,
+		base?: string,
+	): Promise<PromptDocumentView> {
+		return this.#serial(async () => {
+			const spec = this.#registered(id);
+			const file = this.#file(spec);
+			const now = this.#overrides.get(id)?.text ?? file;
+			if (base !== undefined && base !== now)
+				throw new PromptConflictError(this.#view(spec));
+			const max = spec.maxChars ?? DEFAULT_DOCUMENT_CHARS;
+			if (!text.trim() || text.length > max)
+				throw new AgentError(
+					`A prompt document must have 1 to ${max} characters; this one has ${text.length}.`,
+				);
+			if (text === now)
+				throw new AgentError("The text is the one already in force.");
+			if (text === file) return this.#revert(id, spec, file, by);
+			const at = new Date();
+			await this.#sql.begin(async (tx) => {
+				await tx`
+					INSERT INTO prompt_overrides (guild_id, name, text, by_name, at)
+					VALUES (${this.#guild}, ${id}, ${text}, ${by}, ${at})
+					ON CONFLICT (guild_id, name) DO UPDATE
+					SET text = EXCLUDED.text, by_name = EXCLUDED.by_name, at = EXCLUDED.at`;
+				await this.#history.record(
+					"document",
+					id,
+					{ action: "set", text, previous: now, by },
+					tx,
+				);
+			});
+			// The cache follows the committed write.
+			this.#overrides.set(id, { text, by, at });
+			return this.#view(spec);
+		});
+	}
+
+	revert(id: string, by: string, base?: string): Promise<PromptDocumentView> {
+		return this.#serial(async () => {
+			const spec = this.#registered(id);
+			const file = this.#file(spec);
+			if (
+				base !== undefined &&
+				base !== (this.#overrides.get(id)?.text ?? file)
+			)
+				throw new PromptConflictError(this.#view(spec));
+			if (!this.#overrides.has(id))
+				throw new AgentError(
+					`"${id}" has no override; the file version is in force.`,
+				);
+			return this.#revert(id, spec, file, by);
+		});
+	}
+
+	async #revert(
+		id: string,
+		spec: PromptDocumentSpec,
+		file: string,
+		by: string,
+	): Promise<PromptDocumentView> {
+		const previous = this.#overrides.get(id)?.text ?? file;
+		await this.#sql.begin(async (tx) => {
+			await tx`DELETE FROM prompt_overrides WHERE guild_id = ${this.#guild} AND name = ${id}`;
+			await this.#history.record(
+				"document",
+				id,
+				{ action: "revert", text: file, previous, by },
+				tx,
+			);
+		});
+		this.#overrides.delete(id);
+		return this.#view(spec);
+	}
+
+	history(id: string, limit?: number): Promise<PromptVersion[]> {
+		this.#registered(id);
+		return this.#history.list("document", id, limit);
+	}
+
+	/**
+	 * Says which documents differ from their file versions, and which overrides name a document
+	 * nobody registers; the host calls it once every plugin has registered its own.
+	 */
+	logOverrides(logger: Logger): void {
+		for (const [id, override] of this.#overrides) {
+			const found = this.#documents.get(id);
+			if (!found) {
+				logger.warn(
+					{ document: id, by: override.by },
+					"a stored prompt override names a document no plugin registers; it is ignored",
+				);
+				continue;
+			}
+			const read = readFile(found.spec);
+			if ("broken" in read) {
+				logger.error(
+					{ document: id, err: read.error },
+					"the file version of a prompt document cannot be read",
+				);
+				continue;
+			}
+			if (override.text === read.text) continue;
+			logger.warn(
+				{ document: id, by: override.by, at: override.at.toISOString() },
+				"a prompt document differs from its file version: the owner's override is in force until it is reverted in the app",
+			);
+		}
+	}
+}