pi-roundtable 0.17.0 → 0.17.1

package/CHANGELOG.md

@@ -5,6 +5,12 @@ The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ## [Unreleased]
 
+## [0.17.1] - 2026-10-16
+
+### Changed
+
+- A message steered into a running turn renews the turn's time budget: the built-in runtime gives the turn its full `turnTimeoutMs` (10 minutes by default) again from the steer, so a turn the owner kept steering is no longer aborted, and its final reply lost, at 10 minutes from its start. The new runtime option `turnMaxMs` caps the work of one turn, steered or not, at three times `turnTimeoutMs` by default (30 minutes); once it is reached the turn takes no more steering, the message waits for the next turn, and the turn is aborted as on its timeout. Time waiting on the owner's cards counts towards neither. A renewal is logged at info (`steer renewed the turn's time budget`, with `channel` and `deadlineMs`, the work time left), and the timeout warning names the limit that fired (`limit: "turn"` or `"turnMax"`). Task workers, coding workers and sandbox guests keep their own timeouts.
+
 ## [0.17.0] - 2026-10-16
 
 ### Added

package/docs/plugins.md

@@ -3395,6 +3395,7 @@ On `SIGTERM` or `SIGINT` the bot takes no new work at once, finishes what runs,
 `shutdown()` returns exit code `0`, or `1` if a listener, service, or pool failed to stop.
 Every call shares the same shutdown.
 Give the service manager a stop timeout longer than the drain limit plus about a minute for the steps after it, such as systemd's `TimeoutStopSec=5min` with the default three-minute drain; a shorter one has the manager kill the process in the middle of the drain.
+The built-in runtime aborts a turn that works 10 minutes (`turnTimeoutMs`), not counting time spent waiting on the owner's cards. Each message steered into the running turn gives it the full 10 minutes again from that moment, up to a cap of 30 minutes of work for the whole turn (`turnMaxMs`, three times `turnTimeoutMs` by default); once the cap is reached the turn takes no more steering, so a message waits for the next turn, and the turn is aborted as on its timeout. The log says `steer renewed the turn's time budget` with `deadlineMs`, the work time left, and the timeout warning names the limit that fired (`limit: "turn"` or `"turnMax"`). Task workers (`task.timeoutMs`), coding workers (`workTimeout`) and sandbox guests (their own `turnTimeoutMs`) keep their own limits, which steering does not renew.
 A turn whose model ignores its abort (a subprocess that does not exit) is given up on too: a turn that outlives its timeout, or is stopped, gets `turnAbortGraceMs` (15 seconds by default) to end, and then its session is disposed of and the turn is reported failed, so it cannot hold the queue.
 `listen()`, called by the command line and a host's own entry point, exits the process with that code.
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "pi-roundtable",
-	"version": "0.17.0",
+	"version": "0.17.1",
 	"description": "A plugin-driven Pi agent server for one owner, reached through Discord or the web",
 	"type": "module",
 	"license": "MIT",

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

@@ -33,7 +33,7 @@ import { loadsMemory } from "./extensions/private-memory.ts";
 import { missingToolsError } from "./extensions/self-compact-guard.ts";
 import { interimPoster } from "./interim-text.ts";
 import { preflightTools } from "./preflight-tools.ts";
-import { PromptSlot, workTimeout } from "./prompt-slot.ts";
+import { PromptSlot } from "./prompt-slot.ts";
 import { carriesMemory, recordMemoryTurn } from "./reader-history.ts";
 import { type RunningTurn, runningTurn } from "./running-turn.ts";
 import type { PiAgentRuntimeOptions, TurnMessage } from "./runtime-types.ts";
@@ -48,6 +48,7 @@ import { promptImages, SteerableRun } from "./steerable-run.ts";
 import { thinkingLevel } from "./thinking-level.ts";
 import { runningCalls } from "./tool-call-scope.ts";
 import { transcriptOf, turnAnswer, unspokenTurn } from "./turn-answer.ts";
+import { runtimeTurnBudget, type TurnBudget } from "./turn-budget.ts";
 import { progressReporter } from "./turn-progress.ts";
 import { wrapUpTurn } from "./turn-wrapup.ts";
 import { workerReport } from "./worker-task.ts";
@@ -75,6 +76,8 @@ export class PiAgentRuntime implements AgentRuntime {
 	readonly #turns = new Map<ChannelKey, RunningTurn>();
 	/** Each conversation's turn in progress, which the owner may steer or stop. */
 	readonly #running = new Map<ChannelKey, SteerableRun>();
+	/** Each running turn's time limit, which a steered message renews. */
+	readonly #budgets = new Map<ChannelKey, TurnBudget>();
 	readonly #memoryTurns = new Map<ChannelKey, () => void>();
 
 	/** Builds the runtime without starting a session; the preflight proves it can run. */
@@ -114,7 +117,7 @@ export class PiAgentRuntime implements AgentRuntime {
 
 	// pi-lens-ignore: high-complexity, high-fan-out, mixed-async-styles — one turn's lifecycle end to end; batch 4 splits it with the channel router
 	async runTurn(request: TurnRequest): Promise<TurnResult> {
-		const { logger, turnTimeoutMs = 10 * 60_000 } = this.#options;
+		const { logger } = this.#options;
 		if (!request.speaker) return unspokenTurn();
 		// A turn that is only asked for now, such as a group's next member, starts nothing.
 		if (this.#options.stopping?.())
@@ -272,17 +275,14 @@ export class PiAgentRuntime implements AgentRuntime {
 				this.#sessions.drop(key, channelSession);
 			},
 		});
-		// Time spent waiting on the owner's cards does not count towards the timeout.
-		const cancelTimeout = workTimeout(turnTimeoutMs, slot, () => {
-			logger.warn(
-				{ channel: request.channel, turnTimeoutMs },
-				"turn timed out; aborting",
-			);
-			guard.abort();
-		});
+		// Time spent waiting on the owner's cards does not count towards the timeout or the cap.
+		const budget = runtimeTurnBudget(this.#options, slot, request.channel, () =>
+			guard.abort(),
+		);
+		this.#budgets.set(key, budget);
 		const running = new SteerableRun(
 			session,
-			() => request.steerable === true && !gate.pending(),
+			() => request.steerable === true && !gate.pending() && !budget.capped(),
 			() => guard.abort(),
 		);
 		this.#running.set(key, running);
@@ -313,9 +313,10 @@ export class PiAgentRuntime implements AgentRuntime {
 			};
 		} finally {
 			this.#running.delete(key);
+			this.#budgets.delete(key);
 			this.#turns.delete(key);
 			this.#memoryTurns.delete(key);
-			cancelTimeout();
+			budget.cancel();
 			guard.release();
 			slot.unbind();
 			unsubscribe();
@@ -358,8 +359,10 @@ export class PiAgentRuntime implements AgentRuntime {
 				withAttachmentsBlock(text, attachments),
 				promptImages(attachments),
 			);
-			if (steered)
+			if (steered) {
 				this.#options.logger.info({ channel }, "message steered into the turn");
+				this.#budgets.get(channel)?.renew();
+			}
 			return steered;
 		} catch (error) {
 			this.#options.logger.warn({ channel, err: error }, "steer refused");

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

@@ -88,8 +88,18 @@ export interface PiAgentRuntimeOptions {
 	formatting?: (channel: ChannelKey) => string | undefined;
 	/** The lowest tier that may use each tool; the default names the core's tools and leaves the rest to the owner. */
 	toolTiers?: ToolTiers;
-	/** A run that takes longer, not counting time spent waiting on the owner's cards, is aborted and reported as failed. */
+	/**
+	 * A run that works longer, not counting time spent waiting on the owner's cards, is aborted and
+	 * reported as failed; default 10 minutes. Each message steered into the turn gives it this
+	 * budget again from that moment, up to `turnMaxMs`.
+	 */
 	turnTimeoutMs?: number;
+	/**
+	 * The most one turn may work in all, however often it is steered, not counting time spent
+	 * waiting on the owner's cards; default three times `turnTimeoutMs`. Once it is reached the turn
+	 * takes no more steering (the message waits for the next turn) and is aborted as on its timeout.
+	 */
+	turnMaxMs?: number;
 	/**
 	 * 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

@@ -0,0 +1,112 @@
+import type { ChannelKey } from "../sessions.ts";
+import type { PromptSlot } from "./prompt-slot.ts";
+import type { PiAgentRuntimeOptions } from "./runtime-types.ts";
+
+/** Which limit ended a turn: its budget since the start or the last steer, or its cap. */
+export type TurnLimit = "turn" | "turnMax";
+
+/** A turn's time limit, which a steered message renews up to a cap on the whole turn. */
+export interface TurnBudget {
+	/**
+	 * Gives the turn its full budget again from now, up to the cap; the work time left, in ms,
+	 * or undefined when the cap is reached and the turn takes no more steering.
+	 */
+	renew(): number | undefined;
+	/** Whether the turn has worked up to its cap. */
+	capped(): boolean;
+	cancel(): void;
+}
+
+/** The clock a turn budget reads; the real one by default, a fake one in tests. */
+export interface BudgetClock {
+	now(): number;
+	schedule(run: () => void, ms: number): () => void;
+}
+
+const REAL_CLOCK: BudgetClock = {
+	now: () => Date.now(),
+	schedule: (run, ms) => {
+		const timer = setTimeout(run, ms);
+		return () => clearTimeout(timer);
+	},
+};
+
+/**
+ * Calls `expire` once the turn has worked `ms` since it started or since its last renewal, or
+ * `maxMs` in all, whichever comes first; time the slot spent waiting on the owner's cards counts
+ * towards neither. `expire` is told which limit fired.
+ */
+export function turnBudget(
+	ms: number,
+	maxMs: number,
+	slot: Pick<PromptSlot, "waitedMs">,
+	expire: (limit: TurnLimit) => void,
+	clock: BudgetClock = REAL_CLOCK,
+): TurnBudget {
+	const started = clock.now();
+	const worked = () => {
+		const now = clock.now();
+		return now - started - slot.waitedMs(now);
+	};
+	let deadline = Math.min(ms, maxMs);
+	let cancelTimer: (() => void) | undefined;
+	let expired = false;
+	const arm = (delay: number) => {
+		cancelTimer = clock.schedule(() => {
+			const left = deadline - worked();
+			if (left > 0) return arm(left);
+			expired = true;
+			expire(deadline >= maxMs ? "turnMax" : "turn");
+		}, delay);
+	};
+	arm(deadline);
+	return {
+		renew() {
+			const now = worked();
+			if (expired || now >= maxMs) return undefined;
+			deadline = Math.min(now + ms, maxMs);
+			cancelTimer?.();
+			arm(deadline - now);
+			return deadline - now;
+		},
+		capped: () => expired || worked() >= maxMs,
+		cancel: () => cancelTimer?.(),
+	};
+}
+
+/**
+ * The time limit of one turn of the built-in runtime, from its options: `turnTimeoutMs` (default
+ * 10 minutes) renewed by each steer up to `turnMaxMs` (default three times that). It logs each
+ * renewal and, when a limit fires, which one before it calls `abort`.
+ */
+export function runtimeTurnBudget(
+	options: Pick<
+		PiAgentRuntimeOptions,
+		"turnTimeoutMs" | "turnMaxMs" | "logger"
+	>,
+	slot: Pick<PromptSlot, "waitedMs">,
+	channel: ChannelKey,
+	abort: () => void,
+): TurnBudget {
+	const { logger, turnTimeoutMs = 10 * 60_000 } = options;
+	const turnMaxMs = options.turnMaxMs ?? 3 * turnTimeoutMs;
+	const budget = turnBudget(turnTimeoutMs, turnMaxMs, slot, (limit) => {
+		logger.warn(
+			{ channel, limit, turnTimeoutMs, turnMaxMs },
+			"turn timed out; aborting",
+		);
+		abort();
+	});
+	return {
+		...budget,
+		renew() {
+			const deadlineMs = budget.renew();
+			if (deadlineMs !== undefined)
+				logger.info(
+					{ channel, deadlineMs },
+					"steer renewed the turn's time budget",
+				);
+			return deadlineMs;
+		},
+	};
+}