pi-roundtable 0.7.17 → 0.7.19

package/CHANGELOG.md

@@ -5,6 +5,25 @@ The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ## [Unreleased]
 
+## [0.7.19] - 2026-10-07
+
+### Fixed
+
+- Behavior change: in a conversation outside the agent server, such as a plugin's persona conversation run through `context.turns`, a member or admin speaker now reads and changes their own memory. Before, every such turn carried the owner's core facts and upcoming events in its system prompt, whoever spoke, and `memory_add`, `memory_search`, and `memory_remove` (member-tier tools, when a turn's selection offered them) read and changed the owner's memory. The prompt section of such a turn is headed `Memory of <name>` and lists only that speaker's facts. A speaker of the owner tier, the owner or remote MCP's speaker, keeps the owner's memory, and the owner's own conversations, agent conversations, and every tool description read as before. No data moves: facts a member stored before this release sit in the owner's memory, and the owner may remove them with `memory_remove`.
+
+## [0.7.18] - 2026-10-05
+
+### Fixed
+
+- Stop reading attachments as soon as they exceed the 25 MiB limit and cancel HTTP error bodies instead of leaving them open.
+- Stop claiming or starting schedules when shutdown occurs during a database query or claim; already running turns still finish normally.
+- Isolate keyless Jev tests from the developer's home, XDG configuration and environment.
+
+### Changed
+
+- Extract schedule precheck resolution, execution and cleanup tracking from the scheduler without changing its public contract.
+- Release all five official packages in lockstep; MCP and sandbox include lifecycle fixes described in their changelogs.
+
 ## [0.7.17] - 2026-10-04
 
 ### Added

package/docs/plugins.md

@@ -1658,6 +1658,7 @@ The runtime reads `prompt()` when it creates the conversation's session, so mess
   The host merges every plugin's list and keeps each name once.
 - A turn whose kind has no persona is refused with an error naming `personas`.
   The Pi runtime refuses when it makes the session; a runtime of your own does the same, as the example's does.
+- With the memory addon on, a turn's `speaker` decides whose memory the system prompt carries and the memory tools change: a member's or an admin's own, and the owner's for a speaker of the owner tier.
 
 Call `context.turns.run(input)` inside your claim's queue task to run a turn in a conversation it owns.
 It shows typing and the stop control on the channel's surface, runs the turn, and emits `turnStarted` and `turnEnded` with the turn's `kind`.

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "pi-roundtable",
-	"version": "0.7.17",
+	"version": "0.7.19",
 	"description": "A plugin-driven Pi agent server for Discord",
 	"type": "module",
 	"license": "MIT",

package/src/core/attachments/attachment-fetcher.ts

@@ -53,12 +53,13 @@ export async function fetchAttachments(
 		try {
 			const response = await fetchImpl(ref.url);
 			if (!response.ok) {
+				await response.body?.cancel();
 				fail(`download failed with HTTP ${response.status}`);
 				continue;
 			}
-			const data = new Uint8Array(await response.arrayBuffer());
-			if (data.byteLength > MAX_ATTACHMENT_BYTES) {
-				fail(`larger than 25 MB (${data.byteLength} bytes)`);
+			const data = await readAttachmentBody(response);
+			if (typeof data === "number") {
+				fail(`larger than 25 MB (${data} bytes)`);
 				continue;
 			}
 			const file = `${prefix}-${index}-${safeFileName(ref.name)}`;
@@ -81,3 +82,34 @@ export async function fetchAttachments(
 	}
 	return { files, failures };
 }
+
+/** Returns the bytes, or the observed size once the stream exceeds the limit. */
+async function readAttachmentBody(
+	response: Response,
+): Promise<Uint8Array | number> {
+	if (!response.body) return new Uint8Array();
+	const reader = response.body.getReader();
+	const chunks: Uint8Array[] = [];
+	let size = 0;
+	try {
+		for (;;) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			size += value.byteLength;
+			if (size > MAX_ATTACHMENT_BYTES) {
+				await reader.cancel();
+				return size;
+			}
+			chunks.push(value);
+		}
+	} finally {
+		reader.releaseLock();
+	}
+	const data = new Uint8Array(size);
+	let offset = 0;
+	for (const chunk of chunks) {
+		data.set(chunk, offset);
+		offset += chunk.byteLength;
+	}
+	return data;
+}

package/src/core/builtin/stores.ts

@@ -4,7 +4,8 @@ import { PgMemoryStore } from "../modules/memory/owner-memory-store.ts";
 import { memoryPrecheckRegistry } from "../modules/schedules/prechecks.ts";
 import { PgScheduleStore } from "../modules/schedules/schedule-store.ts";
 import type { RoundtablePlugin } from "../plugin.ts";
-import { MEMORY, PRECHECKS, SCHEDULES } from "../services.ts";
+import { MEMORY, type MemoryStore, PRECHECKS, SCHEDULES } from "../services.ts";
+import type { SessionTool } from "../sessions.ts";
 import { THE_SPEAKER, type Tier } from "../speakers.ts";
 import { fixed } from "./session-tool.ts";
 
@@ -14,12 +15,37 @@ export interface MemoryOptions {
 }
 
 /** Each speaker keeps a memory of their own, so every tier may use the tools; the owner's reaches only the owner's turns. */
-const MEMORY_TIERS: Readonly<Record<string, Tier>> = {
+export const MEMORY_TIERS: Readonly<Record<string, Tier>> = {
 	memory_add: "member",
 	memory_search: "member",
 	memory_remove: "member",
 };
 
+/** The memory tools and prompt block of every conversation, over the given store. */
+export function memorySessionTool(
+	memory: MemoryStore,
+	owner: MemoryOptions["owner"],
+): SessionTool {
+	return fixed("owner-memory", (session) => {
+		// An agent session serves every speaker, so its tools name none.
+		if (session.agent)
+			return ownerMemoryExtension(
+				memory,
+				owner.id,
+				THE_SPEAKER,
+				session.speaker,
+			);
+		// Any other conversation may admit a member or an admin, who reads and changes their own
+		// memory; an owner-tier speaker, such as remote MCP, speaks as the owner.
+		const speaker = () => {
+			const current = session.speaker();
+			return current?.tier === "owner" ? undefined : current;
+		};
+		// Its tools keep the owner's words, so the owner's own chats read as before.
+		return ownerMemoryExtension(memory, owner.id, owner, speaker, false);
+	});
+}
+
 /**
  * The remembered facts of each speaker: the table, the store over it provided as `MEMORY`, and
  * the memory tools and prompt block of every conversation. An addon; `memory: false` leaves it
@@ -35,18 +61,7 @@ export function memoryPlugin(options: MemoryOptions): RoundtablePlugin {
 			const memory = PgMemoryStore.attach(database(), owner.id);
 			services.provide(MEMORY, memory);
 			return {
-				sessionTools: [
-					fixed("owner-memory", (session) =>
-						ownerMemoryExtension(
-							memory,
-							owner.id,
-							// An agent session serves every speaker, so its tools name none.
-							session.agent ? THE_SPEAKER : owner,
-							// The owner's own chats have one speaker; the agent server's have several.
-							session.agent ? session.speaker : undefined,
-						),
-					),
-				],
+				sessionTools: [memorySessionTool(memory, owner)],
 				toolTiers: MEMORY_TIERS,
 			};
 		},

package/src/core/modules/memory/owner-memory.ts

@@ -47,10 +47,12 @@ export function ownerMemoryExtension(
 	ownerId: string,
 	owner: OwnerIdentity,
 	/**
-	 * The person the running turn is for, in a session that serves several. Their memory, not
-	 * the owner's, is what the turn reads and changes; without it every turn is the owner's.
+	 * The person the running turn is for, when it may be someone other than the owner. Their
+	 * memory, not the owner's, is what the turn reads and changes; without it every turn is the owner's.
 	 */
 	speaker?: () => Speaker | undefined,
+	/** Whether the tools tell the model that each speaker has a memory of their own. */
+	describesSpeakers = speaker !== undefined,
 ): ExtensionFactory {
 	const o = ownerWords(owner);
 	/** The running turn's other speaker; undefined when the owner's own memory applies. */
@@ -59,7 +61,7 @@ export function ownerMemoryExtension(
 		return current && current.id !== ownerId ? current : undefined;
 	};
 	const storeOf = () => memories.forSpeaker(other()?.id ?? ownerId);
-	const shared = speaker
+	const shared = describesSpeakers
 		? " Whoever is speaking has a memory of their own, shared by every agent; this reads and changes theirs, not someone else's."
 		: "";
 	return (pi) => {

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

@@ -0,0 +1,166 @@
+import type { HoldCheck } from "../../holds.ts";
+import type { Logger } from "../../log.ts";
+import { timeZone, zonedStamp } from "../../time.ts";
+import { type PrecheckTool, precheckScriptTools } from "./precheck-tools.ts";
+import {
+	type Precheck,
+	type PrecheckOutcome,
+	type PrecheckRegistry,
+	runPrecheck,
+	SCRIPT_PRECHECK,
+} from "./prechecks.ts";
+import type { Schedule } from "./schedule-store.ts";
+
+interface SchedulePrechecksOptions {
+	/** The host's prechecks and script runner; without them, a schedule that has one runs with that as its error. */
+	prechecks?: Pick<PrecheckRegistry, "get"> &
+		Partial<Pick<PrecheckRegistry, "scriptRunner">>;
+	/**
+	 * The host's hold rules, read when a script saved before its tools were recorded runs: it runs
+	 * only if it calls no held tool. Without them, such a script does not run.
+	 */
+	holds?: () => HoldCheck;
+	logger: Logger;
+	signal: AbortSignal;
+}
+
+/** Runs schedule prechecks and tracks underlying runs that outlive a timeout. */
+export class SchedulePrechecks {
+	readonly #options: SchedulePrechecksOptions;
+	readonly #pending = new Set<Promise<unknown>>();
+
+	constructor(options: SchedulePrechecksOptions) {
+		this.#options = options;
+	}
+
+	async run(
+		schedule: Schedule,
+		name: string,
+		firedAt: Date,
+	): Promise<PrecheckOutcome> {
+		const { logger } = this.#options;
+		let decision: PrecheckOutcome;
+		try {
+			const precheck = this.#resolve(schedule, firedAt);
+			decision =
+				typeof precheck === "string"
+					? { kind: "failed", error: precheck }
+					: await runPrecheck(
+							precheck,
+							{ schedule, firedAt },
+							{
+								signal: this.#options.signal,
+								settled: (run) => {
+									const tracked = run
+										.catch(() => undefined)
+										.finally(() => this.#pending.delete(tracked));
+									this.#pending.add(tracked);
+								},
+							},
+						);
+		} catch (error) {
+			decision = {
+				kind: "failed",
+				error: `the precheck could not be looked up: ${error instanceof Error ? error.message : String(error)}`,
+			};
+		}
+		// A warning, not an error: the woken turn carries the error already, and an error line would
+		// wake the ops agent's report turn for the same failure.
+		if (decision.kind === "failed")
+			logger.warn(
+				{ schedule: schedule.id, precheck: name, error: decision.error },
+				"precheck failed; the scheduled turn runs with the error",
+			);
+		else
+			logger.info(
+				{
+					schedule: schedule.id,
+					precheck: name,
+					wake: decision.kind === "wake",
+				},
+				"precheck decided",
+			);
+		return decision;
+	}
+
+	async drain(limitMs: number): Promise<void> {
+		let timer: ReturnType<typeof setTimeout> | undefined;
+		const limit = new Promise<"late">((resolve) => {
+			timer = setTimeout(() => resolve("late"), limitMs);
+		});
+		const settled = Promise.allSettled([...this.#pending]);
+		try {
+			// pi-lens-ignore: no-single-promise-in-promise-methods — the race includes both all pending cleanup and the stop deadline
+			if ((await Promise.race([settled, limit])) === "late")
+				this.#options.logger.warn(
+					{ prechecks: this.#pending.size },
+					"prechecks still cleaning up when the scheduler stopped",
+				);
+		} finally {
+			clearTimeout(timer);
+		}
+	}
+
+	/**
+	 * The schedule's precheck: a registered one by name, or its script through the host's runner.
+	 * A script never runs in this process; without a runner it fails, and the turn still runs.
+	 */
+	#resolve(schedule: Schedule, firedAt: Date): Precheck | string {
+		const { prechecks } = this.#options;
+		if (schedule.precheck)
+			return (
+				prechecks?.get(schedule.precheck) ??
+				"no precheck of that name is registered"
+			);
+		const script = schedule.precheckScript ?? "";
+		const runner = prechecks?.scriptRunner?.();
+		if (!runner)
+			return "this host has no precheck script runner, so the script did not run";
+		const tools = this.#tools(schedule, script, runner.toolName.bind(runner));
+		if (typeof tools === "string") return tools;
+		const zone = timeZone();
+		return {
+			name: SCRIPT_PRECHECK,
+			description: "the schedule's own precheck script",
+			...(runner.timeoutMs === undefined
+				? {}
+				: { timeoutMs: runner.timeoutMs }),
+			run: (context) =>
+				runner.run(script, {
+					...context,
+					timeZone: zone,
+					today: zonedStamp(firedAt).slice(0, 10),
+					tools: tools.map(({ server, tool }) => ({ server, tool })),
+				}),
+		};
+	}
+
+	/**
+	 * The tools a script may call: those approved when it was saved, or, for a script saved before
+	 * they were recorded, those it calls when none of them is held. Otherwise why it cannot run.
+	 */
+	#tools(
+		schedule: Schedule,
+		script: string,
+		toolName: (server: string, tool: string) => string,
+	): PrecheckTool[] | string {
+		if (schedule.precheckTools) return schedule.precheckTools;
+		const save =
+			"save it again with schedule_update, so the owner can approve the tools it calls";
+		const holds = this.#options.holds?.();
+		if (!holds)
+			return `this script was saved before its tools were recorded, and this host cannot check them; ${save}`;
+		let tools: PrecheckTool[];
+		try {
+			tools = precheckScriptTools(script, { toolName, holds });
+		} catch (error) {
+			return `this script was saved before its tools were recorded and cannot be checked now (${error instanceof Error ? error.message : String(error)}); fix it and ${save}`;
+		}
+		const held = tools.flatMap((t) =>
+			t.held ? [`${t.server}/${t.tool}`] : [],
+		);
+		if (held.length > 0)
+			return `this script was saved before its tools were recorded and calls tools that need the owner's approval (${held.join(", ")}), so it did not run; ${save}`;
+		return tools;
+	}
+}

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

@@ -2,17 +2,13 @@ import type { ScheduledOutcome } from "../../contract/channels.ts";
 import type { HoldCheck } from "../../holds.ts";
 import type { Logger } from "../../log.ts";
 import type { ScheduleStore } from "../../services.ts";
-import { timeZone, zonedStamp } from "../../time.ts";
-import { type PrecheckTool, precheckScriptTools } from "./precheck-tools.ts";
 import {
-	type Precheck,
 	type PrecheckFinding,
-	type PrecheckOutcome,
 	type PrecheckRegistry,
-	runPrecheck,
 	SCRIPT_PRECHECK,
 } from "./prechecks.ts";
 import { nextRun } from "./recurrence.ts";
+import { SchedulePrechecks } from "./schedule-prechecks.ts";
 import type { Schedule } from "./schedule-store.ts";
 
 export type { ScheduledOutcome };
@@ -81,14 +77,19 @@ function precheckPrefix(finding: PrecheckFinding | undefined): string {
 export class Scheduler {
 	readonly #options: SchedulerOptions;
 	readonly #running = new Set<Promise<void>>();
-	/** Prechecks in flight, including their cleanup after a timeout, which stop waits for. */
-	readonly #prechecks = new Set<Promise<unknown>>();
 	readonly #stopping = new AbortController();
+	readonly #prechecks: SchedulePrechecks;
 	#timer: ReturnType<typeof setInterval> | undefined;
 	#ticking = false;
 
 	constructor(options: SchedulerOptions) {
 		this.#options = options;
+		this.#prechecks = new SchedulePrechecks({
+			prechecks: options.prechecks,
+			holds: options.holds,
+			logger: options.logger,
+			signal: this.#stopping.signal,
+		});
 	}
 
 	start(): void {
@@ -107,20 +108,7 @@ export class Scheduler {
 	async stop(): Promise<void> {
 		clearInterval(this.#timer);
 		this.#stopping.abort();
-		let timer: ReturnType<typeof setTimeout> | undefined;
-		const limit = new Promise<"late">((resolve) => {
-			timer = setTimeout(() => resolve("late"), PRECHECK_STOP_MS);
-		});
-		const settled = Promise.allSettled([...this.#prechecks]);
-		try {
-			if ((await Promise.race([settled, limit])) === "late")
-				this.#options.logger.warn(
-					{ prechecks: this.#prechecks.size },
-					"prechecks still cleaning up when the scheduler stopped",
-				);
-		} finally {
-			clearTimeout(timer);
-		}
+		await this.#prechecks.drain(PRECHECK_STOP_MS);
 	}
 
 	/** Claims every due schedule and starts its run; runs continue after tick resolves. */
@@ -131,12 +119,20 @@ export class Scheduler {
 		try {
 			const now = this.#options.now?.() ?? new Date();
 			for (const schedule of await store.due(now)) {
+				if (this.#stopping.signal.aborted) break;
 				const claimed = await store.claim(
 					schedule,
 					nextRun(schedule.recurrence, now),
 					now,
 				);
 				if (!claimed) continue;
+				if (this.#stopping.signal.aborted) {
+					await this.#record(
+						schedule,
+						"skipped: the host stopped before its run",
+					);
+					break;
+				}
 				if (now.getTime() - schedule.nextRun.getTime() > LATE_LIMIT_MS) {
 					logger.warn(
 						{ schedule: schedule.id, due: schedule.nextRun },
@@ -173,7 +169,7 @@ export class Scheduler {
 			schedule.precheck ??
 			(schedule.precheckScript ? SCRIPT_PRECHECK : undefined);
 		if (name) {
-			const decision = await this.#precheck(schedule, name, firedAt);
+			const decision = await this.#prechecks.run(schedule, name, firedAt);
 			if (this.#stopping.signal.aborted) {
 				await this.#record(
 					schedule,
@@ -206,120 +202,6 @@ export class Scheduler {
 		);
 	}
 
-	/**
-	 * The schedule's precheck: a registered one by name, or its script through the host's runner.
-	 * A script never runs in this process; without a runner it fails, and the turn still runs.
-	 */
-	#resolve(schedule: Schedule, firedAt: Date): Precheck | string {
-		const { prechecks } = this.#options;
-		if (schedule.precheck)
-			return (
-				prechecks?.get(schedule.precheck) ??
-				"no precheck of that name is registered"
-			);
-		const script = schedule.precheckScript ?? "";
-		const runner = prechecks?.scriptRunner?.();
-		if (!runner)
-			return "this host has no precheck script runner, so the script did not run";
-		const tools = this.#tools(schedule, script, runner.toolName.bind(runner));
-		if (typeof tools === "string") return tools;
-		const zone = timeZone();
-		return {
-			name: SCRIPT_PRECHECK,
-			description: "the schedule's own precheck script",
-			...(runner.timeoutMs === undefined
-				? {}
-				: { timeoutMs: runner.timeoutMs }),
-			run: (context) =>
-				runner.run(script, {
-					...context,
-					timeZone: zone,
-					today: zonedStamp(firedAt).slice(0, 10),
-					tools: tools.map(({ server, tool }) => ({ server, tool })),
-				}),
-		};
-	}
-
-	/**
-	 * The tools a script may call: those approved when it was saved, or, for a script saved before
-	 * they were recorded, those it calls when none of them is held. Otherwise why it cannot run.
-	 */
-	#tools(
-		schedule: Schedule,
-		script: string,
-		toolName: (server: string, tool: string) => string,
-	): PrecheckTool[] | string {
-		if (schedule.precheckTools) return schedule.precheckTools;
-		const save =
-			"save it again with schedule_update, so the owner can approve the tools it calls";
-		const holds = this.#options.holds?.();
-		if (!holds)
-			return `this script was saved before its tools were recorded, and this host cannot check them; ${save}`;
-		let tools: PrecheckTool[];
-		try {
-			tools = precheckScriptTools(script, { toolName, holds });
-		} catch (error) {
-			return `this script was saved before its tools were recorded and cannot be checked now (${error instanceof Error ? error.message : String(error)}); fix it and ${save}`;
-		}
-		const held = tools.flatMap((t) =>
-			t.held ? [`${t.server}/${t.tool}`] : [],
-		);
-		if (held.length > 0)
-			return `this script was saved before its tools were recorded and calls tools that need the owner's approval (${held.join(", ")}), so it did not run; ${save}`;
-		return tools;
-	}
-
-	/** Runs the schedule's precheck; a missing one fails like a throw, so the turn still runs. */
-	async #precheck(
-		schedule: Schedule,
-		name: string,
-		firedAt: Date,
-	): Promise<PrecheckOutcome> {
-		const { logger } = this.#options;
-		let decision: PrecheckOutcome;
-		try {
-			const precheck = this.#resolve(schedule, firedAt);
-			decision =
-				typeof precheck === "string"
-					? { kind: "failed", error: precheck }
-					: await runPrecheck(
-							precheck,
-							{ schedule, firedAt },
-							{
-								signal: this.#stopping.signal,
-								settled: (run) => {
-									const tracked = run
-										.catch(() => undefined)
-										.finally(() => this.#prechecks.delete(tracked));
-									this.#prechecks.add(tracked);
-								},
-							},
-						);
-		} catch (error) {
-			decision = {
-				kind: "failed",
-				error: `the precheck could not be looked up: ${error instanceof Error ? error.message : String(error)}`,
-			};
-		}
-		// A warning, not an error: the woken turn carries the error already, and an error line would
-		// wake the ops agent's report turn for the same failure.
-		if (decision.kind === "failed")
-			logger.warn(
-				{ schedule: schedule.id, precheck: name, error: decision.error },
-				"precheck failed; the scheduled turn runs with the error",
-			);
-		else
-			logger.info(
-				{
-					schedule: schedule.id,
-					precheck: name,
-					wake: decision.kind === "wake",
-				},
-				"precheck decided",
-			);
-		return decision;
-	}
-
 	/** Records a run the precheck skipped and posts its note; a note that cannot be posted is logged. */
 	async #skip(schedule: Schedule, note: string | undefined): Promise<void> {
 		const { notify, logger } = this.#options;