pi-roundtable 0.25.0 → 0.26.0

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

@@ -0,0 +1,275 @@
+import type { SQL } from "bun";
+import { IdentityError } from "../domain/errors.ts";
+import type { Logger } from "../log.ts";
+import { ProfileChoices } from "./profile-choices.ts";
+import { cleanName, ExpiringMap } from "./profile-memory.ts";
+import {
+	fetchPicture,
+	type Picture,
+	pictureResponse,
+} from "./profile-picture.ts";
+import type {
+	PersonDisplay,
+	PersonProfiles,
+	ProfileRules,
+	ProfileSource,
+} from "./profiles.ts";
+
+const HOUR_MS = 60 * 60_000;
+const MISS_MS = 10 * 60_000;
+const CHOICE_MS = 30_000;
+const FETCH_BUDGET_MS = 2_000;
+const PICTURES_MAX_BYTES = 32 * 1024 * 1024;
+
+/** What a person's linked identities and display name are, as the directory reads them. */
+export interface ProfileLinks {
+	/** The providers and subjects linked to the principal. */
+	identities(
+		principalId: string,
+	): Promise<readonly { provider: string; subject: string }[]>;
+	/** The principal's own display name; undefined for an unknown principal. */
+	displayName(principalId: string): Promise<string | undefined>;
+}
+
+export interface PersonProfilesOptions {
+	sql: SQL;
+	links: ProfileLinks;
+	rules: ProfileRules;
+	logger: Logger;
+	/** The clock, in milliseconds; a test gives its own. */
+	now?: () => number;
+	/** What a source's fetch may take; default two seconds. */
+	fetchBudgetMs?: number;
+	/** Replaces `fetch` for pictures, for a test. */
+	fetch?: (input: string, init?: RequestInit) => Promise<Response>;
+}
+
+interface Fetched {
+	name?: string;
+	pictureUrl?: string;
+}
+
+/** A call that did not finish in its budget. */
+class Slow extends Error {}
+
+const sleepFor = (ms: number): { done: Promise<never>; cancel(): void } => {
+	let timer: ReturnType<typeof setTimeout> | undefined;
+	const done = new Promise<never>((_, reject) => {
+		timer = setTimeout(() => reject(new Slow("budget")), ms);
+	});
+	return { done, cancel: () => clearTimeout(timer) };
+};
+
+/**
+ * The directory behind `PROFILES`: sources, the names they and the sessions report (memory only,
+ * an hour at most), each person's stored choice, and the picture proxy. Names reach
+ * `Speaker.name` only through `modelName`, which the identity service calls, and only for a
+ * provider the host lists in `profiles.modelVisible`.
+ */
+export class PersonDirectory implements PersonProfiles {
+	readonly #sources = new Map<string, ProfileSource>();
+	readonly #observed = new ExpiringMap<string>(10_000);
+	readonly #fetched = new ExpiringMap<Fetched | null>(10_000);
+	readonly #pending = new Map<string, Promise<Fetched | null>>();
+	readonly #pictures = new ExpiringMap<Picture | null>(512);
+	readonly #choices: ProfileChoices;
+	readonly #chosen = new ExpiringMap<string | null>(10_000);
+	readonly #links: ProfileLinks;
+	readonly #prefer: readonly string[];
+	readonly #modelVisible: ReadonlySet<string>;
+	readonly #logger: Logger;
+	readonly #now: () => number;
+	readonly #budget: number;
+	readonly #fetch: PersonProfilesOptions["fetch"];
+
+	constructor(options: PersonProfilesOptions) {
+		this.#choices = new ProfileChoices(options.sql);
+		this.#links = options.links;
+		this.#prefer = options.rules.prefer;
+		this.#modelVisible = new Set(options.rules.modelVisible);
+		this.#logger = options.logger;
+		this.#now = options.now ?? Date.now;
+		this.#budget = options.fetchBudgetMs ?? FETCH_BUDGET_MS;
+		this.#fetch = options.fetch;
+	}
+
+	register(source: ProfileSource): void {
+		if (source.provider.trim() === "")
+			throw new IdentityError("a profile source needs a provider");
+		if (this.#sources.has(source.provider))
+			throw new IdentityError(
+				`a profile source for ${source.provider} is already registered`,
+			);
+		this.#sources.set(source.provider, source);
+	}
+
+	sources(): readonly { provider: string; label: string }[] {
+		return [...this.#sources.values()].map(({ provider, label }) => ({
+			provider,
+			label,
+		}));
+	}
+
+	observed(principalId: string, provider: string, name: string): void {
+		const clean = cleanName(name);
+		if (clean)
+			this.#observed.set(
+				`${principalId}\0${provider}`,
+				clean,
+				this.#now(),
+				HOUR_MS,
+			);
+	}
+
+	async sourceOf(principalId: string): Promise<string | undefined> {
+		const linked = new Set(
+			(await this.#links.identities(principalId)).map((link) => link.provider),
+		);
+		const chosen = await this.#choice(principalId);
+		if (chosen && linked.has(chosen)) return chosen;
+		return this.#prefer.find((provider) => linked.has(provider));
+	}
+
+	async choose(principalId: string, provider: string | null): Promise<void> {
+		if ((await this.#links.displayName(principalId)) === undefined)
+			throw new IdentityError(`there is no principal ${principalId}`);
+		if (provider === null) await this.#choices.clear(principalId);
+		else {
+			const linked = (await this.#links.identities(principalId)).some(
+				(link) => link.provider === provider,
+			);
+			if (!linked)
+				throw new IdentityError(
+					`${provider} is not linked to principal ${principalId}, so it cannot name them`,
+				);
+			await this.#choices.set(principalId, provider);
+		}
+		this.#chosen.delete(principalId);
+	}
+
+	async of(principalId: string): Promise<PersonDisplay> {
+		const provider = await this.sourceOf(principalId);
+		const profile = provider
+			? await this.#profile(principalId, provider)
+			: undefined;
+		if (provider && profile?.name)
+			return {
+				name: profile.name,
+				source: provider,
+				picture: profile.pictureUrl !== undefined,
+			};
+		return {
+			name: (await this.#links.displayName(principalId)) ?? principalId,
+			picture: false,
+		};
+	}
+
+	async picture(principalId: string): Promise<Response | undefined> {
+		const provider = await this.sourceOf(principalId);
+		const source = provider ? this.#sources.get(provider) : undefined;
+		if (!provider || !source) return undefined;
+		const address = (await this.#profile(principalId, provider))?.pictureUrl;
+		if (!address) return undefined;
+		const now = this.#now();
+		let picture = this.#pictures.get(address, now);
+		if (picture === undefined) {
+			picture =
+				(await fetchPicture(address, source.pictureHosts, this.#fetch)) ?? null;
+			const at = this.#now();
+			this.#pictures.set(address, picture, at, picture ? HOUR_MS : MISS_MS);
+			while (
+				this.#pictures.weigh((held) => held?.bytes.byteLength ?? 0) >
+				PICTURES_MAX_BYTES
+			)
+				if (!this.#pictures.evictOldest()) break;
+		}
+		return picture ? pictureResponse(picture) : undefined;
+	}
+
+	/**
+	 * The name `Speaker.name` takes for the principal: their source's name when the host lists its
+	 * provider in `profiles.modelVisible`, else undefined. Core-internal: `PROFILES` does not carry it.
+	 */
+	async modelName(principalId: string): Promise<string | undefined> {
+		if (this.#modelVisible.size === 0) return undefined;
+		const provider = await this.sourceOf(principalId);
+		if (!provider || !this.#modelVisible.has(provider)) return undefined;
+		return (await this.#profile(principalId, provider))?.name;
+	}
+
+	async #choice(principalId: string): Promise<string | undefined> {
+		const now = this.#now();
+		const held = this.#chosen.get(principalId, now);
+		if (held !== undefined) return held ?? undefined;
+		const stored = (await this.#choices.get(principalId)) ?? null;
+		this.#chosen.set(principalId, stored, now, CHOICE_MS);
+		return stored ?? undefined;
+	}
+
+	/** The name a session reported or the source fetched for this provider, and the picture address. */
+	async #profile(
+		principalId: string,
+		provider: string,
+	): Promise<Fetched | undefined> {
+		const observed = this.#observed.get(
+			`${principalId}\0${provider}`,
+			this.#now(),
+		);
+		const source = this.#sources.get(provider);
+		const link = (await this.#links.identities(principalId)).find(
+			(candidate) => candidate.provider === provider,
+		);
+		const fetched =
+			source && link ? await this.#fetchOnce(source, link.subject) : null;
+		const name = observed ?? fetched?.name;
+		if (!name) return undefined;
+		return {
+			name,
+			...(fetched?.pictureUrl ? { pictureUrl: fetched.pictureUrl } : {}),
+		};
+	}
+
+	#fetchOnce(source: ProfileSource, subject: string): Promise<Fetched | null> {
+		const key = `${source.provider}\0${subject}`;
+		const held = this.#fetched.get(key, this.#now());
+		if (held !== undefined) return Promise.resolve(held);
+		const running = this.#pending.get(key);
+		if (running) return running;
+		const call = this.#ask(source, subject).then((found) => {
+			this.#fetched.set(key, found, this.#now(), found ? HOUR_MS : MISS_MS);
+			this.#pending.delete(key);
+			return found;
+		});
+		this.#pending.set(key, call);
+		return call;
+	}
+
+	/** One fetch inside its budget; a miss, a failure and a timeout all read as nothing. */
+	async #ask(source: ProfileSource, subject: string): Promise<Fetched | null> {
+		const controller = new AbortController();
+		const budget = sleepFor(this.#budget);
+		try {
+			const found = await Promise.race([
+				source.fetch(subject, controller.signal),
+				budget.done,
+			]);
+			const name = cleanName(found?.name);
+			return found && (name || found.pictureUrl)
+				? {
+						...(name ? { name } : {}),
+						...(found.pictureUrl ? { pictureUrl: found.pictureUrl } : {}),
+					}
+				: null;
+		} catch (error) {
+			// Only the provider and the kind of failure: no subject, no name, no address.
+			this.#logger.warn(
+				{ provider: source.provider, slow: error instanceof Slow },
+				"a profile source gave no profile",
+			);
+			return null;
+		} finally {
+			budget.cancel();
+			controller.abort();
+		}
+	}
+}

package/src/core/identity/principal-tables.ts

@@ -59,3 +59,13 @@ export const PRINCIPAL_SELF_LINKS = async (sql: SQL): Promise<void> => {
 		ALTER TABLE principal_identities ADD CONSTRAINT principal_identities_source_check
 		CHECK (source IN ('config', 'plugin', 'cli', 'jit', 'legacy', 'self'))`;
 };
+
+/** Which linked account represents each person (`PROFILES.choose`): only the choice, never a name or a picture address. */
+export const PRINCIPAL_PROFILE_CHOICES = async (sql: SQL): Promise<void> => {
+	await sql`
+		CREATE TABLE IF NOT EXISTS principal_profile_choices (
+			principal_id text PRIMARY KEY REFERENCES principals (id) ON DELETE CASCADE,
+			provider text NOT NULL,
+			chosen_at timestamptz NOT NULL DEFAULT now()
+		)`;
+};

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

@@ -0,0 +1,45 @@
+import type { SQL } from "bun";
+
+/**
+ * Which linked account represents each person, the one thing about profiles that is stored. A
+ * name or a picture address is never written to a table.
+ */
+export class ProfileChoices {
+	readonly #sql: SQL;
+
+	constructor(sql: SQL) {
+		this.#sql = sql;
+	}
+
+	async get(principalId: string): Promise<string | undefined> {
+		const rows: { provider: string }[] = await this.#sql`
+			SELECT provider FROM principal_profile_choices WHERE principal_id = ${principalId}`;
+		return rows[0]?.provider;
+	}
+
+	async set(principalId: string, provider: string): Promise<void> {
+		await this.#sql`
+			INSERT INTO principal_profile_choices (principal_id, provider, chosen_at)
+			VALUES (${principalId}, ${provider}, now())
+			ON CONFLICT (principal_id)
+			DO UPDATE SET provider = EXCLUDED.provider, chosen_at = EXCLUDED.chosen_at`;
+	}
+
+	async clear(principalId: string): Promise<void> {
+		await this.#sql`
+			DELETE FROM principal_profile_choices WHERE principal_id = ${principalId}`;
+	}
+}
+
+/**
+ * The provider a principal chose, read for the CLI beside a host that may not have made the table
+ * yet; undefined for no choice or no table.
+ */
+export async function chosenProfileSource(
+	sql: SQL,
+	principalId: string,
+): Promise<string | undefined> {
+	const [table] = await sql`
+		SELECT to_regclass('principal_profile_choices') IS NOT NULL AS made`;
+	return table?.made ? new ProfileChoices(sql).get(principalId) : undefined;
+}

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

@@ -0,0 +1,65 @@
+/** A map whose entries expire, holding at most `max`; the oldest goes first. Memory only. */
+export class ExpiringMap<V> {
+	readonly #entries = new Map<string, { value: V; until: number }>();
+	readonly #max: number;
+
+	constructor(max: number) {
+		this.#max = max;
+	}
+
+	get(key: string, now: number): V | undefined {
+		const entry = this.#entries.get(key);
+		if (!entry) return undefined;
+		if (entry.until <= now) {
+			this.#entries.delete(key);
+			return undefined;
+		}
+		return entry.value;
+	}
+
+	set(key: string, value: V, now: number, ttlMs: number): void {
+		this.#entries.delete(key);
+		this.#entries.set(key, { value, until: now + ttlMs });
+		for (const old of this.#entries.keys()) {
+			if (this.#entries.size <= this.#max) break;
+			this.#entries.delete(old);
+		}
+	}
+
+	delete(key: string): void {
+		this.#entries.delete(key);
+	}
+
+	/** The summed `weight` of what is held, for a cache bounded by size. */
+	weigh(weight: (value: V) => number): number {
+		let total = 0;
+		for (const entry of this.#entries.values()) total += weight(entry.value);
+		return total;
+	}
+
+	/** Drops the oldest entry; false when there is none. */
+	evictOldest(): boolean {
+		for (const old of this.#entries.keys()) {
+			this.#entries.delete(old);
+			return true;
+		}
+		return false;
+	}
+}
+
+const NAME_MAX = 80;
+
+/**
+ * A name a provider or a session reported, made safe to show and to give an agent: control and
+ * invisible formatting characters become spaces, runs of space one, at most 80 characters.
+ * Undefined when nothing is left.
+ */
+export function cleanName(value: unknown): string | undefined {
+	if (typeof value !== "string") return undefined;
+	const text = value
+		.replace(/[\p{Cc}\p{Cf}\u2028\u2029]/gu, " ")
+		.replace(/\s+/g, " ")
+		.trim();
+	if (text === "") return undefined;
+	return [...text].slice(0, NAME_MAX).join("").trim() || undefined;
+}

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;