pi-roundtable 0.26.1 → 0.26.3

package/src/core/modules/schedules/schedule-tools.ts

@@ -8,12 +8,9 @@ import type { ScheduleStore } from "../../services.ts";
 import type { ScheduleToolName } from "../../shared/schedule-tools.ts";
 import { type Tier, tierAtLeast } from "../../speakers.ts";
 import { timeZone, zonedStamp } from "../../time.ts";
+import { precheckCatalog } from "./precheck-catalog.ts";
 import { type PrecheckTool, precheckScriptTools } from "./precheck-tools.ts";
-import {
-	PRECHECK_SCRIPT_CHARS,
-	type PrecheckFinding,
-	type PrecheckRegistry,
-} from "./prechecks.ts";
+import { PRECHECK_SCRIPT_CHARS, type PrecheckRegistry } from "./prechecks.ts";
 import {
 	describeRecurrence,
 	nextRun,
@@ -22,11 +19,10 @@ import {
 	type RecurrenceInput,
 } from "./recurrence.ts";
 import type { NewSchedule, Schedule } from "./schedule-store.ts";
+import { timeLimitInput, timeLimitText } from "./time-limit.ts";
 
 const TITLE_CHARS = 80;
 const LIST_PROMPT_PREVIEW = 200;
-/** How long schedule_list waits for the script runner to say what a script may call. */
-const DESCRIBE_TIMEOUT_MS = 10_000;
 const DAY_MS = 86_400_000;
 
 export interface ScheduleToolContext {
@@ -40,6 +36,12 @@ export interface ScheduleToolContext {
 	> &
 		Partial<Pick<ScheduleStore, "all" | "createWithin">>;
 	channel: ChannelKey;
+	/**
+	 * Every conversation whose schedules the asker lists, changes, and cancels, `channel` among
+	 * them: an agent's own across all its conversations. Without it, `channel` alone. A new
+	 * schedule is always made in `channel`.
+	 */
+	channels?: readonly ChannelKey[];
 	/** Whose schedules these are; its `schedules` limits apply, and without them nothing is scheduled. */
 	target: BackgroundTarget;
 	/**
@@ -158,48 +160,6 @@ function toolsText(tools: readonly PrecheckTool[] | undefined): string {
 		.join(", ");
 }
 
-/** The prechecks a schedule may name or write, for schedule_list; empty when the host offers neither. */
-async function precheckCatalog(ctx: ScheduleToolContext): Promise<string> {
-	const all = ctx.prechecks?.list() ?? [];
-	const runner = ctx.prechecks?.scriptRunner?.();
-	const named =
-		all.length === 0
-			? ""
-			: `\n\nPrechecks you can attach with precheck on schedule_create or schedule_update; the host runs one before each turn and wakes you only when it finds something:\n${all.map((p) => `- ${p.name}: ${p.description.replace(/\n/g, " ")}`).join("\n")}`;
-	if (!runner) return named;
-	// The list still answers when the host cannot say, or is slow to say, what a script may reach here.
-	let timer: ReturnType<typeof setTimeout> | undefined;
-	const late = new Promise<string>((resolve) => {
-		timer = setTimeout(
-			() => resolve("it did not answer in time"),
-			DESCRIBE_TIMEOUT_MS,
-		);
-	});
-	const described = Promise.resolve()
-		.then(() =>
-			runner.describe({
-				channel: ctx.channel,
-				target: ctx.target.name,
-				tier: ctx.author.tier,
-			}),
-		)
-		.then(
-			(text) => ({ text }),
-			(error: unknown) => ({
-				error: error instanceof Error ? error.message : String(error),
-			}),
-		);
-	const answer = await Promise.race([
-		described,
-		late.then((error) => ({ error })),
-	]).finally(() => clearTimeout(timer));
-	const guide =
-		"text" in answer
-			? answer.text
-			: `The host could not say what a script may call here (${answer.error}); a script set now may fail when it runs.`;
-	return `${named}\n\nYou can write a precheck of your own instead, with precheck_script on schedule_create or schedule_update (null removes it): a JavaScript module, at most ${PRECHECK_SCRIPT_CHARS} characters, that the host runs in a sandbox before each turn. A schedule has a precheck or a precheck_script, not both.\n${guide}`;
-}
-
 function hasTiming(input: Input): boolean {
 	return [
 		"in_minutes",
@@ -225,7 +185,7 @@ function timing(ctx: ScheduleToolContext, input: Input): [Recurrence, Date] {
 	return [recurrence, next];
 }
 
-function line(schedule: Schedule): string {
+function line(schedule: Schedule, where?: ChannelKey): string {
 	const prompt =
 		schedule.prompt.length > LIST_PROMPT_PREVIEW
 			? `${schedule.prompt.slice(0, LIST_PROMPT_PREVIEW)}…`
@@ -235,10 +195,12 @@ function line(schedule: Schedule): string {
 		: schedule.precheckScript
 			? `; precheck script (${schedule.precheckScript.length} characters; tools: ${toolsText(schedule.precheckTools)})`
 			: "";
+	const limit = timeLimitText(schedule.timeLimitMinutes);
 	const last = schedule.lastRun
 		? `; last run ${zonedStamp(schedule.lastRun)} (${schedule.lastStatus ?? "?"})`
 		: "";
-	return `- #${schedule.id} ${schedule.title}: ${describeRecurrence(schedule.recurrence)}, next ${zonedStamp(schedule.nextRun)}; set by ${schedule.createdByName}${precheck}${last}\n  ${prompt.replace(/\n/g, " ")}`;
+	const fires = where ? `; fires in ${where}` : "";
+	return `- #${schedule.id} ${schedule.title}: ${describeRecurrence(schedule.recurrence)}, next ${zonedStamp(schedule.nextRun)}${fires}; set by ${schedule.createdByName}${precheck}${limit}${last}\n  ${prompt.replace(/\n/g, " ")}`;
 }
 
 /** The principal who created a schedule. */
@@ -262,11 +224,15 @@ async function visible(
 	);
 }
 
+/** The conversations whose schedules the asker reaches. */
+const scopeOf = (ctx: ScheduleToolContext): readonly ChannelKey[] =>
+	ctx.channels ?? [ctx.channel];
+
 async function own(ctx: ScheduleToolContext, input: Input): Promise<Schedule> {
 	const schedule = await ctx.store.get(id(input));
 	if (
 		!schedule ||
-		schedule.channel !== ctx.channel ||
+		!scopeOf(ctx).includes(schedule.channel) ||
 		!(await visible(ctx, schedule))
 	)
 		throw new ScheduleError(
@@ -368,6 +334,8 @@ export async function callScheduleTool(
 			const script = given("precheck_script")
 				? precheckScript(ctx, input.precheck_script)
 				: undefined;
+			const timeLimitMinutes =
+				timeLimitInput(input.time_limit_minutes) ?? undefined;
 			const existing = await ctx.store.forChannel(ctx.channel);
 			if (existing.length >= limits.perChannel)
 				throw new ScheduleError(
@@ -384,6 +352,7 @@ export async function callScheduleTool(
 				createdByName: ctx.author.name,
 				createdTier: ctx.author.tier,
 				...(precheck ? { precheck } : {}),
+				...(timeLimitMinutes ? { timeLimitMinutes } : {}),
 				...(script
 					? { precheckScript: script.script, precheckTools: script.tools }
 					: {}),
@@ -393,7 +362,7 @@ export async function callScheduleTool(
 				: script
 					? "; its precheck script runs first"
 					: "";
-			return `Scheduled #${made.id} "${title}": ${describeRecurrence(recurrence)}, first run ${zonedStamp(next)} ${messages().zoneTime(timeZone())}${checked}.`;
+			return `Scheduled #${made.id} "${title}": ${describeRecurrence(recurrence)}, first run ${zonedStamp(next)} ${messages().zoneTime(timeZone())}${checked}${timeLimitText(made.timeLimitMinutes)}.`;
 		}
 		case "schedule_list": {
 			if (input.id !== undefined) {
@@ -404,12 +373,18 @@ export async function callScheduleTool(
 				return `${line(schedule).split("\n")[0]}\n\nPrompt:\n${schedule.prompt}${script}`;
 			}
 			const all: Schedule[] = [];
-			for (const schedule of await ctx.store.forChannel(ctx.channel))
-				if (await visible(ctx, schedule)) all.push(schedule);
+			for (const channel of scopeOf(ctx))
+				for (const schedule of await ctx.store.forChannel(channel))
+					if (await visible(ctx, schedule)) all.push(schedule);
+			// Across several conversations each line says where it fires.
+			const across = scopeOf(ctx).length > 1;
+			if (across) all.sort((a, b) => a.nextRun.getTime() - b.nextRun.getTime());
 			const listed =
 				all.length === 0
-					? "This channel has no schedules."
-					: `It is ${zonedStamp(ctx.now)} in ${messages().zoneName(timeZone())}.\n${all.map(line).join("\n")}`;
+					? across
+						? "You have no schedules in any of your conversations."
+						: "This channel has no schedules."
+					: `It is ${zonedStamp(ctx.now)} in ${messages().zoneName(timeZone())}.\n${all.map((s) => line(s, across ? s.channel : undefined)).join("\n")}`;
 			return `${listed}${await precheckCatalog(ctx)}`;
 		}
 		case "schedule_update": {
@@ -442,25 +417,31 @@ export async function callScheduleTool(
 				change.precheckScript = script.script;
 				change.precheckTools = script.tools;
 			}
+			const timeLimit = timeLimitInput(input.time_limit_minutes);
+			if (timeLimit !== undefined) change.timeLimitMinutes = timeLimit;
 			if (change.precheck) change.precheckScript = null;
 			if (change.precheckScript) change.precheck = null;
 			if (Object.keys(change).length === 0)
 				throw new ScheduleError(
-					"give a title, prompt, timing, precheck, or precheck_script to change",
+					"give a title, prompt, timing, precheck, precheck_script, or time_limit_minutes to change",
 				);
-			const updated = await ctx.store.update(ctx.channel, schedule.id, change);
+			const updated = await ctx.store.update(
+				schedule.channel,
+				schedule.id,
+				change,
+			);
 			if (!updated) throw new ScheduleError(`schedule #${schedule.id} is gone`);
 			const checked = updated.precheck
 				? `; precheck ${updated.precheck} runs first`
 				: updated.precheckScript
 					? "; its precheck script runs first"
 					: "";
-			return `Updated #${updated.id} "${updated.title}": ${describeRecurrence(updated.recurrence)}, next run ${zonedStamp(updated.nextRun)}${checked}.`;
+			return `Updated #${updated.id} "${updated.title}": ${describeRecurrence(updated.recurrence)}, next run ${zonedStamp(updated.nextRun)}${checked}${timeLimitText(updated.timeLimitMinutes)}.`;
 		}
 		case "schedule_cancel": {
 			notTheHost(ctx, "cancel no schedules; ask the owner to cancel it");
 			const schedule = changeable(ctx, await own(ctx, input));
-			await ctx.store.remove(schedule.id, ctx.channel);
+			await ctx.store.remove(schedule.id, schedule.channel);
 			return `Cancelled #${schedule.id} "${schedule.title}".`;
 		}
 		default:
@@ -468,28 +449,4 @@ export async function callScheduleTool(
 	}
 }
 
-/** What the schedule's precheck found, or how it failed, under its own heading after the task. */
-function findingText(finding: PrecheckFinding): string[] {
-	return "error" in finding
-		? [
-				"",
-				`### Precheck failed: ${finding.precheck}`,
-				`The precheck that decides whether this task needs you failed, so you were woken anyway: ${finding.error}. Check what it watches yourself, and say so if it needs fixing.`,
-			]
-		: ["", `### Precheck found (${finding.precheck}):`, finding.context];
-}
-
-/** What a scheduled run receives as its message, with what its precheck found when it has one. */
-export function scheduledTurnText(
-	schedule: Schedule,
-	firedAt: Date,
-	finding?: PrecheckFinding,
-): string {
-	return [
-		`## Scheduled task #${schedule.id}: ${schedule.title}`,
-		`${schedule.createdByName} set this schedule (${describeRecurrence(schedule.recurrence)}). It is due now, ${zonedStamp(firedAt)} ${messages().zoneTime(timeZone())}. Nobody wrote a new message: carry out the task below and write what you would post in this channel. If the task keeps a record for later runs, update it with schedule_update on #${schedule.id}.`,
-		"",
-		schedule.prompt,
-		...(finding ? findingText(finding) : []),
-	].join("\n");
-}
+export { scheduledTurnText } from "./scheduled-turn-text.ts";

package/src/core/modules/schedules/scheduled-turn-text.ts

@@ -0,0 +1,31 @@
+import { messages } from "../../i18n/index.ts";
+import { timeZone, zonedStamp } from "../../time.ts";
+import type { PrecheckFinding } from "./prechecks.ts";
+import { describeRecurrence } from "./recurrence.ts";
+import type { Schedule } from "./schedule-store.ts";
+
+/** What the schedule's precheck found, or how it failed, under its own heading after the task. */
+function findingText(finding: PrecheckFinding): string[] {
+	return "error" in finding
+		? [
+				"",
+				`### Precheck failed: ${finding.precheck}`,
+				`The precheck that decides whether this task needs you failed, so you were woken anyway: ${finding.error}. Check what it watches yourself, and say so if it needs fixing.`,
+			]
+		: ["", `### Precheck found (${finding.precheck}):`, finding.context];
+}
+
+/** What a scheduled run receives as its message, with what its precheck found when it has one. */
+export function scheduledTurnText(
+	schedule: Schedule,
+	firedAt: Date,
+	finding?: PrecheckFinding,
+): string {
+	return [
+		`## Scheduled task #${schedule.id}: ${schedule.title}`,
+		`${schedule.createdByName} set this schedule (${describeRecurrence(schedule.recurrence)}). It is due now, ${zonedStamp(firedAt)} ${messages().zoneTime(timeZone())}. Nobody wrote a new message: carry out the task below and write what you would post in this channel. If the task keeps a record for later runs, update it with schedule_update on #${schedule.id}.`,
+		"",
+		schedule.prompt,
+		...(finding ? findingText(finding) : []),
+	].join("\n");
+}

package/src/core/modules/schedules/schedules.ts

@@ -68,6 +68,18 @@ function withAgentOption(spec: ScheduleToolSpec): ScheduleToolSpec {
 	};
 }
 
+/** The tools that reach every one of an agent's conversations say so, since they read "this channel's" otherwise. */
+function withAgentScope(spec: ScheduleToolSpec): ScheduleToolSpec {
+	if (
+		!["schedule_list", "schedule_update", "schedule_cancel"].includes(spec.name)
+	)
+		return spec;
+	return {
+		...spec,
+		description: `${spec.description} As an agent you reach all your own schedules, whichever of your conversations (Discord, the web app) they were made in; schedule_list says where each fires. A new schedule belongs to the conversation you are in.`,
+	};
+}
+
 /**
  * Registers the schedule tools for one conversation; a schedule's runs speak for the person whose
  * turn set it up, and in a turn nobody is named for the tools refuse. With `agents`,
@@ -79,6 +91,11 @@ export function schedulesExtension(
 	agents?: AgentChannelLookup,
 	/** The person the running turn is for; their schedules run at their tier. */
 	speaker: () => Speaker | undefined = () => undefined,
+	/**
+	 * An agent's conversations, asked when a tool runs: its schedules in all of them are listed,
+	 * changed, and cancelled, `channel`'s among them; without it, `channel`'s alone.
+	 */
+	conversations?: () => readonly ChannelKey[],
 ): ExtensionFactory {
 	const {
 		store,
@@ -94,7 +111,8 @@ export function schedulesExtension(
 		timeZone: timeZone(),
 		precheckScripts: prechecks?.scriptRunner?.() !== undefined,
 	}).map((base) => {
-		const spec = agents ? withAgentOption(base) : base;
+		const named = agents ? withAgentOption(base) : base;
+		const spec = conversations ? withAgentScope(named) : named;
 		return {
 			...spec,
 			run: async (input: ToolInput) => {
@@ -104,14 +122,20 @@ export function schedulesExtension(
 						"schedules are kept only in a turn someone is named for, whose schedules they are",
 					);
 				const peer =
-					agents && typeof input.agent === "string" && input.agent
+					spec.name === "schedule_list" &&
+					agents &&
+					typeof input.agent === "string" &&
+					input.agent
 						? agents(input.agent, channel)
 						: undefined;
 				const target = peer ?? (await channelFor(channel, author.principalId));
+				// Another agent's schedules are read in its one channel; an agent's own span its conversations.
+				const own = peer ? undefined : conversations?.();
 				const answer = await callScheduleTool(
 					{
 						store,
 						channel: target,
+						...(own ? { channels: [...new Set([target, ...own])] } : {}),
 						target: kept,
 						author: {
 							principalId: author.principalId,

package/src/core/modules/schedules/time-limit.ts

@@ -0,0 +1,27 @@
+import { ScheduleError } from "../../domain/errors.ts";
+import { MAX_SCHEDULE_TIME_LIMIT_MINUTES } from "../../shared/schedule-tools.ts";
+
+/**
+ * A schedule's time limit from a tool's input: undefined when it names none, null when it asks
+ * for the runtime's default again, else whole minutes within the schedule limit's maximum.
+ */
+export function timeLimitInput(value: unknown): number | null | undefined {
+	if (value === undefined || value === null) return value;
+	if (
+		typeof value !== "number" ||
+		!Number.isInteger(value) ||
+		value < 1 ||
+		value > MAX_SCHEDULE_TIME_LIMIT_MINUTES
+	)
+		throw new ScheduleError(
+			`time_limit_minutes must be a whole number of minutes from 1 to ${MAX_SCHEDULE_TIME_LIMIT_MINUTES}`,
+		);
+	return value;
+}
+
+/** The time limit as the schedule's lines and replies say it; empty for the default. */
+export function timeLimitText(minutes: number | undefined): string {
+	return minutes === undefined
+		? ""
+		: `; each run may work up to ${minutes} min`;
+}

package/src/core/presentation/reply-body.ts

@@ -23,3 +23,11 @@ export function replyBody(result: TurnResult): {
 		...(result.files?.length ? { files: result.files } : {}),
 	};
 }
+
+/**
+ * Whether a turn ended with nothing to post: an unattended turn, such as a schedule's, that had
+ * nothing to say. It is no failure and shows no notice.
+ */
+export function isQuiet(result: TurnResult): boolean {
+	return result.ok && !result.text.trim() && !result.files?.length;
+}

package/src/core/routing/conversation-turns.ts

@@ -13,7 +13,7 @@ import { HostStoppingError, PluginError } from "../errors.ts";
 import { SYSTEM_PRINCIPAL } from "../identity/principal-store.ts";
 import type { Logger } from "../log.ts";
 import type { EventSink } from "../plugin.ts";
-import { replyBody } from "../presentation/reply-body.ts";
+import { isQuiet, replyBody } from "../presentation/reply-body.ts";
 import { withReplyFiles } from "../reply-files.ts";
 import type { ChannelKey, ToolSelection, TurnSelection } from "../sessions.ts";
 import type { Speaker } from "../speakers.ts";
@@ -45,8 +45,17 @@ export interface ConversationTurnInput {
 	selection?: TurnSelection;
 	/** The owner's own chat turn, which their next messages may steer. */
 	steerable?: boolean;
+	/** The speaker's message started the turn (not a schedule or report): it may spend a late approval. */
+	byMessage?: boolean;
 	/** The turn may ask the owner on the surface's prompts, such as approvals of held actions. */
 	interactive?: boolean;
+	/**
+	 * No person waits on the answer, as for a schedule's turn: an empty final answer then ends the
+	 * turn quietly, with nothing posted and `reply` not called, instead of failing it.
+	 */
+	unattended?: boolean;
+	/** How long the turn may work, in ms, in place of the runtime's default; a schedule's own limit. */
+	timeLimitMs?: number;
 	/**
 	 * The speaker confirmed the channel's held actions, so they may run in this turn, except those
 	 * that named approvers the speaker is neither among nor an owner of, which stay held.
@@ -205,7 +214,12 @@ export function conversationTurns(
 									: {}),
 								...(input.confirmed ? { confirmed: true } : {}),
 								...(input.steerable ? { steerable: true } : {}),
+								...(input.byMessage ? { byMessage: true } : {}),
 								...(input.interactive ? { interactive: true } : {}),
+								...(input.unattended ? { unattended: true } : {}),
+								...(input.timeLimitMs === undefined
+									? {}
+									: { timeLimitMs: input.timeLimitMs }),
 								...(interim ? { interim } : {}),
 								progress,
 							}),
@@ -223,7 +237,12 @@ export function conversationTurns(
 			try {
 				if (!result.ok && !result.stopped)
 					logger.error({ channel, kind, err: result.error }, "turn failed");
-				if (input.reply) await input.reply(result);
+				if (isQuiet(result))
+					logger.info(
+						{ channel, kind },
+						"unattended turn had nothing to say; nothing posted",
+					);
+				else if (input.reply) await input.reply(result);
 				else await surfaces.sendReply(channel, replyBody(result));
 			} catch (error) {
 				logger.error({ channel, kind, err: error }, "reply not posted");

package/src/core/runtime/extensions/ask-user.ts

@@ -87,7 +87,7 @@ export function askUserExtension(
 				const prompts = slot.prompts;
 				if (!prompts)
 					return toolText(
-						`${o.name} cannot answer buttons in this turn, such as a schedule's. Ask ${o.him} in your reply instead.`,
+						`${o.name} cannot answer buttons in this turn: no one wrote to you, a schedule or another agent started it, so nothing waits. Do not call ask_user again. Write the question as your final answer instead; it is posted to this channel for ${o.him} to read, and ${o.his} answer comes in a new turn.`,
 					);
 				const p = params as {
 					questions: {

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

@@ -40,8 +40,14 @@ import {
 	unexpired,
 } from "./held-calls.ts";
 import { HoldDescriber } from "./hold-describer.ts";
-import { type HoldTurn, type Judgment, STOPPED } from "./hold-lookups.ts";
+import {
+	type HoldTurn,
+	heldCall,
+	type Judgment,
+	STOPPED,
+} from "./hold-lookups.ts";
 import { lateOutcome } from "./late-answer.ts";
+import { LateReleases } from "./late-releases.ts";
 
 export { confirmationGateExtension } from "./confirmation-gate-extension.ts";
 export {
@@ -70,14 +76,13 @@ export class ConfirmationGate {
 	#selectionId: string | undefined;
 	/** The running turn's speaker, whom the actions it holds belong to, and who approves those a message confirmed. */
 	#speaker: SpeakerRef | undefined;
+	#lateSpender: SpeakerRef | undefined;
 	/** Whether the running turn's conversation is private to its speaker, who then alone answers its cards. */
 	#private = false;
-	/** The running turn's auto-approver, asked before any card opens. */
 	#auto: AutoApprover | undefined;
 	#pending: PendingConfirmation | undefined;
 	#approved: Release[] = [];
-	/** Calls approved on their cards after the turn that asked stopped waiting; each runs once, in any turn. */
-	#lateApproved: Release[] = [];
+	readonly #late = new LateReleases();
 	/** Who approved each call that is running, and on which card, by tool call id, until its result is back. */
 	readonly #grants = new Grants();
 	readonly #holds: HoldCheck;
@@ -162,7 +167,7 @@ export class ConfirmationGate {
 	 * the approver the calls' `run` sees; a call that named approvers is released only when the
 	 * speaker is one of them or an owner, and otherwise stays held. `isPrivate` says the turn's
 	 * conversation is private to its speaker: they alone then answer its cards. `auto` may approve
-	 * a call the turn makes without a card (yolo mode); it does not change a message's approval.
+	 * a call without a card (yolo mode). `byMessage`: a person's message started the turn.
 	 */
 	beginTurn(
 		selectionId: string,
@@ -171,9 +176,11 @@ export class ConfirmationGate {
 		speaker?: SpeakerRef,
 		isPrivate = false,
 		auto?: AutoApprover,
+		byMessage = false,
 	): void {
 		this.#selectionId = selectionId;
 		this.#speaker = speaker;
+		this.#lateSpender = byMessage ? speaker : undefined;
 		this.#private = isPrivate;
 		this.#auto = auto;
 		this.#addressee = addressee ?? this.#owner;
@@ -184,7 +191,6 @@ export class ConfirmationGate {
 			call,
 			...(by ? { by } : {}),
 		}));
-		// What the speaker could not release stays held for those who may.
 		const kept = (held?.calls ?? []).filter(
 			(call) => confirmed && !released?.calls.includes(call),
 		);
@@ -214,17 +220,15 @@ export class ConfirmationGate {
 	#sweep(): void {
 		const kept = (call: HeldCall) =>
 			(this.#pending?.calls.some((c) => sameCall(c, call)) ?? false) ||
-			[...this.#approved, ...this.#lateApproved].some((r) =>
-				sameCall(r.call, call),
-			);
+			this.#approved.some((r) => sameCall(r.call, call)) ||
+			this.#late.has(call);
 		this.#withdrawals.sweep(kept);
 	}
 
 	/** A plugin withdrew `call`: nothing that could run it stays, and what is held is kept anew. */
 	#forget(call: HeldCall): void {
-		const other = (r: { call: HeldCall }) => !sameCall(r.call, call);
-		this.#approved = this.#approved.filter(other);
-		this.#lateApproved = this.#lateApproved.filter(other);
+		this.#approved = this.#approved.filter((r) => !sameCall(r.call, call));
+		this.#late.drop(call);
 		const pending = this.#pending;
 		if (!pending?.calls.some((c) => sameCall(c, call))) return;
 		// In place, so a partial release's kept set stays the object `remembered` compares.
@@ -338,7 +342,7 @@ export class ConfirmationGate {
 					// A late answer on the card: the text of the turn that tells the model, and the release it earned.
 					late: (late) => {
 						const outcome = lateOutcome(call, late, watch, needing.onDeclined);
-						if (outcome?.release) this.#lateApproved.push(outcome.release);
+						if (outcome?.release) this.#late.add(outcome.release);
 						return outcome?.text;
 					},
 				},
@@ -385,7 +389,7 @@ export class ConfirmationGate {
 	/** What a call needs when a rule holds it; undefined when none does. */
 	#needing(tool: string, input: Record<string, unknown>): Needing | undefined {
 		const action = this.#holds(tool, input, this.#context);
-		if (!action) return undefined;
+		if (!action) return this.#ranUnheld(tool, input);
 		const classes = this.#holds.classesOf?.(tool, input, this.#context);
 		return this.#unlessApproved(tool, input, { action, classes });
 	}
@@ -407,10 +411,18 @@ export class ConfirmationGate {
 		if (!turn || !this.#holds.inTurn) return this.#needing(tool, input);
 		return this.#describer.describe(tool, input, turn, (judged) => {
 			if (judged === STOPPED) return STOPPED;
-			return judged ? this.#unlessApproved(tool, input, judged) : undefined;
+			return judged
+				? this.#unlessApproved(tool, input, judged)
+				: this.#ranUnheld(tool, input);
 		});
 	}
 
+	/** A call no hold stops runs as the one a late approval was for, so that approval is spent. */
+	#ranUnheld(tool: string, input: Record<string, unknown>): undefined {
+		this.#late.drop({ tool, input: canonicalJson(input) });
+		return undefined;
+	}
+
 	/**
 	 * The call for a description, unless an approval releases it, which that approval then spends
 	 * and whose approver the release names.
@@ -420,21 +432,13 @@ export class ConfirmationGate {
 		input: Record<string, unknown>,
 		judged: Judgment,
 	): Needing {
-		const minTier = this.#holds.approvalTier?.(tool, input, this.#context);
-		const call: HeldCall = {
-			tool,
-			input: canonicalJson(input),
-			action: judged.action,
-			...(minTier ? { minTier } : {}),
-			...(judged.approvers ? { approverIds: [...judged.approvers] } : {}),
-			...(judged.classes && judged.classes.length > 0
-				? { holdClasses: [...judged.classes] }
-				: {}),
-		};
+		const tier = this.#holds.approvalTier?.(tool, input, this.#context);
+		const call = heldCall(tool, input, judged, tier);
 		// A plugin that already withdrew the call lets no approval of it release it.
 		const spent = judged.supersede?.aborted
 			? undefined
-			: spendApproval([this.#approved, this.#lateApproved], call);
+			: (spendApproval([this.#approved], call) ??
+				this.#late.spend(call, this.#lateSpender));
 		if (spent) {
 			this.#withdrawals.endCall(spent.call);
 			return { released: spent };

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

@@ -1,4 +1,5 @@
 import type { ToolTurn } from "../../define.ts";
+import type { HeldCall } from "../../domain/conversation.ts";
 import {
 	type HoldCheck,
 	type HoldContext,
@@ -7,6 +8,7 @@ import {
 } from "../../holds.ts";
 import { messages } from "../../i18n/index.ts";
 import type { ApprovalDetails } from "../../interactions/prompts.ts";
+import { canonicalJson } from "./held-calls.ts";
 
 /** The turn a hold that looks things up sees; see `HoldRule.describeInTurn`. */
 export interface HoldTurn {
@@ -195,3 +197,22 @@ function withoutApprovers(
 		found === STOPPED || found === undefined ? found : described(found, tool);
 	return isPromise(answer) ? answer.then(wrap) : wrap(answer);
 }
+
+/** The held call for a tool call and the description a hold gave it. */
+export function heldCall(
+	tool: string,
+	input: Record<string, unknown>,
+	judged: Judgment,
+	minTier: HeldCall["minTier"],
+): HeldCall {
+	return {
+		tool,
+		input: canonicalJson(input),
+		action: judged.action,
+		...(minTier ? { minTier } : {}),
+		...(judged.approvers ? { approverIds: [...judged.approvers] } : {}),
+		...(judged.classes && judged.classes.length > 0
+			? { holdClasses: [...judged.classes] }
+			: {}),
+	};
+}