pi-roundtable 0.26.0 → 0.26.2

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

@@ -20,7 +20,7 @@ import {
 	approverOf,
 	askSpeaker,
 	awaitingText,
-	declinedText,
+	declinedRefusal,
 	type GateDecision,
 	type Needing,
 	namesOf,
@@ -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.
@@ -337,8 +341,8 @@ export class ConfirmationGate {
 				wait: {
 					// 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);
-						if (outcome?.release) this.#lateApproved.push(outcome.release);
+						const outcome = lateOutcome(call, late, watch, needing.onDeclined);
+						if (outcome?.release) this.#late.add(outcome.release);
 						return outcome?.text;
 					},
 				},
@@ -372,13 +376,8 @@ export class ConfirmationGate {
 				reason: awaitingText(this.#addressee, call),
 				refused: "pending",
 			};
-		if (answer === "declined") {
-			watch?.end();
-			return {
-				reason: declinedText(this.#addressee, call),
-				refused: "declined",
-			};
-		}
+		if (answer === "declined")
+			return declinedRefusal(this.#addressee, call, watch, needing.onDeclined);
 		if (answer === "cancelled") {
 			watch?.end();
 			return { reason: "The turn was stopped." };
@@ -390,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 });
 	}
@@ -412,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.
@@ -425,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 };
@@ -449,6 +448,7 @@ export class ConfirmationGate {
 			...(judged.copy ? { copy: judged.copy } : {}),
 			...(judged.supersede ? { supersede: judged.supersede } : {}),
 			...(judged.speakerOnly ? { speakerOnly: judged.speakerOnly } : {}),
+			...(judged.onDeclined ? { onDeclined: judged.onDeclined } : {}),
 		};
 	}
 

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

@@ -37,6 +37,8 @@ export type Needing =
 			supersede?: AbortSignal;
 			/** The card is the speaker's alone; see `HoldDescription`. */
 			speakerOnly?: true;
+			/** Called when the call's card is declined; see `HoldDescription`. */
+			onDeclined?: () => void | Promise<void>;
 	  }
 	| { released: Release };
 
@@ -76,6 +78,36 @@ export function declinedText(addressee: OwnerIdentity, call: HeldCall): string {
 	return `${o.name} declined this on its approval card: it would ${call.action}. Do not retry it; go on without it, or ask ${o.him} what ${o.he} wants instead.`;
 }
 
+/**
+ * Tells the plugin that held a call that its card was declined (`HoldDescription.onDeclined`).
+ * The call is refused whatever the plugin does, so what its hook throws or rejects with is ignored.
+ */
+export function notifyDeclined(
+	onDeclined: (() => void | Promise<void>) | undefined,
+): void {
+	if (!onDeclined) return;
+	try {
+		Promise.resolve(onDeclined()).catch(() => undefined);
+	} catch {
+		// A hook that throws changes nothing: the call is refused already.
+	}
+}
+
+/**
+ * The refusal of a call declined on its card the turn was still waiting on: ends the plugin's
+ * watch of the call, tells it through `onDeclined`, and gives the turn the text and the reason.
+ */
+export function declinedRefusal(
+	addressee: OwnerIdentity,
+	call: HeldCall,
+	watch: { end(): void } | undefined,
+	onDeclined: (() => void | Promise<void>) | undefined,
+): { reason: string; refused: "declined" } {
+	watch?.end();
+	notifyDeclined(onDeclined);
+	return { reason: declinedText(addressee, call), refused: "declined" };
+}
+
 /** The text for a held call that the speaker's own message confirms. */
 export function askSpeaker(addressee: OwnerIdentity, call: HeldCall): string {
 	const o = ownerWords(addressee);

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 {
@@ -36,6 +38,8 @@ export interface Judgment {
 	speakerOnly?: true;
 	/** The hold classes of the call; see `HoldRule.holdClasses`. Absent when the holds gave none. */
 	classes?: readonly string[] | undefined;
+	/** Called when the call's card is declined; see `HoldDescription`. */
+	onDeclined?: () => void | Promise<void>;
 }
 
 export type Judged = Judgment | undefined | typeof STOPPED;
@@ -59,11 +63,14 @@ function isSignal(value: unknown): value is AbortSignal {
 export function described(
 	answer: HoldDescription,
 	tool: string,
-): Pick<Judgment, "action" | "copy" | "supersede" | "speakerOnly" | "classes"> {
+): Pick<
+	Judgment,
+	"action" | "copy" | "supersede" | "speakerOnly" | "classes" | "onDeclined"
+> {
 	if (typeof answer === "string") return { action: answer };
 	if (typeof answer !== "object" || answer === null)
 		return { action: messages().holdGeneric(tool) };
-	const { text, copy, supersede, approval, classes } = answer;
+	const { text, copy, supersede, approval, classes, onDeclined } = 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 !== "")
@@ -72,6 +79,7 @@ export function described(
 		...(isSignal(supersede) ? { supersede } : {}),
 		...(approval === "speaker" ? { speakerOnly: true as const } : {}),
 		...(named.length > 0 ? { classes: named } : {}),
+		...(typeof onDeclined === "function" ? { onDeclined } : {}),
 	};
 	if (
 		!copy ||
@@ -142,6 +150,7 @@ export function joinApprovers(
 			supersede,
 			speakerOnly,
 			classes,
+			onDeclined,
 		} = described(action, tool);
 		const joined = (approvers: readonly string[] | undefined): Judgment => ({
 			action: text,
@@ -149,6 +158,7 @@ export function joinApprovers(
 			...(supersede ? { supersede } : {}),
 			...(speakerOnly ? { speakerOnly } : {}),
 			...(classes ? { classes } : {}),
+			...(onDeclined ? { onDeclined } : {}),
 			...(approvers ? { approvers } : {}),
 		});
 		const controller = new AbortController();
@@ -187,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] }
+			: {}),
+	};
+}

package/src/core/runtime/extensions/late-answer.ts

@@ -1,6 +1,6 @@
 import type { HeldCall } from "../../domain/conversation.ts";
 import type { LateAnswer } from "../../interactions/prompts.ts";
-import type { Release } from "./gate-refusals.ts";
+import { notifyDeclined, type Release } from "./gate-refusals.ts";
 import { namedApprover } from "./held-calls.ts";
 import type { Watch } from "./withdrawals.ts";
 
@@ -8,12 +8,14 @@ import type { Watch } from "./withdrawals.ts";
  * What a card answered after its turn stopped waiting comes to: the text of the turn that tells
  * the model, and, for an approval that stands, the release that lets the identical call run once
  * in whichever turn makes it next. Undefined when the answer changes nothing: a question's, a
- * card its plugin withdrew, or an approval by someone the call does not name.
+ * card its plugin withdrew, or an approval by someone the call does not name. A card declined
+ * tells the plugin through `onDeclined`.
  */
 export function lateOutcome(
 	call: HeldCall,
 	late: LateAnswer,
 	watch: Watch | undefined,
+	onDeclined?: () => void | Promise<void>,
 ): { text: string; release?: Release } | undefined {
 	// A card the plugin withdrew answers nothing, whatever a surface that kept it open reports.
 	if (watch?.withdrawn || late.kind !== "approval") return undefined;
@@ -21,6 +23,7 @@ export function lateOutcome(
 	if (late.approved && !namedApprover(call, late.approvedBy)) return undefined;
 	if (!late.approved) {
 		watch?.end();
+		notifyDeclined(onDeclined);
 		return {
 			text: `(${late.by} declined on its card the action you were waiting on: it would ${call.action}. It did not run; do not make the call again. Go on without it, or ask what ${late.by} wants instead.)`,
 		};

package/src/core/runtime/extensions/late-releases.ts

@@ -0,0 +1,76 @@
+import type { HeldCall } from "../../domain/conversation.ts";
+import { SYSTEM_PRINCIPAL } from "../../identity/principal-store.ts";
+import type { Release, SpeakerRef } from "./gate-refusals.ts";
+import { sameCall } from "./held-calls.ts";
+
+/**
+ * How long a late approval's release waits for the call it was granted for. The turn that
+ * answers a late card re-makes the call at once, so an hour covers a slow model or a queue of
+ * turns and no more; a release nobody spent by then belongs to a call that is long gone.
+ */
+export const LATE_RELEASE_TTL_MS = 3_600_000;
+
+/**
+ * The releases that cards answered after their turn stopped waiting earned. A release lets the
+ * identical call run once, only while it is fresh and only in a turn spoken by the person who gave it
+ * (or by an owner), only in a turn a person's message started, and it is dropped when the identical call
+ * runs without a hold, since that run is the call the person approved.
+ */
+export class LateReleases {
+	#list: { release: Release; at: number }[] = [];
+
+	add(release: Release, now = Date.now()): void {
+		this.#prune(now);
+		this.#list.push({ release, at: now });
+	}
+
+	/**
+	 * Takes the release of `call` that `speaker` may spend out of the list; undefined when none
+	 * is fresh and theirs. A release whose approver is unknown is anyone's.
+	 */
+	spend(
+		call: Pick<HeldCall, "tool" | "input">,
+		speaker: SpeakerRef | undefined,
+		now = Date.now(),
+	): Release | undefined {
+		this.#prune(now);
+		const at = this.#list.findIndex(
+			({ release }) =>
+				sameCall(release.call, call) && maySpend(release, speaker),
+		);
+		if (at === -1) return undefined;
+		const [spent] = this.#list.splice(at, 1);
+		return spent?.release;
+	}
+
+	/** Drops every release of `call`, whoever gave it. */
+	drop(call: Pick<HeldCall, "tool" | "input">): void {
+		this.#list = this.#list.filter(
+			({ release }) => !sameCall(release.call, call),
+		);
+	}
+
+	/** Whether a fresh release of `call` waits, for whoever may spend it. */
+	has(call: Pick<HeldCall, "tool" | "input">, now = Date.now()): boolean {
+		this.#prune(now);
+		return this.#list.some(({ release }) => sameCall(release.call, call));
+	}
+
+	#prune(now: number): void {
+		this.#list = this.#list.filter(({ at }) => now - at <= LATE_RELEASE_TTL_MS);
+	}
+}
+
+/**
+ * Whether `speaker` may spend `release`: they gave it, or are an owner; any speaker, when its
+ * giver is unknown. The gate hands only the speaker of a turn a person's
+ * message started; every other turn (schedule, agent message, report, error report) has none and
+ * spends nothing, so a card is shown again there. The system principal never spends one.
+ */
+function maySpend(release: Release, speaker: SpeakerRef | undefined): boolean {
+	if (!speaker || speaker.principalId === SYSTEM_PRINCIPAL) return false;
+	if (!release.by) return true;
+	return (
+		speaker.tier === "owner" || speaker.principalId === release.by.principalId
+	);
+}

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

@@ -21,10 +21,9 @@ import type { TurnRequest } from "../domain/ports.ts";
 import { HostStoppingError } from "../errors.ts";
 import { assistantName } from "../i18n/index.ts";
 import { promptScopeOf } from "../interactions/prompts.ts";
-import { MEMORY_TOOLS } from "../modules/memory/owner-memory.ts";
 import { withoutReplyFiles } from "../reply-files.ts";
 import type { TransientTask } from "../sessions.ts";
-import { type ToolTiers, toolsForTier, toolTiers } from "../tool-tiers.ts";
+import { type ToolTiers, toolTiers } from "../tool-tiers.ts";
 import { AbortGuard } from "./abort-guard.ts";
 import { bridgeTurnRefusal, chosenAgentModel } from "./bridge-guard.ts";
 import { ConversationSessions } from "./conversation-sessions.ts";
@@ -52,6 +51,7 @@ import { transcriptOf, turnAnswer, unspokenTurn } from "./turn-answer.ts";
 import type { TurnBudget } from "./turn-budget.ts";
 import { promptFailed, turnLimits } from "./turn-limits.ts";
 import { progressReporter } from "./turn-progress.ts";
+import { turnTools } from "./turn-tools.ts";
 import { wrapUpTurn } from "./turn-wrapup.ts";
 import { workerReport } from "./worker-task.ts";
 
@@ -62,8 +62,6 @@ export {
 	sessionExtensions,
 } from "./runtime-types.ts";
 
-const MEMORY = new Set<string>(MEMORY_TOOLS);
-
 /** AgentRuntime over the Pi SDK: one persistent session per channel, each with its own loader. */
 const STOPPED = "stopped by the owner";
 
@@ -183,18 +181,15 @@ export class PiAgentRuntime implements AgentRuntime {
 			request.agent !== undefined &&
 			this.#options.agents?.memory === "owners" &&
 			tier !== "owner";
-		const wanted = toolsForTier(
-			[
-				...new Set([
-					...this.#factory.toolsFor(request.selection),
-					...(request.confirmed && pending
-						? pending.calls.map((call) => call.tool)
-						: []),
-				]),
-			],
-			tier,
+		const wanted = turnTools(
+			{
+				selected: this.#factory.toolsFor(request.selection),
+				held: request.confirmed && pending ? pending.calls : [],
+				tier,
+				withheld,
+			},
 			this.#tiers,
-		).filter((name) => !withheld || !MEMORY.has(name));
+		);
 		const markPrivateMemory = recordMemoryTurn(
 			session.sessionManager,
 			request.speaker.principalId,
@@ -221,6 +216,7 @@ export class PiAgentRuntime implements AgentRuntime {
 			request.speaker,
 			conversation.visibility === "private",
 			turnYolo(this.#options, request),
+			request.byMessage === true,
 		);
 		if (request.confirmed && pending && pending.calls.length > 0) {
 			logger.info(
@@ -231,7 +227,6 @@ export class PiAgentRuntime implements AgentRuntime {
 				"confirmed actions released",
 			);
 		}
-
 		// Collected as they end: a compaction during the turn shortens session.messages.
 		const turnMessages: TurnMessage[] = [];
 		const toolCalls: string[] = [];
@@ -240,8 +235,12 @@ export class PiAgentRuntime implements AgentRuntime {
 		// The caller's live view: the text as it streams and each tool, never the thinking.
 		const slot = this.#sessions.slot(key);
 		// Its time limit, not counting time waiting on the owner's cards, follows what it does to say why it fired.
-		const limits = turnLimits(this.#options, slot, request.channel, () =>
-			guard.abort(),
+		const limits = turnLimits(
+			this.#options,
+			slot,
+			request.channel,
+			() => guard.abort(),
+			request.timeLimitMs,
 		);
 		const progress = request.progress
 			? progressReporter(request.progress, {
@@ -333,7 +332,10 @@ export class PiAgentRuntime implements AgentRuntime {
 
 		if (running.stopped)
 			return { ok: false, error: new AgentRunError(STOPPED), stopped: true };
-		return limits.failure() ?? turnAnswer(turnMessages, running.steered);
+		return (
+			limits.failure() ??
+			turnAnswer(turnMessages, running.steered, request.unattended !== true)
+		);
 	}
 
 	async steer(

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

@@ -77,11 +77,14 @@ export function thinkingOf(messages: readonly Message[]): string {
 
 /**
  * A finished turn's result from the messages it added. A steered run may have answered before
- * the steer arrived, so every final answer of it is kept.
+ * the steer arrived, so every final answer of it is kept. A turn nobody waits on (`attended`
+ * false: a schedule's, an agent's message) may end with nothing to say, such as "send nothing if
+ * there is no progress"; that is an empty answer, not a failure. For an attended turn it is one.
  */
 export function turnAnswer(
 	messages: readonly Message[],
 	steered: boolean,
+	attended: boolean,
 ): TurnResult {
 	const last = lastAssistant(messages);
 	if (!last.ok) return { ok: false, error: new AgentRunError(last.error) };
@@ -97,6 +100,7 @@ export function turnAnswer(
 					.join("\n\n")
 			: textOf(last.message.content)
 	).trim();
+	if (!text && !hasReplyFiles() && !attended) return { ok: true, text: "" };
 	if (!text && !hasReplyFiles())
 		return {
 			ok: false,

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

@@ -167,6 +167,7 @@ export function runtimeTurnBudget(
 		...seams.activity.now(clock.now()),
 		graceMs,
 		end,
+		...(slot.cards ? {} : { unasked: true as const }),
 	});
 	const stop = (timeout: TurnTimeout) => {
 		logger.warn(

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

@@ -35,7 +35,8 @@ export function timeoutMessage(timeout: TurnTimeout): string {
 /**
  * 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`.
+ * asking or aborting, until the turn has worked `options.autonomy.longRunningMaxMs`. A
+ * `timeLimitMs` replaces the turn's limit and its cap, both held under that same ceiling.
  */
 export function turnLimits(
 	options: Parameters<typeof runtimeTurnBudget>[0] &
@@ -43,15 +44,24 @@ export function turnLimits(
 	slot: Pick<PromptSlot, "waitedMs" | "cards">,
 	channel: ChannelKey,
 	abort: () => void,
+	timeLimitMs?: number,
 ): TurnLimits {
 	const { longRunningMaxMs } = options.autonomy ?? DEFAULT_AUTONOMY;
+	const limited =
+		timeLimitMs === undefined
+			? options
+			: {
+					...options,
+					turnTimeoutMs: Math.min(timeLimitMs, longRunningMaxMs),
+					turnMaxMs: Math.min(timeLimitMs, longRunningMaxMs),
+				};
 	const keepGoing = (workedMs: number) =>
 		workedMs < longRunningMaxMs &&
 		options.modes?.peek(channel).longRunning === true;
 	const activity = activityTracker();
 	let timedOut: TurnTimeout | undefined;
 	const budget = runtimeTurnBudget(
-		options,
+		limited,
 		slot,
 		channel,
 		(timeout) => {

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

@@ -0,0 +1,26 @@
+import type { HeldCall } from "../domain/conversation.ts";
+import { MEMORY_TOOLS } from "../modules/memory/owner-memory.ts";
+import type { Tier } from "../speakers.ts";
+import { type ToolTiers, toolsForTier } from "../tool-tiers.ts";
+
+const MEMORY = new Set<string>(MEMORY_TOOLS);
+
+/**
+ * The tools a turn is given: its selection, and the tools of the held calls an approving turn
+ * releases, limited to the speaker's tier; a speaker kept out of memory gets none of its tools.
+ */
+export function turnTools(
+	turn: {
+		selected: readonly string[];
+		held: readonly Pick<HeldCall, "tool">[];
+		tier: Tier;
+		withheld: boolean;
+	},
+	tiers: ToolTiers,
+): string[] {
+	return toolsForTier(
+		[...new Set([...turn.selected, ...turn.held.map((call) => call.tool)])],
+		turn.tier,
+		tiers,
+	).filter((name) => !turn.withheld || !MEMORY.has(name));
+}

package/src/core/shared/schedule-tools.ts

@@ -13,6 +13,9 @@ export const SCHEDULE_TOOLS = Object.freeze([
 ] as const);
 export type ScheduleToolName = (typeof SCHEDULE_TOOLS)[number];
 
+/** The most minutes a schedule's own time limit may name: the four hours a long-running turn may work. */
+export const MAX_SCHEDULE_TIME_LIMIT_MINUTES = 240;
+
 export function isScheduleTool(value: string): value is ScheduleToolName {
 	return (SCHEDULE_TOOLS as readonly string[]).includes(value);
 }
@@ -62,6 +65,8 @@ const timing = (zone: string) => ({
 	),
 });
 
+const TIME_LIMIT = `How long, in minutes, each run may work before it is stopped (at most ${MAX_SCHEDULE_TIME_LIMIT_MINUTES}); without it a run is stopped after the host's default of 10 minutes. Set it for a task that works longer.`;
+
 export interface ScheduleToolSpec {
 	name: ScheduleToolName;
 	label: string;
@@ -118,6 +123,13 @@ export function scheduleToolSpecs(
 							"The name of a precheck the host runs first, from schedule_list; you are woken only when it finds something.",
 					}),
 				),
+				time_limit_minutes: Type.Optional(
+					Type.Integer({
+						minimum: 1,
+						maximum: MAX_SCHEDULE_TIME_LIMIT_MINUTES,
+						description: TIME_LIMIT,
+					}),
+				),
 				...script(false),
 			}),
 		},
@@ -133,7 +145,7 @@ export function scheduleToolSpecs(
 			name: "schedule_update",
 			label: "Update schedule",
 			description:
-				"Change one of this channel's schedules: its title, its prompt, its timing (timing fields replace the old timing), or its precheck. A run can use this to keep its own prompt current, such as adding what it already reported.",
+				"Change one of this channel's schedules: its title, its prompt, its timing (timing fields replace the old timing), its precheck, or its time limit. A run can use this to keep its own prompt current, such as adding what it already reported.",
 			parameters: Type.Object({
 				id: Type.Integer({ description: "Schedule id." }),
 				title: Type.Optional(Type.String()),
@@ -147,6 +159,18 @@ export function scheduleToolSpecs(
 							"A precheck's name from schedule_list to run first, or null to remove the schedule's precheck.",
 					}),
 				),
+				time_limit_minutes: Type.Optional(
+					Type.Union(
+						[
+							Type.Integer({
+								minimum: 1,
+								maximum: MAX_SCHEDULE_TIME_LIMIT_MINUTES,
+							}),
+							Type.Null(),
+						],
+						{ description: `${TIME_LIMIT} null returns it to the default.` },
+					),
+				),
 				...script(true),
 			}),
 		},