pi-roundtable 0.21.0 → 0.22.1

package/src/core/modules/skills/skill-rules.ts

@@ -28,7 +28,8 @@ export interface SkillSet {
 export type SkillSource =
 	| { kind: "builtin" }
 	| { kind: "linked"; repo: string; path: string }
-	| { kind: "written" };
+	| { kind: "written" }
+	| { kind: "package"; package: string };
 
 /** One skill as the web app lists it; a skill whose file cannot be read has `missing` instead. */
 export interface SkillCatalogEntry {
@@ -43,6 +44,15 @@ export interface SkillCatalogEntry {
 	carriers: string[];
 }
 
+/** A skill an installed npm package offers through its `pi.skills` folders. */
+export interface PackageSkill {
+	name: string;
+	/** The npm package that holds it. */
+	package: string;
+	/** Its SKILL.md in the installed package. */
+	file: string;
+}
+
 export interface SkillRegistryOptions {
 	store: SkillStore;
 	/** Managed repositories, as `<dir>/<owner>/<repo>`. */
@@ -51,6 +61,8 @@ export interface SkillRegistryOptions {
 	writtenDir: string;
 	/** The release's built-in skills, as `<dir>/<name>/SKILL.md`. */
 	builtinDir: string;
+	/** Skills of installed packages, as `discoverPackageSkills` found them at startup. */
+	packageSkills?: readonly PackageSkill[];
 	logger: Logger;
 }
 

package/src/core/presentation/failure-notice.ts

@@ -0,0 +1,13 @@
+import { TurnTimeoutError } from "../domain/turn-timeout.ts";
+import { messages } from "../i18n/index.ts";
+
+/** What a failed turn posts: the stopped notice for a stop, the reason for a time limit, else the failure notice. */
+export function failureNotice(result: {
+	error: Error;
+	stopped?: true;
+}): string {
+	if (result.stopped) return messages().stoppedNotice;
+	if (result.error instanceof TurnTimeoutError)
+		return messages().turnTimedOutNotice(result.error.timeout);
+	return messages().failureNotice;
+}

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

@@ -10,10 +10,10 @@ import type { TurnResult } from "../domain/conversation.ts";
 import type { TurnConversation } from "../domain/ports.ts";
 import type { TurnProgress } from "../domain/progress.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";
 import type { EventSink } from "../plugin.ts";
+import { failureNotice } from "../presentation/failure-notice.ts";
 import { splitReply } from "../presentation/reply-splitter.ts";
 import { thinkingLine } from "../presentation/thinking-line.ts";
 import { withReplyFiles } from "../reply-files.ts";
@@ -239,12 +239,7 @@ export function conversationTurns(
 
 /** The default post: the answer with its thinking line, or the failure or stopped notice. */
 function replyOf(result: TurnResult) {
-	if (!result.ok)
-		return {
-			chunks: [
-				result.stopped ? messages().stoppedNotice : messages().failureNotice,
-			],
-		};
+	if (!result.ok) return { chunks: [failureNotice(result)] };
 	const thinking = result.thinking ? thinkingLine(result.thinking) : undefined;
 	return {
 		...(thinking ? { thinking } : {}),

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

@@ -48,7 +48,8 @@ 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 type { TurnBudget } from "./turn-budget.ts";
+import { promptFailed, turnLimits } from "./turn-limits.ts";
 import { progressReporter } from "./turn-progress.ts";
 import { wrapUpTurn } from "./turn-wrapup.ts";
 import { workerReport } from "./worker-task.ts";
@@ -240,6 +241,10 @@ export class PiAgentRuntime implements AgentRuntime {
 		const interim = interimPoster(request, this.#options);
 		// 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 progress = request.progress
 			? progressReporter(request.progress, {
 					refusalOf: (id) => slot.refusalOf(id),
@@ -247,6 +252,7 @@ export class PiAgentRuntime implements AgentRuntime {
 			: undefined;
 		const unsubscribe = session.subscribe((event) => {
 			progress?.observe(event);
+			limits.observe(event);
 			if (event.type === "tool_execution_start") {
 				toolCalls.push(event.toolName);
 				interim?.toolStart(event.toolName);
@@ -275,10 +281,7 @@ export class PiAgentRuntime implements AgentRuntime {
 				this.#sessions.drop(key, channelSession);
 			},
 		});
-		// 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(),
-		);
+		const { budget } = limits;
 		this.#budgets.set(key, budget);
 		const running = new SteerableRun(
 			session,
@@ -307,10 +310,7 @@ export class PiAgentRuntime implements AgentRuntime {
 		} catch (error) {
 			if (running.stopped)
 				return { ok: false, error: new AgentRunError(STOPPED), stopped: true };
-			return {
-				ok: false,
-				error: new AgentRunError(`prompt failed: ${String(error)}`),
-			};
+			return limits.failure() ?? promptFailed(error);
 		} finally {
 			this.#running.delete(key);
 			this.#budgets.delete(key);
@@ -335,7 +335,7 @@ export class PiAgentRuntime implements AgentRuntime {
 
 		if (running.stopped)
 			return { ok: false, error: new AgentRunError(STOPPED), stopped: true };
-		return turnAnswer(turnMessages, running.steered);
+		return limits.failure() ?? turnAnswer(turnMessages, running.steered);
 	}
 
 	async steer(

package/src/core/runtime/prompt-slot.ts

@@ -99,6 +99,14 @@ export class PromptSlot {
 		};
 	}
 
+	/**
+	 * The turn's prompts as bound, an open card not counted as waiting; for a card the turn keeps
+	 * working beside, such as the one its time limit posts.
+	 */
+	get cards(): Prompts | undefined {
+		return this.#prompts;
+	}
+
 	/** Time this turn has spent with at least one card open. */
 	waitedMs(now = Date.now()): number {
 		return this.#waited + (this.#open > 0 ? now - this.#openSince : 0);

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

@@ -89,17 +89,25 @@ export interface PiAgentRuntimeOptions {
 	/** 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 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
+	 * A run that works longer, not counting time spent waiting on the owner's cards, asks the owner
+	 * on a card whether to go on (see `turnTimeoutCardMs`), or, when it cannot show one, is aborted
+	 * and reported as failed with the reason; 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.
+	 * takes no more steering (the message waits for the next turn) and asks or is aborted as on its
+	 * timeout; the owner's Continue moves the cap to a full `turnTimeoutMs` from then.
 	 */
 	turnMaxMs?: number;
+	/**
+	 * How long the card a turn posts when it reaches `turnTimeoutMs` or `turnMaxMs` waits for the
+	 * owner's Continue or Cancel, in wall time, while the turn keeps working; default 5 minutes. With
+	 * no answer by then the turn is aborted. A turn that cannot show a card is aborted at once.
+	 */
+	turnTimeoutCardMs?: 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-activity.ts

@@ -0,0 +1,42 @@
+import type { AgentSessionEvent } from "@earendil-works/pi-coding-agent";
+
+/** What a turn was doing at one moment: tools running and for how long, or compacting, or neither (the model). */
+export interface TurnActivity {
+	/** The tools running, the longest-running first, each with how long it has run. */
+	running: { tool: string; ms: number }[];
+	compacting: boolean;
+	/** Every tool called so far, by name, with how often, in the order first called. */
+	tools: [string, number][];
+}
+
+/** Follows a turn's events to say, when asked, what it is doing; never its inputs. */
+export interface ActivityTracker {
+	observe(event: AgentSessionEvent): void;
+	now(at: number): TurnActivity;
+}
+
+export function activityTracker(
+	clock: () => number = Date.now,
+): ActivityTracker {
+	const running = new Map<string, { tool: string; since: number }>();
+	const tools = new Map<string, number>();
+	let compacting = false;
+	return {
+		observe(event) {
+			if (event.type === "tool_execution_start") {
+				running.set(event.toolCallId, { tool: event.toolName, since: clock() });
+				tools.set(event.toolName, (tools.get(event.toolName) ?? 0) + 1);
+			} else if (event.type === "tool_execution_end") {
+				running.delete(event.toolCallId);
+			} else if (event.type === "compaction_start") compacting = true;
+			else if (event.type === "compaction_end") compacting = false;
+		},
+		now: (at) => ({
+			running: [...running.values()]
+				.sort((a, b) => a.since - b.since)
+				.map(({ tool, since }) => ({ tool, ms: at - since })),
+			compacting,
+			tools: [...tools],
+		}),
+	};
+}

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

@@ -1,9 +1,16 @@
+import type {
+	TurnLimit,
+	TurnTimeout,
+	TurnTimeoutEnd,
+} from "../domain/turn-timeout.ts";
+import { messages } from "../i18n/index.ts";
+import type { Approval } from "../interactions/prompts.ts";
 import type { ChannelKey } from "../sessions.ts";
 import type { PromptSlot } from "./prompt-slot.ts";
 import type { PiAgentRuntimeOptions } from "./runtime-types.ts";
+import type { ActivityTracker } from "./turn-activity.ts";
 
-/** Which limit ended a turn: its budget since the start or the last steer, or its cap. */
-export type TurnLimit = "turn" | "turnMax";
+export type { TurnLimit };
 
 /** A turn's time limit, which a steered message renews up to a cap on the whole turn. */
 export interface TurnBudget {
@@ -12,8 +19,15 @@ export interface TurnBudget {
 	 * 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. */
+	/**
+	 * After a limit fired, gives the turn its full budget again from now, as the owner's Continue
+	 * does; with `raiseCap` the cap moves too, to a full budget from now.
+	 */
+	extend(raiseCap: boolean): void;
+	/** Whether the turn has worked up to its cap, or a limit fired and was not extended. */
 	capped(): boolean;
+	/** The turn's work so far, not counting time the slot spent waiting on cards. */
+	workedMs(): number;
 	cancel(): void;
 }
 
@@ -43,13 +57,13 @@ const REARM_FLOOR_MS = 1_000;
 /**
  * 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.
+ * towards neither. `expire` is told which limit fired and its length.
  */
 export function turnBudget(
 	ms: number,
 	maxMs: number,
 	slot: Pick<PromptSlot, "waitedMs">,
-	expire: (limit: TurnLimit) => void,
+	expire: (limit: TurnLimit, limitMs: number) => void,
 	clock: BudgetClock = REAL_CLOCK,
 ): TurnBudget {
 	const started = clock.now();
@@ -57,7 +71,8 @@ export function turnBudget(
 		const now = clock.now();
 		return now - started - slot.waitedMs(now);
 	};
-	let deadline = Math.min(ms, maxMs);
+	let cap = maxMs;
+	let deadline = Math.min(ms, cap);
 	let cancelTimer: (() => void) | undefined;
 	let expired = false;
 	const arm = (delay: number) => {
@@ -65,47 +80,172 @@ export function turnBudget(
 			const left = deadline - worked();
 			if (left > 0) return arm(Math.max(left, REARM_FLOOR_MS));
 			expired = true;
-			expire(deadline >= maxMs ? "turnMax" : "turn");
+			if (deadline >= cap) expire("turnMax", cap);
+			else expire("turn", ms);
 		}, delay);
 	};
 	arm(deadline);
 	return {
 		renew() {
 			const now = worked();
-			if (expired || now >= maxMs) return undefined;
-			deadline = Math.min(now + ms, maxMs);
+			if (expired || now >= cap) return undefined;
+			deadline = Math.min(now + ms, cap);
 			cancelTimer?.();
 			arm(deadline - now);
 			return deadline - now;
 		},
-		capped: () => expired || worked() >= maxMs,
+		extend(raiseCap) {
+			const now = worked();
+			if (raiseCap) cap = Math.max(cap, now + ms);
+			deadline = Math.min(now + ms, cap);
+			expired = false;
+			cancelTimer?.();
+			arm(Math.max(deadline - now, REARM_FLOOR_MS));
+		},
+		capped: () => expired || worked() >= cap,
+		workedMs: worked,
 		cancel: () => cancelTimer?.(),
 	};
 }
 
+/** What the runtime's turn budget needs besides its options: what the turn is doing, and its clock. */
+export interface TurnBudgetSeams {
+	activity: Pick<ActivityTracker, "now">;
+	clock?: BudgetClock;
+}
+
 /**
  * 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`.
+ * 10 minutes) renewed by each steer up to `turnMaxMs` (default three times that). When a limit
+ * fires on a turn that can show the owner a card, the turn keeps working and a card asks whether
+ * to go on: Continue extends the limit that fired by a full budget from then, Cancel aborts, and
+ * no answer within `turnTimeoutCardMs` (default 5 minutes, wall time) aborts. The card closes
+ * when the turn ends first. Without a card the turn is aborted at once. `abort` is told why.
  */
 export function runtimeTurnBudget(
 	options: Pick<
 		PiAgentRuntimeOptions,
-		"turnTimeoutMs" | "turnMaxMs" | "logger"
+		"turnTimeoutMs" | "turnMaxMs" | "turnTimeoutCardMs" | "logger"
 	>,
-	slot: Pick<PromptSlot, "waitedMs">,
+	slot: Pick<PromptSlot, "waitedMs" | "cards">,
 	channel: ChannelKey,
-	abort: () => void,
+	abort: (timeout: TurnTimeout) => void,
+	seams: TurnBudgetSeams,
 ): TurnBudget {
 	const { logger, turnTimeoutMs = 10 * 60_000 } = options;
 	const turnMaxMs = options.turnMaxMs ?? 3 * turnTimeoutMs;
-	const budget = turnBudget(turnTimeoutMs, turnMaxMs, slot, (limit) => {
+	const graceMs = options.turnTimeoutCardMs ?? 5 * 60_000;
+	const clock = seams.clock ?? REAL_CLOCK;
+	/** Closes the open timeout card, if any, with the footer given. */
+	let closeCard: ((footer: string) => void) | undefined;
+	const reason = (
+		limit: TurnLimit,
+		limitMs: number,
+		end: TurnTimeoutEnd,
+	): TurnTimeout => ({
+		limit,
+		limitMs,
+		workedMs: budget.workedMs(),
+		...seams.activity.now(clock.now()),
+		graceMs,
+		end,
+	});
+	const stop = (timeout: TurnTimeout) => {
 		logger.warn(
-			{ channel, limit, turnTimeoutMs, turnMaxMs },
+			{
+				channel,
+				limit: timeout.limit,
+				turnTimeoutMs,
+				turnMaxMs,
+				workedMs: timeout.workedMs,
+				running: timeout.running,
+				compacting: timeout.compacting,
+				tools: timeout.tools,
+				end: timeout.end,
+			},
 			"turn timed out; aborting",
 		);
-		abort();
-	});
+		abort(timeout);
+	};
+	const budget = turnBudget(
+		turnTimeoutMs,
+		turnMaxMs,
+		slot,
+		(limit, limitMs) => {
+			const prompts = slot.cards;
+			if (!prompts) return stop(reason(limit, limitMs, "timeout"));
+			const m = messages();
+			const asked = reason(limit, limitMs, "timeout");
+			logger.info(
+				{
+					channel,
+					limit,
+					workedMs: asked.workedMs,
+					running: asked.running,
+				},
+				"turn reached its time limit; asking the owner",
+			);
+			const controller = new AbortController();
+			let open = true;
+			const settle = () => {
+				if (!open) return false;
+				open = false;
+				closeCard = undefined;
+				cancelGrace();
+				return true;
+			};
+			const cancelGrace = clock.schedule(() => {
+				if (!settle()) return;
+				const timeout = reason(limit, limitMs, "unanswered");
+				controller.abort(m.turnTimeoutUnanswered(timeout));
+				stop(timeout);
+			}, graceMs);
+			closeCard = (footer) => {
+				if (settle()) controller.abort(footer);
+			};
+			const answered = (approval: Approval) => {
+				if (!settle()) return;
+				if (approval === "approved") {
+					budget.extend(limit === "turnMax");
+					logger.info(
+						{ channel, limit, workedMs: budget.workedMs() },
+						"owner continued the turn past its time limit",
+					);
+				} else
+					stop(
+						reason(
+							limit,
+							limitMs,
+							approval === "declined" ? "cancelled" : "timeout",
+						),
+					);
+			};
+			prompts
+				.confirm(
+					m.turnTimeoutTitle,
+					m.turnTimeoutQuestion(asked, turnTimeoutMs),
+					undefined,
+					"owner",
+					undefined,
+					undefined,
+					{
+						supersede: controller.signal,
+						wording: {
+							approve: m.turnTimeoutContinue,
+							decline: m.turnTimeoutCancel,
+							footer: m.turnTimeoutFooter,
+							approved: m.turnTimeoutContinued,
+							declined: m.turnTimeoutCancelled,
+						},
+					},
+				)
+				.then(answered, (error: unknown) => {
+					logger.warn({ channel, err: error }, "timeout card failed");
+					answered("unavailable");
+				});
+		},
+		clock,
+	);
 	return {
 		...budget,
 		renew() {
@@ -117,5 +257,9 @@ export function runtimeTurnBudget(
 				);
 			return deadlineMs;
 		},
+		cancel() {
+			budget.cancel();
+			closeCard?.(messages().turnTimeoutFinished);
+		},
 	};
 }

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

@@ -0,0 +1,61 @@
+import type { AgentSessionEvent } from "@earendil-works/pi-coding-agent";
+import type { TurnResult } from "../domain/conversation.ts";
+import { AgentRunError } from "../domain/errors.ts";
+import { type TurnTimeout, TurnTimeoutError } from "../domain/turn-timeout.ts";
+import { catalogFor } from "../i18n/index.ts";
+import type { ChannelKey } from "../sessions.ts";
+import type { PromptSlot } from "./prompt-slot.ts";
+import { activityTracker } from "./turn-activity.ts";
+import { runtimeTurnBudget, type TurnBudget } from "./turn-budget.ts";
+
+/** One turn's time limit, with what it follows of the turn to say why it fired. */
+export interface TurnLimits {
+	budget: TurnBudget;
+	/** Follows the turn's events: its tools and its compactions. */
+	observe(event: AgentSessionEvent): void;
+	/** The turn's failure when a limit aborted it, its reason as a `TurnTimeoutError`; else undefined. */
+	failure(): TurnResult | undefined;
+}
+
+/** The answer to a turn whose prompt threw, when no limit aborted it. */
+export function promptFailed(error: unknown): TurnResult {
+	return {
+		ok: false,
+		error: new AgentRunError(`prompt failed: ${String(error)}`),
+	};
+}
+
+/** A timed-out turn's reason in English, for its error and the logs. */
+export function timeoutMessage(timeout: TurnTimeout): string {
+	return catalogFor("en").turnTimedOutNotice(timeout);
+}
+
+/** The time limit of a turn of the built-in runtime; see `runtimeTurnBudget`. `abort` aborts the turn. */
+export function turnLimits(
+	options: Parameters<typeof runtimeTurnBudget>[0],
+	slot: Pick<PromptSlot, "waitedMs" | "cards">,
+	channel: ChannelKey,
+	abort: () => void,
+): TurnLimits {
+	const activity = activityTracker();
+	let timedOut: TurnTimeout | undefined;
+	const budget = runtimeTurnBudget(
+		options,
+		slot,
+		channel,
+		(timeout) => {
+			timedOut = timeout;
+			abort();
+		},
+		{ activity },
+	);
+	return {
+		budget,
+		observe: (event) => activity.observe(event),
+		failure: () =>
+			timedOut && {
+				ok: false,
+				error: new TurnTimeoutError(timedOut, timeoutMessage(timedOut)),
+			},
+	};
+}

package/src/core/services.ts

@@ -1,3 +1,4 @@
+import type { ExtensionFactory } from "@earendil-works/pi-coding-agent";
 import type { Agent, AgentGroup } from "./agents/agent-rules.ts";
 import type { AvatarMode } from "./agents/agent-tools.ts";
 import type { TeamStatus } from "./agents/team-status.ts";
@@ -12,7 +13,7 @@ import type { PendingConfirmation } from "./domain/conversation.ts";
 import type { HttpRoute } from "./http/listeners.ts";
 import type { IdentityLinks } from "./identity/identity-links.ts";
 import type { IdentityService } from "./identity/identity-service.ts";
-import type { ThinkingSetting } from "./models.ts";
+import type { ThinkingLevel, ThinkingSetting } from "./models.ts";
 import type {
 	DelegationJob,
 	DelegationOutcome,
@@ -91,6 +92,12 @@ export const BACKGROUND_TURNS: ServiceKey<BackgroundTurns> =
 export const DELEGATION: ServiceKey<Delegator> = serviceKey<Delegator>(
 	"roundtable.delegation",
 );
+/**
+ * Worker sessions on the host's models: a fresh, unsaved Pi session that has only the tools a
+ * plugin gives it. Provided by the `worker-sessions` plugin.
+ */
+export const WORKER_SESSIONS: ServiceKey<WorkerSessions> =
+	serviceKey<WorkerSessions>("roundtable.worker-sessions");
 /**
  * The remembered facts of each speaker. Provided by the `memory` plugin, an addon: read it with
  * `find` when your plugin works without memory, and with `get` when it cannot.
@@ -267,6 +274,42 @@ export interface Delegator {
 	idle(): Promise<void>;
 }
 
+/** One task for a worker session. */
+export interface WorkerSessionRequest {
+	/** What the worker is asked to do, as its one prompt. */
+	task: string;
+	/** Aborting it stops the worker; `run` then rejects. */
+	signal: AbortSignal;
+	/** Appended to the worker's system prompt: its role, its rules, and any instructions it should follow. */
+	prompt: string;
+	/** Extensions that register the worker's tools with `pi.registerTool`. */
+	extensions: readonly ExtensionFactory[];
+	/** The only tools active in the session. The session has no built-in tool, skill, context file or other extension. */
+	toolNames: readonly string[];
+	/** `<provider>/<id>`; default: the host's delegation model. */
+	model?: string;
+	/** Default: the host's delegation thinking level. */
+	thinking?: ThinkingLevel;
+	/** Why an aborted run stopped, as the rejection's message; default "the worker ran out of time". */
+	aborted?: string;
+}
+
+/**
+ * Runs one task in a fresh, unsaved Pi session on the host's model login and returns the worker's
+ * final answer. The session is disposed of either way. It has no access to the conversation, the
+ * owner's memory or the agents' tools: it can do only what `toolNames` lets it, and the tools a
+ * plugin registers for it are that plugin's to bound.
+ */
+export interface WorkerSessions {
+	/** The model and thinking level a request without its own uses: the host's `delegation` settings. */
+	readonly delegation: {
+		readonly model: string;
+		readonly thinking: ThinkingLevel;
+	};
+	/** Rejects with an `AgentRunError` when the worker ends without an answer. */
+	run(request: WorkerSessionRequest): Promise<string>;
+}
+
 /** Remembered facts, each speaker's own; every agent shares the memory of whoever is speaking. */
 export interface MemoryStore {
 	/** One speaker's memory; it never reads or changes another's. */

package/src/index.ts

@@ -39,6 +39,7 @@ export type {
 	RoundtableConfig,
 	TierConfig,
 } from "./core/config/config.ts";
+export type { SkillsConfig } from "./core/config/skills-config.ts";
 export type {
 	AttachmentPort,
 	AttachmentRefusalCode,
@@ -138,6 +139,12 @@ export type {
 } from "./core/domain/interim.ts";
 export type { TurnConversation, TurnRequest } from "./core/domain/ports.ts";
 export type { HoldRefusal, TurnProgress } from "./core/domain/progress.ts";
+export {
+	type TurnLimit,
+	type TurnTimeout,
+	type TurnTimeoutEnd,
+	TurnTimeoutError,
+} from "./core/domain/turn-timeout.ts";
 export type { DrainOptions } from "./core/drain.ts";
 export {
 	HostStoppingError,
@@ -193,6 +200,7 @@ export type {
 	ApprovalDetails,
 	ApprovalFile,
 	ApprovalOptions,
+	ApprovalWording,
 	ApprovedBy,
 	AskOption,
 	AskSupport,
@@ -309,6 +317,8 @@ export type {
 	ScheduleStore,
 	SkillRegistry,
 	SpeakerMemory,
+	WorkerSessionRequest,
+	WorkerSessions,
 } from "./core/services.ts";
 export {
 	AGENTS,
@@ -322,6 +332,7 @@ export {
 	RUNTIME,
 	SCHEDULES,
 	SKILLS,
+	WORKER_SESSIONS,
 } from "./core/services.ts";
 export type {
 	AgentTurnScope,