pi-roundtable 0.9.0 → 0.9.2

package/src/core/routing/channel-router.ts

@@ -12,7 +12,8 @@ import {
 } from "../contract/channels.ts";
 import { parseChannelKey, type SurfacePort } from "../contract/surface.ts";
 import { IdentityError } from "../domain/errors.ts";
-import { PluginError } from "../errors.ts";
+import { HostStoppingError, PluginError } from "../errors.ts";
+import { messages } from "../i18n/index.ts";
 import type { ActorFacts } from "../identity/actor-facts.ts";
 import type { Contact, ContactAssessor } from "../identity/contact.ts";
 import {
@@ -37,8 +38,11 @@ export interface ChannelRouterOptions {
 	contacts?: ContactAssessor;
 	/** Whom a background turn runs as; without it, only the host's own turns run. */
 	principals?: Pick<IdentityService, "speakerFor">;
-	/** The surfaces, so a conversation started over is marked in a channel that shows one; without it, none is. */
-	surfaces?: Pick<SurfacePort, "of">;
+	/**
+	 * The surfaces, so a conversation started over is marked in a channel that shows one, and a
+	 * message that arrives while the host shuts down is told so; without it, neither is.
+	 */
+	surfaces?: Pick<SurfacePort, "of"> & Partial<Pick<SurfacePort, "sendReply">>;
 	/** How long a bare forward waits for the text sent with it; FORWARD_JOIN_MS by default. */
 	forwardJoinMs?: number;
 }
@@ -56,6 +60,12 @@ export function orderClaims(
 	return claims.toSorted((a, b) => b.priority - a.priority);
 }
 
+/** The outcome of a background turn the host did not start because it is shutting down. */
+const stopping = (): ScheduledOutcome => ({
+	status: "skipped",
+	reason: new HostStoppingError().message,
+});
+
 /**
  * Routes every conversation operation to the claim that owns its channel, each inside the
  * channel's queue: messages after joining a bare forward to its text, background turns,
@@ -69,6 +79,8 @@ export class ChannelRouter implements ConversationPort {
 	readonly #admitting = new Map<ChannelKey, Promise<unknown>>();
 	/** The surfaces already warned that their messages carry no actor. */
 	readonly #warned = new Set<string>();
+	/** The channels already told that the host is restarting, so a burst of messages gets one notice. */
+	readonly #told = new Set<ChannelKey>();
 
 	constructor(options: ChannelRouterOptions) {
 		this.#options = options;
@@ -100,7 +112,13 @@ export class ChannelRouter implements ConversationPort {
 		if (!claim) return;
 		const started = await this.#inOrder(message.channel, async () => {
 			const admission = await this.#admit(claim, message);
-			return admission && (await this.#start(message, admission));
+			if (!admission) return undefined;
+			// Once the host shuts down only the turns already running finish: this one starts nothing.
+			if (this.#options.queue.closed) {
+				await this.#refuse(message, admission);
+				return undefined;
+			}
+			return this.#start(message, admission);
 		});
 		await started?.done;
 	}
@@ -209,6 +227,33 @@ export class ChannelRouter implements ConversationPort {
 		};
 	}
 
+	/**
+	 * Drops a message the host no longer starts a turn for because it is shutting down, and tells
+	 * its channel once that it restarts; no one is told for a bot's or an integration's message, such
+	 * as a report, since a notice there would only start the next one.
+	 */
+	async #refuse(message: InboundMessage, admission: Admission): Promise<void> {
+		const { logger, surfaces } = this.#options;
+		const { channel } = message;
+		if (admission.kind === "turn") admission.dropped?.();
+		else
+			admission.unanswered({
+				status: "skipped",
+				reason: new HostStoppingError().message,
+			});
+		logger.info({ channel }, "message not run: the host is shutting down");
+		if (message.authorIsBot || message.integration || this.#told.has(channel))
+			return;
+		this.#told.add(channel);
+		try {
+			await surfaces?.sendReply?.(channel, {
+				chunks: [messages().restartingNotice],
+			});
+		} catch (error) {
+			logger.warn({ channel, err: error }, "restart notice not posted");
+		}
+	}
+
 	/**
 	 * Starts what the claim admitted, in the channel's queue, and returns while it runs: a message
 	 * during a turn is first offered to it, then marked as waiting.
@@ -238,12 +283,17 @@ export class ChannelRouter implements ConversationPort {
 				return admission.run();
 			})
 			// pi-lens-ignore: no-unknown-parameters
-			.catch((error: unknown) =>
+			.catch(async (error: unknown) => {
+				// The host began shutting down while this message waited behind a running turn.
+				if (error instanceof HostStoppingError) {
+					if (queued) void busy?.unreact(QUEUED_MARK);
+					return this.#refuse(message, admission);
+				}
 				logger.error(
 					{ channel: message.channel, err: error },
 					admission.failure,
-				),
-			);
+				);
+			});
 		return { done };
 	}
 
@@ -257,6 +307,7 @@ export class ChannelRouter implements ConversationPort {
 	 * handed to another target's claim, and so is one whose author may not run it now.
 	 */
 	async background(turn: BackgroundTurn): Promise<ScheduledOutcome> {
+		if (this.#options.queue.closed) return stopping();
 		if (!this.#options.targets(turn.target))
 			return {
 				status: "skipped",
@@ -277,6 +328,7 @@ export class ChannelRouter implements ConversationPort {
 				return claim.background({ ...turn, speaker: runs.speaker });
 			});
 		} catch (error) {
+			if (error instanceof HostStoppingError) return stopping();
 			return { status: "failed", error: String(error) };
 		}
 	}

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

@@ -8,7 +8,7 @@ import type { TurnAttachments } from "../domain/attachment.ts";
 import type { TurnResult } from "../domain/conversation.ts";
 import type { TurnConversation } from "../domain/ports.ts";
 import type { TurnProgress } from "../domain/progress.ts";
-import { PluginError } from "../errors.ts";
+import { HostStoppingError, PluginError } from "../errors.ts";
 import { messages } from "../i18n/index.ts";
 import { SYSTEM_PRINCIPAL } from "../identity/principal-store.ts";
 import type { Logger } from "../log.ts";
@@ -61,7 +61,8 @@ export interface ConversationTurns {
 	 * task. It shows typing and the stop control on the channel's surface, emits `turnStarted` and
 	 * `turnEnded` with the turn's `kind`, settles a runtime that throws into a failed result, and
 	 * posts the reply, or a failure or stopped notice, through the surface unless `reply` is given.
-	 * It rejects during setup (NotLinkedError), when the host has no runtime to run the turn on,
+	 * It rejects during setup (NotLinkedError), once the host is shutting down (HostStoppingError),
+	 * when the host has no runtime to run the turn on,
 	 * when the conversation cannot be recorded in the host's registry (a database error, or a
 	 * `private` conversation without a speaker), and when the conversation is recorded private to a
 	 * principal other than the speaker's, unless the speaker is the host's own (`SYSTEM_PRINCIPAL`).
@@ -75,6 +76,8 @@ export interface ConversationTurns {
 export interface ConversationTurnsOptions {
 	/** Throws NotLinkedError until every plugin is set up and linked. */
 	linked: () => void;
+	/** Whether the host is shutting down, so no turn starts; undefined or false while it serves. */
+	stopping?: () => boolean;
 	/** The runtime that runs the turn; throws PluginError when the host has none yet. */
 	runtime: () => AgentRuntime;
 	/** Where each turn records its conversation; absent, or undefined, records none. */
@@ -143,6 +146,8 @@ export function conversationTurns(
 		async run(input) {
 			const { channel, kind, speaker } = input;
 			options.linked();
+			// Refused before anything is shown or recorded, like a turn the host cannot run.
+			if (options.stopping?.()) throw new HostStoppingError();
 			// A host without a runtime is a setup mistake, so it is refused before anything is shown.
 			const runtime = options.runtime();
 			// A conversation that cannot be recorded runs no turn: who it belongs to would be lost.

package/src/core/runtime/abort-guard.ts

@@ -0,0 +1,58 @@
+import type { AgentSession } from "@earendil-works/pi-coding-agent";
+import { AgentRunError } from "../domain/errors.ts";
+
+/** How long a run told to abort gets to end before its session is disposed of; default for the guard. */
+const ABORT_GRACE_MS = 15_000;
+
+/**
+ * Aborts a Pi session's run and does not trust the abort to work. A model behind a subprocess that
+ * ignores the abort would leave the run, and the queue behind it, waiting for ever, so a run still
+ * going once the grace is over has its session disposed of, which drops its model connection, and
+ * `gaveUp` rejects so the caller can end the turn as failed.
+ */
+export class AbortGuard {
+	/** Rejects when the abort did not end the run in time; never resolves. */
+	readonly gaveUp: Promise<never>;
+	readonly #session: Pick<AgentSession, "abort" | "dispose">;
+	readonly #graceMs: number;
+	readonly #onGiveUp: () => void;
+	#reject: (error: Error) => void = () => undefined;
+	#timer: ReturnType<typeof setTimeout> | undefined;
+
+	constructor(
+		session: Pick<AgentSession, "abort" | "dispose">,
+		options: { graceMs?: number; onGiveUp?: () => void } = {},
+	) {
+		this.#session = session;
+		this.#graceMs = options.graceMs ?? ABORT_GRACE_MS;
+		this.#onGiveUp = options.onGiveUp ?? (() => undefined);
+		this.gaveUp = new Promise<never>((_resolve, reject) => {
+			this.#reject = reject;
+		});
+		// Nobody waits on it unless the abort fails.
+		this.gaveUp.catch(() => undefined);
+	}
+
+	/** Aborts the run, and starts the grace the first time. */
+	abort(): void {
+		void this.#session.abort();
+		this.#timer ??= setTimeout(() => {
+			this.#onGiveUp();
+			try {
+				this.#session.dispose();
+			} catch {
+				// A session that cannot be disposed of is dropped all the same.
+			}
+			this.#reject(
+				new AgentRunError(
+					"the run did not stop after it was aborted, so its session was disposed of",
+				),
+			);
+		}, this.#graceMs);
+	}
+
+	/** The run ended: no session is disposed of any more. */
+	release(): void {
+		clearTimeout(this.#timer);
+	}
+}

package/src/core/runtime/conversation-sessions.ts

@@ -262,6 +262,21 @@ export class ConversationSessions {
 		);
 	}
 
+	/**
+	 * Forgets a session that was disposed of while its turn still ran, so the conversation's next
+	 * turn opens a new one from its files; a newer session of the conversation stays.
+	 */
+	drop(key: ChannelKey, disposed: ChannelSession): void {
+		const open = this.#sessions.get(key);
+		if (!open) return;
+		void open
+			.then((current) => {
+				if (current === disposed && this.#sessions.get(key) === open)
+					this.#sessions.delete(key);
+			})
+			.catch(() => undefined);
+	}
+
 	/** Drops the open session and everything held for the conversation, leaving its files. */
 	// pi-lens-ignore: mixed-async-styles — disposal failures of a dropped session are swallowed in a chain on purpose
 	async forget(channel: ChannelKey): Promise<void> {

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

@@ -1,6 +1,5 @@
 import { rmSync } from "node:fs";
 import {
-	type AgentSession,
 	type ModelRuntime,
 	SessionManager,
 } from "@earendil-works/pi-coding-agent";
@@ -16,20 +15,16 @@ import type {
 } from "../domain/conversation.ts";
 import { AgentRunError } from "../domain/errors.ts";
 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 { AUTO_THINKING, type ThinkingLevel } from "../models.ts";
 import { MEMORY_TOOLS } from "../modules/memory/owner-memory.ts";
 import { withoutReplyFiles } from "../reply-files.ts";
 import type { TransientTask } from "../sessions.ts";
 import type { Speaker, Tier } from "../speakers.ts";
 import { type ToolTiers, toolsForTier, toolTiers } from "../tool-tiers.ts";
-import {
-	type AgentModelSettings,
-	bridgeTurnRefusal,
-	chosenAgentModel,
-	useChosenAgentModel,
-} from "./bridge-guard.ts";
+import { AbortGuard } from "./abort-guard.ts";
+import { bridgeTurnRefusal, chosenAgentModel } from "./bridge-guard.ts";
 import { ConversationSessions } from "./conversation-sessions.ts";
 import { confirmedTurnText } from "./extensions/confirmation-gate.ts";
 import { loadsMemory } from "./extensions/private-memory.ts";
@@ -47,14 +42,11 @@ import {
 } from "./session-conversation.ts";
 import { SessionFactory } from "./session-factory.ts";
 import { promptImages, SteerableRun } from "./steerable-run.ts";
+import { thinkingLevel } from "./thinking-level.ts";
 import { runningCalls } from "./tool-call-scope.ts";
-import {
-	lastReply,
-	transcriptOf,
-	turnAnswer,
-	unspokenTurn,
-} from "./turn-answer.ts";
+import { transcriptOf, turnAnswer, unspokenTurn } from "./turn-answer.ts";
 import { progressReporter } from "./turn-progress.ts";
+import { wrapUpTurn } from "./turn-wrapup.ts";
 import { workerReport } from "./worker-task.ts";
 
 export {
@@ -118,6 +110,12 @@ export class PiAgentRuntime implements AgentRuntime {
 	async runTurn(request: TurnRequest): Promise<TurnResult> {
 		const { logger, turnTimeoutMs = 10 * 60_000 } = 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?.())
+			return {
+				ok: false,
+				error: new AgentRunError(new HostStoppingError().message),
+			};
 		const key = request.agent?.session ?? request.channel;
 		// Resolve current scope; refuse a foreign private speaker before touching its session.
 		const conversation = await this.#sessions.conversation(key, request);
@@ -147,7 +145,17 @@ export class PiAgentRuntime implements AgentRuntime {
 				: undefined;
 		if (bridgeRefused)
 			return { ok: false, error: new AgentRunError(bridgeRefused) };
-		const level = await this.#thinkingLevel(key, session, request, agentModel);
+		const level = await thinkingLevel(
+			{
+				modelRuntime: this.#modelRuntime,
+				effort: this.#options.effort,
+				judged: this.#sessions.judged,
+			},
+			key,
+			session,
+			request,
+			agentModel,
+		);
 		if (session.thinkingLevel !== level) session.setThinkingLevel(level);
 		const gate = await this.#sessions.gate(key, request.agent !== undefined);
 		const pending = gate.pending();
@@ -240,17 +248,29 @@ export class PiAgentRuntime implements AgentRuntime {
 			request.agent?.name ?? assistantName(),
 			interim ? () => interim.flush() : undefined,
 		);
+		// A model that ignores the abort must not hold the turn: its session is disposed of instead.
+		const guard = new AbortGuard(session, {
+			graceMs: this.#options.turnAbortGraceMs,
+			onGiveUp: () => {
+				logger.error(
+					{ channel: request.channel },
+					"turn did not stop after its abort; disposing of its session",
+				);
+				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",
 			);
-			void session.abort();
+			guard.abort();
 		});
 		const running = new SteerableRun(
 			session,
 			() => request.steerable === true && !gate.pending(),
+			() => guard.abort(),
 		);
 		this.#running.set(key, running);
 
@@ -260,7 +280,7 @@ export class PiAgentRuntime implements AgentRuntime {
 				request.confirmed && pending
 					? confirmedTurnText(pending, request.text, who)
 					: request.text;
-			await running.run(() =>
+			const prompted = running.run(() =>
 				session.prompt(
 					withAttachmentsBlock(text, attachments),
 					attachments.images.length > 0
@@ -268,6 +288,9 @@ export class PiAgentRuntime implements AgentRuntime {
 						: undefined,
 				),
 			);
+			// A run abandoned by the guard may still reject later; nobody waits for it then.
+			prompted.catch(() => undefined);
+			await Promise.race([prompted, guard.gaveUp]);
 		} catch (error) {
 			if (running.stopped)
 				return { ok: false, error: new AgentRunError(STOPPED), stopped: true };
@@ -280,42 +303,20 @@ export class PiAgentRuntime implements AgentRuntime {
 			this.#turns.delete(key);
 			this.#memoryTurns.delete(key);
 			cancelTimeout();
+			guard.release();
 			slot.unbind();
 			unsubscribe();
 			progress?.close();
 			await interim?.flush();
-			gate.endTurn();
-			const usage = session.getContextUsage();
-			if (usage)
-				this.#sessions.usage.set(key, {
-					tokens: usage.tokens,
-					contextWindow: usage.contextWindow,
-				});
-			const held = gate.pending();
-			await this.#options.confirmations
-				.save(key, held)
-				// pi-lens-ignore: no-unknown-parameters — a rejection reason is unknown; it only reaches the logger
-				.catch((error: unknown) =>
-					logger.error({ channel: key, err: error }, "held actions not saved"),
-				);
-			if (held)
-				logger.info(
-					{ channel: key, held: held.calls.map((call) => call.action) },
-					"actions held for confirmation",
-				);
-			logger.info(
-				{
-					channel: key,
-					selection: request.selection.id,
-					toolCalls,
-					thinking: session.thinkingLevel,
-					// pi-lens-ignore: no-conditional-empty-object-spread — owner turns keep their log line without a model key
-					...(request.agent
-						? { model: `${session.model?.provider}/${session.model?.id}` }
-						: {}),
-				},
-				"turn finished",
-			);
+			await wrapUpTurn({
+				key,
+				request,
+				session,
+				gate,
+				toolCalls,
+				options: this.#options,
+				recordUsage: (usage) => this.#sessions.usage.set(key, usage),
+			});
 		}
 
 		if (running.stopped)
@@ -368,6 +369,8 @@ export class PiAgentRuntime implements AgentRuntime {
 	): Promise<string> {
 		const { dataDir } = this.#options;
 		const { signal } = task;
+		if (this.#options.stopping?.())
+			throw new AgentRunError(new HostStoppingError().message);
 		// A task works at the tier of the turn that started it; without one there is no tier to take.
 		const turn = this.#turns.get(scope.turn);
 		if (!turn)
@@ -393,7 +396,11 @@ export class PiAgentRuntime implements AgentRuntime {
 		const unsubscribe = session.subscribe((event) => {
 			if (event.type === "tool_execution_start") toolCalls.push(event.toolName);
 		});
-		const abort = () => void session.abort();
+		// A worker whose model ignores the abort is given up on, like a turn's.
+		const guard = new AbortGuard(session, {
+			graceMs: this.#options.turnAbortGraceMs,
+		});
+		const abort = () => guard.abort();
 		signal?.addEventListener("abort", abort, { once: true });
 		const timer = setTimeout(abort, task.timeoutMs);
 		try {
@@ -411,13 +418,16 @@ export class PiAgentRuntime implements AgentRuntime {
 					(name) => registered.has(name) && this.#tiers.allows(tier, name),
 				);
 			session.setActiveToolsByName([...worker.tools]);
-			await withoutReplyFiles(() => session.prompt(task.text));
+			const prompted = withoutReplyFiles(() => session.prompt(task.text));
+			prompted.catch(() => undefined);
+			await Promise.race([prompted, guard.gaveUp]);
 			return workerReport(
 				session.messages,
 				"the worker stopped before it reported",
 			);
 		} finally {
 			clearTimeout(timer);
+			guard.release();
 			signal?.removeEventListener("abort", abort);
 			unsubscribe();
 			session.dispose();
@@ -467,33 +477,6 @@ export class PiAgentRuntime implements AgentRuntime {
 		return transcriptOf(await this.#sessions.messages(channel), limit);
 	}
 
-	/** Uses the checked model snapshot; auto thinking keeps the last pick while the judge is unsure. */
-	async #thinkingLevel(
-		key: ChannelKey,
-		session: AgentSession,
-		request: TurnRequest,
-		agentModel?: AgentModelSettings,
-	): Promise<ThinkingLevel> {
-		const setting = request.agent
-			? await useChosenAgentModel(
-					session,
-					this.#modelRuntime,
-					request.agent.name,
-					agentModel,
-				)
-			: AUTO_THINKING;
-		if (setting !== AUTO_THINKING) {
-			this.#sessions.judged.delete(key);
-			return setting;
-		}
-		const level = await this.#options.effort.judge(request.text, {
-			reply: lastReply(session.messages),
-			level: this.#sessions.judged.get(key),
-		});
-		this.#sessions.judged.set(key, level);
-		return level;
-	}
-
 	dispose(): void {
 		this.#sessions.dispose();
 	}

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

@@ -168,6 +168,7 @@ export function runtimePlugin(
 						}),
 						confirmations: heldActions,
 						toolTiers: context.toolTiers,
+						stopping: () => context.queue.closed,
 						get agents() {
 							return agents();
 						},

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

@@ -80,6 +80,14 @@ export interface PiAgentRuntimeOptions {
 	toolTiers?: ToolTiers;
 	/** A run that takes longer, not counting time spent waiting on the owner's cards, is aborted and reported as failed. */
 	turnTimeoutMs?: 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
+	 * abort would otherwise hold the turn, and the shutdown drain, for ever.
+	 */
+	turnAbortGraceMs?: number;
+	/** Whether the host is shutting down: a turn or a task is then refused before it starts. */
+	stopping?: () => boolean;
 	/**
 	 * Whether a turn given a place for interim posts shows the text it writes before its final
 	 * answer as it goes; default "on". "off" posts only the final reply.

package/src/core/runtime/session-factory.ts

@@ -332,6 +332,7 @@ export class SessionFactory {
 			},
 			conversation,
 			addressee,
+			attachmentDir,
 			get memory() {
 				return state.memory;
 			},

package/src/core/runtime/steerable-run.ts

@@ -33,13 +33,22 @@ export class SteerableRun {
 	readonly #canSteer: () => boolean;
 	/** Steered prompts in arrival order, each with its images. */
 	readonly #steers: { text: string; images: PromptImages }[] = [];
+	readonly #abort: () => void;
 	#stopped = false;
 	#done = false;
 
-	/** `canSteer` is asked at each steer: the turn is the owner's and holds no actions. */
-	constructor(session: SteeringSession, canSteer: () => boolean) {
+	/**
+	 * `canSteer` is asked at each steer: the turn is the owner's and holds no actions. `abort`
+	 * ends the session's run when the turn is stopped; by default the session's own abort.
+	 */
+	constructor(
+		session: SteeringSession,
+		canSteer: () => boolean,
+		abort: () => void = () => void session.abort(),
+	) {
 		this.#session = session;
 		this.#canSteer = canSteer;
+		this.#abort = abort;
 	}
 
 	get stopped(): boolean {
@@ -106,7 +115,7 @@ export class SteerableRun {
 		if (this.#done) return false;
 		this.#stopped = true;
 		this.#session.clearQueue();
-		void this.#session.abort();
+		this.#abort();
 		return true;
 	}
 

package/src/core/runtime/thinking-level.ts

@@ -0,0 +1,47 @@
+import type {
+	AgentSession,
+	ModelRuntime,
+} from "@earendil-works/pi-coding-agent";
+import type { ChannelKey } from "../domain/conversation.ts";
+import type { TurnRequest } from "../domain/ports.ts";
+import { AUTO_THINKING, type ThinkingLevel } from "../models.ts";
+import {
+	type AgentModelSettings,
+	useChosenAgentModel,
+} from "./bridge-guard.ts";
+import type { PiAgentRuntimeOptions } from "./runtime-types.ts";
+import { lastReply } from "./turn-answer.ts";
+
+/** Uses the checked model snapshot; auto thinking keeps the last pick while the judge is unsure. */
+export async function thinkingLevel(
+	parts: {
+		modelRuntime: ModelRuntime;
+		effort: PiAgentRuntimeOptions["effort"];
+		/** The level last judged for each conversation. */
+		judged: Map<ChannelKey, ThinkingLevel>;
+	},
+	key: ChannelKey,
+	session: AgentSession,
+	request: TurnRequest,
+	agentModel?: AgentModelSettings,
+): Promise<ThinkingLevel> {
+	const { modelRuntime, effort, judged } = parts;
+	const setting = request.agent
+		? await useChosenAgentModel(
+				session,
+				modelRuntime,
+				request.agent.name,
+				agentModel,
+			)
+		: AUTO_THINKING;
+	if (setting !== AUTO_THINKING) {
+		judged.delete(key);
+		return setting;
+	}
+	const level = await effort.judge(request.text, {
+		reply: lastReply(session.messages),
+		level: judged.get(key),
+	});
+	judged.set(key, level);
+	return level;
+}

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

@@ -0,0 +1,63 @@
+import type { AgentSession } from "@earendil-works/pi-coding-agent";
+import type { ChannelKey } from "../domain/conversation.ts";
+import type { TurnRequest } from "../domain/ports.ts";
+import type { ConfirmationGate } from "./extensions/confirmation-gate.ts";
+import type { PiAgentRuntimeOptions } from "./runtime-types.ts";
+
+/**
+ * What a turn leaves behind when it ends, whatever way it ended: the gate stops counting the turn,
+ * the conversation's context usage and held actions are recorded, and the turn is logged. A
+ * session disposed of under a turn that would not stop has no usage to read.
+ */
+export async function wrapUpTurn(parts: {
+	key: ChannelKey;
+	request: TurnRequest;
+	session: AgentSession;
+	gate: ConfirmationGate;
+	toolCalls: readonly string[];
+	options: Pick<PiAgentRuntimeOptions, "confirmations" | "logger">;
+	recordUsage: (usage: {
+		tokens: number | null;
+		contextWindow: number;
+	}) => void;
+}): Promise<void> {
+	const { key, request, session, gate, toolCalls, options, recordUsage } =
+		parts;
+	const { logger } = options;
+	gate.endTurn();
+	try {
+		const usage = session.getContextUsage();
+		if (usage)
+			recordUsage({
+				tokens: usage.tokens,
+				contextWindow: usage.contextWindow,
+			});
+	} catch (error) {
+		logger.warn({ channel: key, err: error }, "context usage not read");
+	}
+	const held = gate.pending();
+	await options.confirmations
+		.save(key, held)
+		// pi-lens-ignore: no-unknown-parameters — a rejection reason is unknown; it only reaches the logger
+		.catch((error: unknown) =>
+			logger.error({ channel: key, err: error }, "held actions not saved"),
+		);
+	if (held)
+		logger.info(
+			{ channel: key, held: held.calls.map((call) => call.action) },
+			"actions held for confirmation",
+		);
+	logger.info(
+		{
+			channel: key,
+			selection: request.selection.id,
+			toolCalls,
+			thinking: session.thinkingLevel,
+			// pi-lens-ignore: no-conditional-empty-object-spread — owner turns keep their log line without a model key
+			...(request.agent
+				? { model: `${session.model?.provider}/${session.model?.id}` }
+				: {}),
+		},
+		"turn finished",
+	);
+}