pi-roundtable 0.22.5 → 0.23.0

package/src/core/holds.ts

@@ -44,6 +44,9 @@ export interface HoldContext {
  * signal that is already aborted when the hold answers refuses the call without a card, and
  * drops a confirmation of it, which is how a hold withdraws what a restart left held: the
  * signals do not survive a restart, but a repeated call is described again.
+ *
+ * `classes` are the hold classes of the call, for a rule that describes it in a turn (see
+ * `HoldRule.holdClasses`); a rule that leaves them out leaves its call unclassed.
  */
 export type HoldDescription =
 	| string
@@ -52,6 +55,7 @@ export type HoldDescription =
 			copy?: NonNullable<ApprovalDetails["copy"]>;
 			supersede?: AbortSignal;
 			approval?: "speaker";
+			classes?: readonly string[];
 	  };
 
 /**
@@ -60,11 +64,34 @@ export type HoldDescription =
  */
 export interface HoldRule {
 	name: string;
+	/**
+	 * Whether the rule stands for other rules' calls, as the precheck scripts' does, and may report
+	 * their ids in `holdClasses`. Any other rule may report only ids that start with its own name
+	 * and a dot. A relay's calls also carry `<name>.relay`, so `autonomy.yolo.card` naming the relay
+	 * cards them.
+	 */
+	relay?: true;
 	describe(
 		tool: string,
 		input: Record<string, unknown>,
 		context: HoldContext,
 	): string | undefined;
+	/**
+	 * The classes of a call this rule holds, as `<rule>.<class>` ids such as `shell.rm`, for yolo
+	 * mode to tell a call it may approve from one it never does (see `autonomy.yolo`). Report only
+	 * classes that are safe to approve with no person looking: listing a class opts the call in, and
+	 * yolo then approves it unless `autonomy.yolo.card` names the class or the rule. List every
+	 * reason the call is held, not only the first: yolo approves only a call whose classes it all
+	 * allows. Every id starts with the rule's name and a dot; a `relay` rule, which stands for other
+	 * rules' calls, may list their ids instead. A rule that reports none,
+	 * or an id that is not so named, leaves the call unclassed: yolo cards it unless
+	 * `autonomy.yolo.allow` names the rule. Asked for a call `describe` held. It must change nothing.
+	 */
+	holdClasses?(
+		tool: string,
+		input: Record<string, unknown>,
+		context: HoldContext,
+	): readonly string[] | undefined;
 	/**
 	 * Whether this rule may hold some call of `tool`, for a rule whose verdict depends on the input
 	 * (such as an action argument). Asked when the input is not known yet, as for a precheck
@@ -119,6 +146,12 @@ export interface HoldRule {
 	mayName?(tool: string): boolean;
 }
 
+/** The description of a held call with its hold classes. */
+export interface ClassedHold {
+	description: HoldDescription;
+	classes: readonly string[];
+}
+
 /** The description of a call that must be approved first, or undefined to let it run. */
 export type HoldCheck = ((
 	tool: string,
@@ -127,6 +160,17 @@ export type HoldCheck = ((
 ) => string | undefined) & {
 	/** The name of a rule that may hold some call of `tool` whatever its input; see `HoldRule.mayHold`. */
 	mayHold?(tool: string): string | undefined;
+	/**
+	 * The classes of the call, from every rule whose `describe` holds it; see
+	 * `HoldRule.holdClasses`. A rule without valid classes of its own gives its bare name, which
+	 * marks the call unclassed. Undefined when no rule holds the call. A check made without `holdChain` has none, and yolo
+	 * mode then never approves its calls.
+	 */
+	classesOf?(
+		tool: string,
+		input: Record<string, unknown>,
+		context: HoldContext,
+	): readonly string[] | undefined;
 	/**
 	 * The check as a turn runs it: each rule's `describeInTurn`, or its `describe` for a rule
 	 * without one, asked in order until one describes the call. It answers at once when every rule
@@ -138,6 +182,18 @@ export type HoldCheck = ((
 		context: HoldContext,
 		turn: ToolTurn,
 	): HoldDescription | undefined | Promise<HoldDescription | undefined>;
+	/**
+	 * `inTurn`, with the classes of every rule that holds the call, as the confirmation gate records
+	 * them with it; see `HoldRule.holdClasses`. The rules after the first that holds the call are
+	 * asked too, and one whose lookup fails leaves its bare name. A description that names its own
+	 * `classes` keeps them. A check without it has no classes for its calls.
+	 */
+	inTurnWithClasses?(
+		tool: string,
+		input: Record<string, unknown>,
+		context: HoldContext,
+		turn: ToolTurn,
+	): ClassedHold | undefined | Promise<ClassedHold | undefined>;
 	/** The highest tier any rule requires to approve the call; see `HoldRule.approvalTier`. */
 	approvalTier?(
 		tool: string,
@@ -173,6 +229,10 @@ export function higherTier(
 export function holdChain(rules: readonly HoldRule[]): HoldCheck {
 	const names = new Set<string>();
 	for (const rule of rules) {
+		if (rule.name.includes("."))
+			throw new PluginError(
+				`hold rule ${rule.name}: the name has a dot, which separates a rule from its hold classes. Rename it.`,
+			);
 		if (names.has(rule.name))
 			throw new PluginError(
 				`hold rule ${rule.name} is registered twice. Rename one of the two.`,
@@ -186,25 +246,90 @@ export function holdChain(rules: readonly HoldRule[]): HoldCheck {
 		}
 		return undefined;
 	};
-	check.inTurn = (tool, input, context, turn) => {
-		const ask = (
-			from: number,
-		): HoldDescription | undefined | Promise<HoldDescription | undefined> => {
-			for (let at = from; at < rules.length; at++) {
-				const rule = rules[at];
-				if (!rule) continue;
-				const description = rule.describeInTurn
+	check.classesOf = (tool, input, context) => {
+		const holding = rules.filter(
+			(r) => r.describe(tool, input, context) !== undefined,
+		);
+		return holding.length === 0
+			? undefined
+			: unionOf(
+					holding.map((rule) => classesFor(rule, names, tool, input, context)),
+				);
+	};
+	/**
+	 * Asks the rules from `from` in order, each holding rule joining `found`. Stops at the first
+	 * holding rule unless `all`; then a later rule whose lookup fails holds the call undescribed.
+	 */
+	const ask = (
+		tool: string,
+		input: Record<string, unknown>,
+		context: HoldContext,
+		turn: ToolTurn,
+		from: number,
+		all: boolean,
+		found: readonly Holding[] = [],
+	): readonly Holding[] | Promise<readonly Holding[]> => {
+		let holding = found;
+		for (let at = from; at < rules.length; at++) {
+			const rule = rules[at];
+			if (!rule) continue;
+			let description: ReturnType<NonNullable<HoldRule["describeInTurn"]>>;
+			try {
+				description = rule.describeInTurn
 					? rule.describeInTurn(tool, input, context, turn)
 					: rule.describe(tool, input, context);
-				if (isPromise(description))
-					return description.then((found) =>
-						found !== undefined ? found : ask(at + 1),
-					);
-				if (description !== undefined) return description;
+			} catch (error) {
+				if (holding.length === 0) throw error;
+				holding = [...holding, { description: undefined, rule }];
+				continue;
+			}
+			if (isPromise(description)) {
+				const before = holding;
+				return description.then(
+					(answer) => {
+						const next =
+							answer === undefined
+								? before
+								: [...before, { description: answer, rule }];
+						return all || next.length === 0
+							? ask(tool, input, context, turn, at + 1, all, next)
+							: next;
+					},
+					(error) => {
+						if (before.length === 0) throw error;
+						return ask(tool, input, context, turn, at + 1, all, [
+							...before,
+							{ description: undefined, rule },
+						]);
+					},
+				);
 			}
-			return undefined;
+			if (description !== undefined) {
+				holding = [...holding, { description, rule }];
+				if (!all) return holding;
+			}
+		}
+		return holding;
+	};
+	check.inTurn = (tool, input, context, turn) => {
+		const found = ask(tool, input, context, turn, 0, false);
+		return isPromise(found)
+			? found.then((holding) => holding[0]?.description)
+			: found[0]?.description;
+	};
+	check.inTurnWithClasses = (tool, input, context, turn) => {
+		const classed = (holding: readonly Holding[]) => {
+			const first = holding.find((held) => held.description !== undefined);
+			if (first?.description === undefined) return undefined;
+			return {
+				description: first.description,
+				classes: unionOf(
+					holding.map((held) => classesIn(held, names, tool, input, context)),
+				),
+			};
 		};
-		return ask(0);
+		const found = ask(tool, input, context, turn, 0, true);
+		return isPromise(found) ? found.then(classed) : classed(found);
 	};
 	check.mayHold = (tool) => rules.find((rule) => rule.mayHold?.(tool))?.name;
 	check.approvalTier = (tool, input, context) =>
@@ -232,6 +357,87 @@ export function holdChain(rules: readonly HoldRule[]): HoldCheck {
 	return check;
 }
 
+/** The classes of a call a rule holds: its own, or the rule's bare name, which leaves the call unclassed. */
+function classesFor(
+	rule: HoldRule,
+	names: ReadonlySet<string>,
+	tool: string,
+	input: Record<string, unknown>,
+	context: HoldContext,
+): readonly string[] {
+	let own: unknown;
+	try {
+		own = rule.holdClasses?.(tool, input, context);
+	} catch {
+		// A rule whose classes fail leaves its call unclassed.
+		own = undefined;
+	}
+	return validClasses(own, rule, names);
+}
+
+/**
+ * The ids a rule reports once each, when it reports some and every one starts with the name of a
+ * rule of the chain and a dot or is that name; otherwise the rule's bare name, which yolo mode
+ * treats as unclassed and cards.
+ */
+function validClasses(
+	reported: unknown,
+	rule: HoldRule,
+	names: ReadonlySet<string>,
+): readonly string[] {
+	if (!Array.isArray(reported) || reported.length === 0) return [rule.name];
+	const ids = reported as unknown[];
+	if (!ids.every((id): id is string => isClassOf(id, rule, names)))
+		return [rule.name];
+	return [
+		...new Set(rule.relay ? [...ids, `${rule.name}.relay`] : ids),
+	] as string[];
+}
+
+/** A rule's description, if it gave one, and the rule; a rule whose lookup failed has none. */
+interface Holding {
+	description: HoldDescription | undefined;
+	rule: HoldRule;
+}
+
+/** The classes of a held call: those its description names, else its rule's. */
+function classesIn(
+	{ description, rule }: Holding,
+	names: ReadonlySet<string>,
+	tool: string,
+	input: Record<string, unknown>,
+	context: HoldContext,
+): readonly string[] {
+	// A rule whose lookup failed could not say what the call is.
+	if (description === undefined) return [rule.name];
+	if (typeof description === "object" && description !== null) {
+		const named = description.classes;
+		if (Array.isArray(named) && named.length > 0)
+			return validClasses(named, rule, names);
+	}
+	return classesFor(rule, names, tool, input, context);
+}
+
+/**
+ * Whether a rule may report the id: it is the rule's own name or one of its classes, or the rule
+ * is a relay and the id is a rule of the chain or one of that rule's classes.
+ */
+function isClassOf(
+	id: unknown,
+	rule: HoldRule,
+	names: ReadonlySet<string>,
+): id is string {
+	if (typeof id !== "string") return false;
+	const dot = id.indexOf(".");
+	const owner = dot === -1 ? id : id.slice(0, dot);
+	return rule.relay ? names.has(owner) : owner === rule.name;
+}
+
+/** The ids of the lists once each, in order. */
+function unionOf(lists: readonly (readonly string[])[]): readonly string[] {
+	return [...new Set(lists.flat())];
+}
+
 /** The principals every list names, in the first list's order; undefined when there are no lists. */
 function commonApprovers(
 	lists: readonly (readonly string[] | undefined)[],

package/src/core/host-registration.ts

@@ -8,7 +8,7 @@ import type { SurfacePort } from "./contract/surface.ts";
 import { NotLinkedError } from "./errors.ts";
 import { EventBus } from "./events.ts";
 import type { RoundtableOptions } from "./host.ts";
-import { HttpListeners } from "./http/listeners.ts";
+import { HttpListeners, listenerAddress } from "./http/listeners.ts";
 import { setLocale } from "./i18n/index.ts";
 import { contactsOf } from "./identity/identity-view.ts";
 import type {
@@ -178,6 +178,7 @@ export class Linkage {
 					return this.registry.dashboard;
 				},
 				apiKey: async (provider) => this.#options.apiKey?.(provider),
+				listener: (id) => listenerAddress(listeners, id),
 			},
 			this.tiers,
 			services,

package/src/core/http/listeners.ts

@@ -20,6 +20,14 @@ export interface HttpRoute {
 	path: { exact: string } | { prefix: string };
 	/** Omitted: every method, for a handler that answers the rest itself. */
 	methods?: readonly string[];
+	/**
+	 * The most bytes of request body this route takes, such as a plugin's upload limit plus its
+	 * multipart overhead. The listener serves the largest value among its routes (a route that
+	 * says nothing counts as `DEFAULT_MAX_REQUEST_BODY_BYTES`) unless the host set the listener's
+	 * own `maxRequestBodyBytes`, which decides; a request over it is answered 413 before the
+	 * handler runs. A positive integer.
+	 */
+	maxRequestBodyBytes?: number;
 	handle(request: Request): Response | Promise<Response>;
 	/**
 	 * Takes the route's WebSocket upgrade requests (GET with `Upgrade: websocket`); every other
@@ -37,8 +45,44 @@ export type ListenerAddress =
 	  }
 	| { port: number; hostname?: string };
 
-/** An address the host serves HTTP on, with the id routes name it by. */
-export type ListenerConfig = { id: string } & ListenerAddress;
+/**
+ * An address the host serves HTTP on, with the id routes name it by. `maxRequestBodyBytes` is the
+ * most bytes of request body the listener takes (a positive integer); without it the listener
+ * takes what its routes ask for, see `HttpRoute.maxRequestBodyBytes`.
+ */
+export type ListenerConfig = {
+	id: string;
+	maxRequestBodyBytes?: number;
+} & ListenerAddress;
+
+/** Bun's own default request body limit, 128 MiB, which a listener sets explicitly. */
+export const DEFAULT_MAX_REQUEST_BODY_BYTES = 128 * 1024 * 1024;
+
+/** The request body limit a listener is opened with: its own option, else its routes' largest ask, else the default. */
+export function requestBodyLimit(
+	listener: ListenerConfig,
+	routes: readonly HttpRoute[],
+): number {
+	if (listener.maxRequestBodyBytes !== undefined)
+		return listener.maxRequestBodyBytes;
+	const asked = routes.map(
+		(route) => route.maxRequestBodyBytes ?? DEFAULT_MAX_REQUEST_BODY_BYTES,
+	);
+	return asked.length === 0
+		? DEFAULT_MAX_REQUEST_BODY_BYTES
+		: Math.max(...asked);
+}
+
+/** The address of the listener `id`, without the id, as a copy a plugin cannot use to change the host's. */
+export function listenerAddress(
+	listeners: readonly ListenerConfig[],
+	id: string,
+): Readonly<ListenerAddress> | undefined {
+	const found = listeners.find((listener) => listener.id === id);
+	if (!found) return undefined;
+	const { id: _id, maxRequestBodyBytes: _limit, ...address } = found;
+	return Object.freeze(address);
+}
 
 const pathOf = (route: HttpRoute) =>
 	"exact" in route.path ? route.path.exact : route.path.prefix;
@@ -88,6 +132,14 @@ function validateLimits(name: string, websocket: WebSocketRoute): void {
 			);
 }
 
+/** Refuses a request body limit that is not a positive integer, naming what set it. */
+function validateBodyLimit(owner: string, value: number | undefined): void {
+	if (value !== undefined && !(Number.isSafeInteger(value) && value > 0))
+		throw new PluginError(
+			`${owner} sets maxRequestBodyBytes to ${value}, which is not a positive integer`,
+		);
+}
+
 /** Refuses routes on unknown listeners, reused names, and any request two routes could both take. */
 function validate(
 	listeners: readonly ListenerConfig[],
@@ -96,7 +148,10 @@ function validate(
 	const ids = new Set(listeners.map((l) => l.id));
 	if (ids.size !== listeners.length)
 		throw new PluginError("a listener is configured twice");
+	for (const listener of listeners)
+		validateBodyLimit(`listener ${listener.id}`, listener.maxRequestBodyBytes);
 	routes.forEach((route, index) => {
+		validateBodyLimit(`route ${route.name}`, route.maxRequestBodyBytes);
 		if (route.websocket && route.methods && !route.methods.includes("GET"))
 			throw new PluginError(
 				`route ${route.name} takes WebSockets, so its methods must include GET`,
@@ -198,11 +253,13 @@ function serveTcp(
 	hostname: string | undefined,
 	fetch: Fetch,
 	websocket: WebSocketHandler<Connection> | undefined,
+	maxRequestBodySize: number,
 ): Server<Connection> {
 	const options = {
 		port,
 		...(hostname ? { hostname } : {}),
 		idleTimeout: 0,
+		maxRequestBodySize,
 		fetch,
 		error: serverError,
 		...(websocket ? { websocket } : {}),
@@ -256,18 +313,20 @@ export class HttpListeners {
 						sockets: this.#sockets,
 					});
 				const websocket = this.#websocketHandler(listener.id, routes);
+				const maxRequestBodySize = requestBodyLimit(listener, routes);
 				if ("socketPath" in listener) {
 					this.#servers.push(
 						websocket
 							? serveUnix(listener.socketPath, handle, {
 									error: serverError,
+									maxRequestBodySize,
 									websocket,
 								})
 							: serveUnix(
 									listener.socketPath,
 									(request) =>
 										routeRequest(routes, request, listener.id, this.#logger),
-									{ error: serverError },
+									{ error: serverError, maxRequestBodySize },
 								),
 					);
 					chmodSync(listener.socketPath, listener.mode ?? 0o660);
@@ -277,6 +336,7 @@ export class HttpListeners {
 						listener.hostname,
 						handle,
 						websocket,
+						maxRequestBodySize,
 					);
 					this.#servers.push(server);
 					if (server.port !== undefined)

package/src/core/i18n/agent-panel.ts

@@ -20,17 +20,11 @@ export function agentPanelEn(ctx: CatalogContext) {
 			skills: string;
 		}) =>
 			`### ${v.displayName}\n-# agent name \`${v.name}\`, cannot be changed\n**Model** · \`${v.model}\` · thinking \`${v.thinking}\`${v.follows}\n${v.skills}\n-# To add or remove a skill, ask any agent to use agent_skills.`,
-		agentAvatarPromptText: (prompt: string) => `**Avatar prompt**\n${prompt}`,
-		agentNoImageProvider:
-			"**Avatar** · No image provider is configured, so this avatar is generated from the agent's display name and cannot be redrawn or edited. A plugin that fills the `images` slot adds drawing.",
 		agentPromptInline: (prompt: string) =>
 			`**Prompt**\n\`\`\`\n${prompt}\n\`\`\``,
 		agentPromptFile: (length: number) =>
 			`**Prompt** · ${length} characters, the full text is in the file below.`,
 		agentEditPromptLabel: "Edit prompt",
-		agentRedrawLabel: "Redraw avatar",
-		agentNewAvatarPromptLabel: "New avatar prompt",
-		agentEditAvatarLabel: "Edit avatar",
 		agentModelLabel: "Model",
 		agentDefaultNote:
 			"A changed prompt takes effect from this agent's next turn; the conversation history is kept.",
@@ -41,12 +35,15 @@ export function agentPanelEn(ctx: CatalogContext) {
 		agentEditModalTitle: (displayName: string) => `Edit ${displayName}`,
 		agentDisplayNameLabel: "Display name",
 		agentPromptLabel: "Prompt",
-		agentAvatarPromptLabel: "Avatar prompt (state the background colour)",
-		agentEditAvatarField: "How to change it (for example: add a hat)",
+		agentLook: (label: string, color: string) =>
+			`**Look** · ${label}, ${color}`,
+		agentClassPlaceholder: "Class",
+		agentColorPlaceholder: "Color",
+		agentLookChanged: "The new picture shows from this agent's next message.",
+		agentLookFailed: (message: string) =>
+			`The look was not changed: ${message}`,
+		agentPanelOutdated: `This panel is out of date; open it again with \`/${ctx.root} profile\`.`,
 		agentSaved: "Saved; it takes effect from the next turn.",
-		agentAvatarRedrawn: "The new avatar shows from this agent's next message.",
-		agentAvatarFailed: (message: string) =>
-			`The avatar was not drawn: ${message}`,
 	};
 }
 
@@ -70,17 +67,11 @@ export function agentPanelZhTW(
 			skills: string;
 		}) =>
 			`### ${v.displayName}\n-# agent 名稱 \`${v.name}\`，不能更改\n**模型**　\`${v.model}\`　thinking \`${v.thinking}\`${v.follows}\n${v.skills}\n-# 要增減 skill，請任一個 agent 用 agent_skills。`,
-		agentAvatarPromptText: (prompt: string) => `**頭像提示詞**\n${prompt}`,
-		agentNoImageProvider:
-			"**頭像**　尚未設定圖像提供者，所以這個頭像由 agent 的顯示名自動產生，不能重畫或修改。要能畫頭像，需要一個填入 `images` 槽位的外掛。",
 		agentPromptInline: (prompt: string) =>
 			`**提示詞**\n\`\`\`\n${prompt}\n\`\`\``,
 		agentPromptFile: (length: number) =>
 			`**提示詞**　${length} 字，完整內容在下面的檔案。`,
 		agentEditPromptLabel: "編輯提示詞",
-		agentRedrawLabel: "重畫頭像",
-		agentNewAvatarPromptLabel: "新頭像提示詞",
-		agentEditAvatarLabel: "修改頭像",
 		agentModelLabel: "模型",
 		agentDefaultNote:
 			"提示詞改完，從這個 agent 的下一回合開始生效；對話紀錄保留。",
@@ -91,10 +82,12 @@ export function agentPanelZhTW(
 		agentEditModalTitle: (displayName: string) => `編輯 ${displayName}`,
 		agentDisplayNameLabel: "顯示名",
 		agentPromptLabel: "提示詞",
-		agentAvatarPromptLabel: "頭像提示詞（寫明背景色）",
-		agentEditAvatarField: "要怎麼改（例如：加一頂帽子）",
+		agentLook: (label: string, color: string) => `**外觀**　${label}，${color}`,
+		agentClassPlaceholder: "職業",
+		agentColorPlaceholder: "顏色",
+		agentLookChanged: "新的頭像從這個 agent 的下一則訊息開始顯示。",
+		agentLookFailed: (message: string) => `外觀沒有改成：${message}`,
+		agentPanelOutdated: `這個面板已經過期，請重新用 \`/${ctx.root} profile\` 開啟。`,
 		agentSaved: "已儲存，從下一回合開始生效。",
-		agentAvatarRedrawn: "新頭像從這個 agent 的下一則訊息開始顯示。",
-		agentAvatarFailed: (message: string) => `頭像沒有畫成：${message}`,
 	};
 }

package/src/core/interactions/prompts.ts

@@ -78,6 +78,12 @@ export interface ApprovedBy {
 	 * approval without it, from anyone else, is not accepted.
 	 */
 	owner?: true;
+	/**
+	 * Set only when the server approved the call itself and no person answered: `"yolo"` is the
+	 * conversation's yolo mode. A surface that reports an answer from a person never sets it;
+	 * `ToolTurn.approvedBy` shows it to the tool.
+	 */
+	auto?: "yolo";
 }
 
 /**
@@ -133,6 +139,12 @@ export interface ApprovalOptions {
 	 * such as a turn's timeout card; a surface that cannot show them keeps its own.
 	 */
 	wording?: ApprovalWording;
+	/**
+	 * What the card asks: `"action"` (the default, also when absent) whether to run a held call,
+	 * `"turn-timeout"` whether to let a turn that reached its time limit go on. A surface may show
+	 * the two differently or notify on the second; Discord ignores it.
+	 */
+	purpose?: "action" | "turn-timeout";
 }
 
 /** A card's words in place of an approval's; see `ApprovalOptions.wording`. */

package/src/core/modes/autonomy.ts

@@ -0,0 +1,23 @@
+/** How far the host lets a conversation run without a person: the limits behind its modes. */
+export interface Autonomy {
+	yolo: {
+		/**
+		 * Hold classes yolo may approve although it cards them by default, such as `shell.rm`, and the
+		 * names of rules that report no classes, such as `tool:repo_push`, whose calls it then approves.
+		 */
+		allow: readonly string[];
+		/** Hold classes or rule names yolo never approves, such as `shell.push` or `tool:repo_push`. */
+		card: readonly string[];
+	};
+	/** The most one long-running turn works in all before it asks or stops, in ms. */
+	longRunningMaxMs: number;
+}
+
+/** The longest a long-running turn works without a person: four hours. */
+export const DEFAULT_LONG_RUNNING_MS = 4 * 60 * 60_000;
+
+/** Yolo approves nothing beyond its built-in classes, and a long-running turn stops at four hours. */
+export const DEFAULT_AUTONOMY: Autonomy = Object.freeze({
+	yolo: Object.freeze({ allow: [], card: [] }),
+	longRunningMaxMs: DEFAULT_LONG_RUNNING_MS,
+});