pi-roundtable 0.22.5 → 0.23.0

package/src/core/runtime/extensions/gate-refusals.ts

@@ -2,6 +2,7 @@ import type {
 	HeldCall,
 	PendingConfirmation,
 } from "../../domain/conversation.ts";
+import type { HoldRefusal } from "../../domain/progress.ts";
 import { type OwnerIdentity, ownerWords } from "../../identity.ts";
 import type {
 	ApprovalDetails,
@@ -181,3 +182,25 @@ function orList(items: readonly string[]): string {
 	if (items.length < 2 || last === undefined) return items.join("");
 	return `${items.slice(0, -1).join(", ")} or ${last}`;
 }
+
+/**
+ * Decides for a held call whether the server approves it without a card, and says who approved
+ * it when it does; see `yoloApprover`. `card.speakerOnly` is true when the call's card is the
+ * speaker's alone. It must change nothing but its own record of the approval.
+ */
+export type AutoApprover = (
+	call: HeldCall,
+	card: { speakerOnly: boolean },
+) => ApprovedBy | undefined;
+
+/** What `ConfirmationGate.decide` answers for a call; an empty answer lets the call run. */
+export interface GateDecision {
+	reason?: string;
+	approvedOnCard?: true;
+	/** Who approved the call, when it was held and a surface or a confirming message said who. */
+	approvedBy?: ApprovedBy;
+	/** The id of the card whose approval released the call, in this turn or answered late; absent for a call a message confirmed. */
+	approvedPrompt?: string;
+	/** Why a hold refused the call, for a surface that tells that from a failure; absent when it ran or the turn stopped. */
+	refused?: HoldRefusal;
+}

package/src/core/runtime/extensions/held-calls.ts

@@ -28,6 +28,19 @@ export function sameCall(
 	return a.tool === b.tool && a.input === b.input;
 }
 
+/** Takes the first approval of `call` out of the lists, in order; undefined when none approves it. */
+export function spendApproval<R extends { call: HeldCall }>(
+	lists: readonly R[][],
+	call: Pick<HeldCall, "tool" | "input">,
+): R | undefined {
+	for (const list of lists) {
+		const at = list.findIndex((r) => sameCall(r.call, call));
+		const [spent] = at === -1 ? [] : list.splice(at, 1);
+		if (spent) return spent;
+	}
+	return undefined;
+}
+
 /** JSON with object keys sorted at every level, so equal inputs compare equal. */
 // pi-lens-ignore: no-unknown-parameters — tool input is untyped model JSON; this is where it is read
 export function canonicalJson(value: unknown): string {
@@ -38,7 +51,9 @@ export function canonicalJson(value: unknown): string {
 }
 
 // pi-lens-ignore: no-unknown-parameters — tool input is untyped model JSON; this is where it is read
-function isPlainObject(value: unknown): value is Record<string, unknown> {
+export function isPlainObject(
+	value: unknown,
+): value is Record<string, unknown> {
 	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 

package/src/core/runtime/extensions/hold-describer.ts

@@ -1,4 +1,11 @@
-import { type HoldCheck, type HoldContext, isPromise } from "../../holds.ts";
+import type { ToolTurn } from "../../define.ts";
+import {
+	type ClassedHold,
+	type HoldCheck,
+	type HoldContext,
+	type HoldDescription,
+	isPromise,
+} from "../../holds.ts";
 import { messages } from "../../i18n/index.ts";
 import {
 	awaited,
@@ -8,6 +15,27 @@ import {
 	joinApprovers,
 } from "./hold-lookups.ts";
 
+/** A held call's description with its classes inside, for the gate to record with the call. */
+function withClasses(
+	held: ClassedHold | undefined,
+): HoldDescription | undefined {
+	if (!held) return undefined;
+	const { description, classes } = held;
+	return typeof description === "string"
+		? { text: description, classes }
+		: { ...description, classes };
+}
+
+/** A description without the classes it names. */
+function unclassed(
+	description: HoldDescription | undefined,
+): HoldDescription | undefined {
+	if (typeof description !== "object" || description === null)
+		return description;
+	const { classes: _classes, ...rest } = description;
+	return rest;
+}
+
 /**
  * Asks a conversation's holds to describe a call a turn makes, and hands each description on in
  * the order the calls were made, whichever comes back first, so calls made together are held,
@@ -44,13 +72,7 @@ export class HoldDescriber {
 		if (turn.signal?.aborted) controller.abort();
 		let answer: ReturnType<NonNullable<HoldCheck["inTurn"]>>;
 		try {
-			answer = this.#holds.inTurn?.call(
-				this.#holds,
-				tool,
-				input,
-				this.#context,
-				turn.toolTurn(controller.signal),
-			);
+			answer = this.#ask(tool, input, turn.toolTurn(controller.signal));
 		} catch {
 			answer = messages().holdGeneric(tool);
 		}
@@ -79,6 +101,34 @@ export class HoldDescriber {
 		);
 	}
 
+	/** The holds' answer for the call, with its classes in the description when the holds report them. */
+	#ask(
+		tool: string,
+		input: Record<string, unknown>,
+		toolTurn: ToolTurn,
+	): HoldDescription | undefined | Promise<HoldDescription | undefined> {
+		const classed = this.#holds.inTurnWithClasses;
+		if (!classed) {
+			// A check that does not vouch for its classes has none: yolo mode cards its calls.
+			const answer = this.#holds.inTurn?.call(
+				this.#holds,
+				tool,
+				input,
+				this.#context,
+				toolTurn,
+			);
+			return isPromise(answer) ? answer.then(unclassed) : unclassed(answer);
+		}
+		const answer = classed.call(
+			this.#holds,
+			tool,
+			input,
+			this.#context,
+			toolTurn,
+		);
+		return isPromise(answer) ? answer.then(withClasses) : withClasses(answer);
+	}
+
 	#inOrder<T, R>(
 		described: T | Promise<T>,
 		use: (described: T) => R,

package/src/core/runtime/extensions/hold-lookups.ts

@@ -34,6 +34,8 @@ export interface Judgment {
 	approvers?: readonly string[];
 	/** The card is the speaker's alone; see `HoldDescription`. */
 	speakerOnly?: true;
+	/** The hold classes of the call; see `HoldRule.holdClasses`. Absent when the holds gave none. */
+	classes?: readonly string[] | undefined;
 }
 
 export type Judged = Judgment | undefined | typeof STOPPED;
@@ -57,15 +59,19 @@ function isSignal(value: unknown): value is AbortSignal {
 export function described(
 	answer: HoldDescription,
 	tool: string,
-): Pick<Judgment, "action" | "copy" | "supersede" | "speakerOnly"> {
+): Pick<Judgment, "action" | "copy" | "supersede" | "speakerOnly" | "classes"> {
 	if (typeof answer === "string") return { action: answer };
 	if (typeof answer !== "object" || answer === null)
 		return { action: messages().holdGeneric(tool) };
-	const { text, copy, supersede, approval } = answer;
+	const { text, copy, supersede, approval, classes } = answer;
 	if (typeof text !== "string") return { action: messages().holdGeneric(tool) };
+	const named = Array.isArray(classes)
+		? classes.filter((id): id is string => typeof id === "string" && id !== "")
+		: [];
 	const withdrawal = {
 		...(isSignal(supersede) ? { supersede } : {}),
 		...(approval === "speaker" ? { speakerOnly: true as const } : {}),
+		...(named.length > 0 ? { classes: named } : {}),
 	};
 	if (
 		!copy ||
@@ -135,7 +141,16 @@ export function joinApprovers(
 			copy,
 			supersede,
 			speakerOnly,
+			classes,
 		} = described(action, tool);
+		const joined = (approvers: readonly string[] | undefined): Judgment => ({
+			action: text,
+			...(copy ? { copy } : {}),
+			...(supersede ? { supersede } : {}),
+			...(speakerOnly ? { speakerOnly } : {}),
+			...(classes ? { classes } : {}),
+			...(approvers ? { approvers } : {}),
+		});
 		const controller = new AbortController();
 		if (turn.signal?.aborted) controller.abort();
 		let named:
@@ -155,25 +170,10 @@ export function joinApprovers(
 		}
 		if (!isPromise(named)) {
 			controller.abort();
-			return {
-				action: text,
-				...(copy ? { copy } : {}),
-				...(supersede ? { supersede } : {}),
-				...(speakerOnly ? { speakerOnly } : {}),
-				...(named ? { approvers: named } : {}),
-			};
+			return joined(named);
 		}
 		return awaited(named, [], controller, turn.signal, from.timeoutMs).then(
-			(approvers) => {
-				if (approvers === STOPPED) return STOPPED;
-				return {
-					action: text,
-					...(copy ? { copy } : {}),
-					...(supersede ? { supersede } : {}),
-					...(speakerOnly ? { speakerOnly } : {}),
-					...(approvers ? { approvers } : {}),
-				};
-			},
+			(approvers) => (approvers === STOPPED ? STOPPED : joined(approvers)),
 		);
 	};
 	return isPromise(answer) ? answer.then(join) : join(answer);

package/src/core/runtime/extensions/yolo.ts

@@ -0,0 +1,105 @@
+import type { HeldCall } from "../../domain/conversation.ts";
+import type { TurnRequest } from "../../domain/ports.ts";
+import { SYSTEM_PRINCIPAL } from "../../identity/principal-store.ts";
+import type { ApprovedBy } from "../../interactions/prompts.ts";
+import { type Autonomy, DEFAULT_AUTONOMY } from "../../modes/autonomy.ts";
+import type { ConversationModes } from "../../modes/conversation-modes.ts";
+import { YOLO_CARDED_SHELL_CLASSES } from "../../modules/host-shell/shell-policy.ts";
+import type { ChannelKey } from "../../sessions.ts";
+import type { PiAgentRuntimeOptions } from "../runtime-types.ts";
+import type { AutoApprover } from "./confirmation-gate.ts";
+import type { SpeakerRef } from "./gate-refusals.ts";
+
+/** What a turn's yolo approver needs to know. */
+export interface YoloSeams {
+	/** The conversations' modes: read when a call is held, and told of each approval. */
+	modes: Pick<ConversationModes, "peek" | "autoApproved">;
+	/** The classes yolo may approve although it cards them by default, and those it never approves. */
+	autonomy: Pick<Autonomy, "yolo">;
+	/** The conversation the turn runs in, whose yolo mode decides. */
+	channel: ChannelKey;
+	/** Who spoke the turn: only an owner other than the host's own principal is acted for. */
+	speaker: SpeakerRef;
+	/** The clock, for the time of an approval. */
+	now?: () => Date;
+}
+
+/** The rule a class belongs to: the part before its first dot, or the whole of a rule's own name. */
+function ruleOf(id: string): string {
+	const dot = id.indexOf(".");
+	return dot === -1 ? id : id.slice(0, dot);
+}
+
+/**
+ * Whether an id is a rule's bare name, which a call carries when its rule reports no classes for
+ * it: the call is unclassed. Rule names have no dot and every class id has one.
+ */
+function unclassed(id: string): boolean {
+	return !id.includes(".");
+}
+
+/** The auto-approver of a turn on a runtime built with `options.modes`; undefined without them. */
+export function turnYolo(
+	options: Pick<PiAgentRuntimeOptions, "modes" | "autonomy">,
+	request: Pick<TurnRequest, "channel" | "speaker">,
+): AutoApprover | undefined {
+	const { modes } = options;
+	return modes
+		? yoloApprover({
+				modes,
+				autonomy: options.autonomy ?? DEFAULT_AUTONOMY,
+				channel: request.channel,
+				speaker: request.speaker,
+			})
+		: undefined;
+}
+
+/**
+ * The auto-approver of one turn in a yolo conversation: it answers for a held call, so that no
+ * card opens, only when all of these hold at the time of the call:
+ * - the conversation's yolo mode is on (read now, so a card opened before the toggle stays open);
+ * - the turn's speaker is an owner, and not the host's own principal, which the webhook and report
+ *   turns speak as;
+ * - the call names no approvers and its card is not the speaker's alone;
+ * - the call has classes (a call without them is unknown, so a person decides), and none of them
+ *   is carded: not `autonomy.yolo.card`, not one of its rules named there, not a class in
+ *   `YOLO_CARDED_SHELL_CLASSES` that `autonomy.yolo.allow` leaves out, and not a rule's bare name
+ *   (its call is unclassed) that `autonomy.yolo.allow` leaves out.
+ * It reports who approved as the speaker, marked `auto: "yolo"`, and tells the modes, which log it.
+ */
+export function yoloApprover(seams: YoloSeams): AutoApprover {
+	const { modes, autonomy, channel, speaker } = seams;
+	const allow = new Set(autonomy.yolo.allow);
+	const card = new Set(autonomy.yolo.card);
+	const carded = new Set(YOLO_CARDED_SHELL_CLASSES);
+	const approves = (id: string) => {
+		if (card.has(id) || card.has(ruleOf(id))) return false;
+		// A rule that reports classes has opted in; one that reports none is approved only by name.
+		if (unclassed(id)) return allow.has(id);
+		return !carded.has(id) || allow.has(id);
+	};
+	return (call: HeldCall, { speakerOnly }): ApprovedBy | undefined => {
+		if (!modes.peek(channel).yolo) return undefined;
+		if (speaker.tier !== "owner" || speaker.principalId === SYSTEM_PRINCIPAL)
+			return undefined;
+		if (call.approverIds !== undefined || speakerOnly) return undefined;
+		const classes = call.holdClasses;
+		if (!classes || classes.length === 0 || !classes.every(approves))
+			return undefined;
+		modes.autoApproved({
+			channel,
+			tool: call.tool,
+			action: call.action,
+			classes: [...classes],
+			principalId: speaker.principalId,
+			at: (seams.now ?? (() => new Date()))(),
+		});
+		return {
+			principalId: speaker.principalId,
+			speakerId: speaker.id,
+			name: speaker.name ?? speaker.id,
+			owner: true,
+			auto: "yolo",
+		};
+	};
+}

package/src/core/runtime/pi-agent-runtime.ts

@@ -31,6 +31,7 @@ import { ConversationSessions } from "./conversation-sessions.ts";
 import { confirmedTurnText } from "./extensions/confirmation-gate.ts";
 import { loadsMemory } from "./extensions/private-memory.ts";
 import { missingToolsError } from "./extensions/self-compact-guard.ts";
+import { turnYolo } from "./extensions/yolo.ts";
 import { interimPoster } from "./interim-text.ts";
 import { preflightTools } from "./preflight-tools.ts";
 import { PromptSlot } from "./prompt-slot.ts";
@@ -207,11 +208,7 @@ export class PiAgentRuntime implements AgentRuntime {
 		const missing = wanted.filter((name) => !registered.has(name));
 		if (missing.length > 0) {
 			logger.warn(
-				{
-					channel: request.channel,
-					selection: request.selection.id,
-					missing,
-				},
+				{ channel: request.channel, selection: request.selection.id, missing },
 				"selected tools missing; running without them",
 			);
 		}
@@ -223,6 +220,7 @@ export class PiAgentRuntime implements AgentRuntime {
 			who,
 			request.speaker,
 			conversation.visibility === "private",
+			turnYolo(this.#options, request),
 		);
 		if (request.confirmed && pending && pending.calls.length > 0) {
 			logger.info(

package/src/core/runtime/runtime-plugin.ts

@@ -17,8 +17,9 @@ import {
 	type ModelRef,
 	type ThinkingLevel,
 } from "../models.ts";
+import type { Autonomy } from "../modes/autonomy.ts";
 import type { PluginContext, RoundtablePlugin } from "../plugin.ts";
-import { CONVERSATIONS, IDENTITY, RUNTIME } from "../services.ts";
+import { CONVERSATIONS, IDENTITY, MODES, RUNTIME } from "../services.ts";
 import type { Speaker } from "../speakers.ts";
 import {
 	BRIDGE_MEMORY_FIX,
@@ -28,6 +29,9 @@ import {
 } from "./bridge-guard.ts";
 import { PendingConfirmationStore } from "./pending-confirmation-store.ts";
 import { PiAgentRuntime } from "./pi-agent-runtime.ts";
+import type { PiAgentRuntimeOptions } from "./runtime-types.ts";
+
+const NO_MODES = { yolo: false, longRunning: false } as const;
 
 /** The name of the runtime plugin, as `serviceStarted` events and the migration ledger name it. */
 export const RUNTIME_PLUGIN = "runtime";
@@ -82,6 +86,35 @@ export interface RuntimePluginOptions {
 	memory?: boolean;
 	/** Why the configuration lets several people speak in a shared conversation, as `configuredCrowd` says. */
 	crowd?: string;
+	/** A turn's budget, in ms; see `PiAgentRuntimeOptions.turnTimeoutMs`. */
+	turnTimeoutMs?: number;
+	/** The most one turn works in all, in ms; see `PiAgentRuntimeOptions.turnMaxMs`. */
+	turnMaxMs?: number;
+	/** How long the card at a turn's limit waits, in ms; see `PiAgentRuntimeOptions.turnTimeoutCardMs`. */
+	turnTimeoutCardMs?: number;
+	/** How far yolo and long-running reach; the modes themselves are the `MODES` service's. */
+	autonomy?: Autonomy;
+}
+
+/** The turn limits and autonomy the plugin's options set, as the runtime's options name them. */
+export function turnPolicy(
+	options: RuntimePluginOptions,
+): Pick<
+	PiAgentRuntimeOptions,
+	"turnTimeoutMs" | "turnMaxMs" | "turnTimeoutCardMs" | "autonomy"
+> {
+	return {
+		...(options.turnTimeoutMs === undefined
+			? {}
+			: { turnTimeoutMs: options.turnTimeoutMs }),
+		...(options.turnMaxMs === undefined
+			? {}
+			: { turnMaxMs: options.turnMaxMs }),
+		...(options.turnTimeoutCardMs === undefined
+			? {}
+			: { turnTimeoutCardMs: options.turnTimeoutCardMs }),
+		...(options.autonomy ? { autonomy: options.autonomy } : {}),
+	};
 }
 
 /**
@@ -157,6 +190,14 @@ export function runtimePlugin(
 						},
 						principalOf: async (id) => services.find(IDENTITY)?.principal(id),
 						memory: options.memory === true,
+						// Read at every turn, after every plugin set up; a host without the modes has none on.
+						modes: {
+							peek: (channel) =>
+								services.find(MODES)?.peek(channel) ?? NO_MODES,
+							autoApproved: (entry) =>
+								services.find(MODES)?.autoApproved(entry),
+						},
+						...turnPolicy(options),
 						sessions: context.sessions,
 						agentDir: options.agentDir,
 						modelRuntime: options.modelRuntime,

package/src/core/runtime/runtime-types.ts

@@ -14,6 +14,8 @@ import type { OwnerIdentity } from "../identity.ts";
 import type { PromptScope, Prompts } from "../interactions/prompts.ts";
 import type { Logger } from "../log.ts";
 import type { EffortPolicy, ThinkingLevel, ThinkingPicker } from "../models.ts";
+import type { Autonomy } from "../modes/autonomy.ts";
+import type { ConversationModes } from "../modes/conversation-modes.ts";
 import type { LinkedSessions } from "../plugin.ts";
 import {
 	planOrder,
@@ -108,6 +110,15 @@ export interface PiAgentRuntimeOptions {
 	 * no answer by then the turn is aborted. A turn that cannot show a card is aborted at once.
 	 */
 	turnTimeoutCardMs?: number;
+	/**
+	 * The conversations' modes, read at each turn: a turn in a long-running conversation goes on
+	 * past its time limit without a card, up to `autonomy.longRunningMaxMs` of work, and a turn in
+	 * a yolo conversation has the held calls `autonomy.yolo` allows approved without a card
+	 * (`autoApproved` is told of each). Without it no conversation has either mode.
+	 */
+	modes?: Pick<ConversationModes, "peek" | "autoApproved">;
+	/** How far the modes reach; default `DEFAULT_AUTONOMY`. */
+	autonomy?: Autonomy;
 	/**
 	 * How long a turn that was aborted, by its timeout or a stop, gets to end before its session is
 	 * disposed of and the turn is reported failed; default 15 seconds. A model that ignores the

package/src/core/runtime/turn-budget.ts

@@ -21,9 +21,11 @@ export interface TurnBudget {
 	renew(): number | undefined;
 	/**
 	 * After a limit fired, gives the turn its full budget again from now, as the owner's Continue
-	 * does; with `raiseCap` the cap moves too, to a full budget from now.
+	 * does; with `raiseCap` the cap moves too, to a full budget from now. With `ceilingMs`
+	 * the limit never lands past that much work: a turn that reaches it fires there, as at its cap,
+	 * whatever is left of its budget. A later `extend` without one lifts the ceiling.
 	 */
-	extend(raiseCap: boolean): void;
+	extend(raiseCap: boolean, ceilingMs?: number): void;
 	/** Whether the turn has worked up to its cap, or a limit fired and was not extended. */
 	capped(): boolean;
 	/** The turn's work so far, not counting time the slot spent waiting on cards. */
@@ -72,6 +74,8 @@ export function turnBudget(
 		return now - started - slot.waitedMs(now);
 	};
 	let cap = maxMs;
+	// The work time an extension was told not to pass; none until one is.
+	let ceiling = Number.POSITIVE_INFINITY;
 	let deadline = Math.min(ms, cap);
 	let cancelTimer: (() => void) | undefined;
 	let expired = false;
@@ -81,6 +85,7 @@ export function turnBudget(
 			if (left > 0) return arm(Math.max(left, REARM_FLOOR_MS));
 			expired = true;
 			if (deadline >= cap) expire("turnMax", cap);
+			else if (deadline >= ceiling) expire("turnMax", ceiling);
 			else expire("turn", ms);
 		}, delay);
 	};
@@ -89,15 +94,16 @@ export function turnBudget(
 		renew() {
 			const now = worked();
 			if (expired || now >= cap) return undefined;
-			deadline = Math.min(now + ms, cap);
+			deadline = Math.min(now + ms, cap, ceiling);
 			cancelTimer?.();
 			arm(deadline - now);
 			return deadline - now;
 		},
-		extend(raiseCap) {
+		extend(raiseCap, ceilingMs) {
 			const now = worked();
 			if (raiseCap) cap = Math.max(cap, now + ms);
-			deadline = Math.min(now + ms, cap);
+			ceiling = ceilingMs ?? Number.POSITIVE_INFINITY;
+			deadline = Math.min(now + ms, cap, ceiling);
 			expired = false;
 			cancelTimer?.();
 			arm(Math.max(deadline - now, REARM_FLOOR_MS));
@@ -112,6 +118,17 @@ export function turnBudget(
 export interface TurnBudgetSeams {
 	activity: Pick<ActivityTracker, "now">;
 	clock?: BudgetClock;
+	/**
+	 * Asked when a limit fires, with the turn's work so far: true goes on without a card, as the
+	 * owner's Continue would (a long-running conversation, up to its own cap); false takes the
+	 * limit's usual path, a card or an abort. It also answers for a turn that cannot show a card.
+	 */
+	keepGoing?: (workedMs: number) => boolean;
+	/**
+	 * The work time, in ms, a `keepGoing` extension never carries the turn past: the limit then
+	 * fires at it, as the turn's cap, so a long time limit cannot overshoot the long-running cap.
+	 */
+	ceilingMs?: number;
 }
 
 /**
@@ -121,6 +138,7 @@ export interface TurnBudgetSeams {
  * to go on: Continue extends the limit that fired by a full budget from then, Cancel aborts, and
  * no answer within `turnTimeoutCardMs` (default 5 minutes, wall time) aborts. The card closes
  * when the turn ends first. Without a card the turn is aborted at once. `abort` is told why.
+ * When `seams.keepGoing` says so, the limit is extended server-side first and neither happens.
  */
 export function runtimeTurnBudget(
 	options: Pick<
@@ -172,6 +190,14 @@ export function runtimeTurnBudget(
 		turnMaxMs,
 		slot,
 		(limit, limitMs) => {
+			if (seams.keepGoing?.(budget.workedMs())) {
+				budget.extend(limit === "turnMax", seams.ceilingMs);
+				logger.info(
+					{ channel, limit, workedMs: budget.workedMs() },
+					"long-running mode continued the turn",
+				);
+				return;
+			}
 			const prompts = slot.cards;
 			if (!prompts) return stop(reason(limit, limitMs, "timeout"));
 			const m = messages();
@@ -230,6 +256,7 @@ export function runtimeTurnBudget(
 					undefined,
 					{
 						supersede: controller.signal,
+						purpose: "turn-timeout",
 						wording: {
 							approve: m.turnTimeoutContinue,
 							decline: m.turnTimeoutCancel,

package/src/core/runtime/turn-limits.ts

@@ -3,8 +3,10 @@ import type { TurnResult } from "../domain/conversation.ts";
 import { AgentRunError } from "../domain/errors.ts";
 import { type TurnTimeout, TurnTimeoutError } from "../domain/turn-timeout.ts";
 import { catalogFor } from "../i18n/index.ts";
+import { DEFAULT_AUTONOMY } from "../modes/autonomy.ts";
 import type { ChannelKey } from "../sessions.ts";
 import type { PromptSlot } from "./prompt-slot.ts";
+import type { PiAgentRuntimeOptions } from "./runtime-types.ts";
 import { activityTracker } from "./turn-activity.ts";
 import { runtimeTurnBudget, type TurnBudget } from "./turn-budget.ts";
 
@@ -30,13 +32,22 @@ export function timeoutMessage(timeout: TurnTimeout): string {
 	return catalogFor("en").turnTimedOutNotice(timeout);
 }
 
-/** The time limit of a turn of the built-in runtime; see `runtimeTurnBudget`. `abort` aborts the turn. */
+/**
+ * The time limit of a turn of the built-in runtime; see `runtimeTurnBudget`. `abort` aborts the
+ * turn. In a long-running conversation (`options.modes`) a limit extends the turn instead of
+ * asking or aborting, until the turn has worked `options.autonomy.longRunningMaxMs`.
+ */
 export function turnLimits(
-	options: Parameters<typeof runtimeTurnBudget>[0],
+	options: Parameters<typeof runtimeTurnBudget>[0] &
+		Pick<PiAgentRuntimeOptions, "modes" | "autonomy">,
 	slot: Pick<PromptSlot, "waitedMs" | "cards">,
 	channel: ChannelKey,
 	abort: () => void,
 ): TurnLimits {
+	const { longRunningMaxMs } = options.autonomy ?? DEFAULT_AUTONOMY;
+	const keepGoing = (workedMs: number) =>
+		workedMs < longRunningMaxMs &&
+		options.modes?.peek(channel).longRunning === true;
 	const activity = activityTracker();
 	let timedOut: TurnTimeout | undefined;
 	const budget = runtimeTurnBudget(
@@ -47,7 +58,7 @@ export function turnLimits(
 			timedOut = timeout;
 			abort();
 		},
-		{ activity },
+		{ activity, keepGoing, ceilingMs: longRunningMaxMs },
 	);
 	return {
 		budget,