pi-roundtable 0.15.3 → 0.16.0

package/CHANGELOG.md

@@ -5,6 +5,18 @@ The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ## [Unreleased]
 
+## [0.16.0] - 2026-10-16
+
+### Changed
+
+- Release in lockstep with pi-roundtable-line 0.16.0, which adds a webhook screen, LINE's API through the plugin and `senderNameProblem`; the core has no behavior change. Every package's core peer range moves to `>=0.16.0 <0.17.0`.
+
+## [0.15.4] - 2026-10-15
+
+### Changed
+
+- With `discord.agentSpeakers: "owners"`, a schedule whose turn would run below the owner tier no longer starts its precheck or its container: the scheduler asks the channel's claim before the precheck, and the run is recorded `skipped:` with the reason the turn would have been skipped with (`the agent server answers owners only (speakers: "owners")`). A new optional `ChannelClaim.backgroundRefusal(turn)` answers that for a claim, with the turn and the speaker the router checked; `ConversationPort.runsAs` and `ChannelRouter.runsAs` now include it, and the agent server's claim uses it for its own `background` skips (the owner target only, no groups, owners only). A claim without it is unaffected.
+
 ## [0.15.3] - 2026-10-15
 
 ### Added

package/docs/plugins.md

@@ -1238,7 +1238,7 @@ pi-roundtable-sandbox's `precheckScriptRunner` runs each script in a sealed cont
 - `schedule_create` and `schedule_update` take `precheck_script`, a JavaScript module of at most `PRECHECK_SCRIPT_CHARS` (8,000) characters with a default export; it is parsed, never run, when it is set. A schedule has a `precheck` or a `precheck_script`; setting one removes the other, and `null` removes either.
 - The runner's `run(script, context)` gets the `PrecheckScriptContext`: the schedule, `firedAt`, `tier`, `signal`, the host's `timeZone`, and `today`, the date there. `tier` is the tier the run is for: the schedule's, capped at what its creator holds now, as its turn would run. Its answer is checked like a named precheck's, and its finding is named `script`.
 - `describe({ channel, target, tier })` (a `PrecheckScope`) tells the model how to write one and what it may call there; `schedule_list` shows it, waiting at most 10 seconds. `tier` is the asker's there and the run's `tier` when it runs, so a runner may grant lower tiers less.
-- Before a schedule's precheck, named or a script, the scheduler checks who its turn would run as, as `ConversationPort.runsAs` does: a creator who may not run it now, such as one disabled, runs no precheck, and the run is recorded `skipped:` with the reason.
+- Before a schedule's precheck, named or a script, the scheduler checks who its turn would run as, as `ConversationPort.runsAs` does: a creator who may not run it now, such as one disabled, runs no precheck, and the run is recorded `skipped:` with the reason. The claim that owns the channel is asked too (`ChannelClaim.backgroundRefusal`): with `discord.agentSpeakers: "owners"`, a schedule whose turn would run below the owner tier starts no precheck and no container, and is recorded with the same reason its turn would have been skipped with.
 - When the host stops, the scheduler aborts running scripts and waits up to 15 seconds for the runner to clean up; a precheck that ends then starts no turn.
 - Without a runner, the tools neither take nor mention `precheck_script`, a script is refused with the registered names, and a schedule that already has one wakes with `### Precheck failed: script`, never a silent skip.
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "pi-roundtable",
-	"version": "0.15.3",
+	"version": "0.16.0",
 	"description": "A plugin-driven Pi agent server for one owner, reached through Discord or the web",
 	"type": "module",
 	"license": "MIT",
@@ -65,7 +65,7 @@
 		"canvas": "3.2.3",
 		"discord.js": "14.27.0",
 		"pi-jev-compaction": "1.0.0",
-		"pi-mcp-adapter": "5.0.0",
+		"pi-mcp-adapter": "5.2.0",
 		"pino": "10.4.0",
 		"typebox": "1.3.34",
 		"unpdf": "1.8.1"
@@ -78,6 +78,6 @@
 		"@biomejs/biome": "2.5.15",
 		"@types/bun": "1.4.2",
 		"pi-self-compact": "0.2.0",
-		"pi-web-access": "0.35.0"
+		"pi-web-access": "0.39.0"
 	}
 }

package/src/core/agents/agent-claim.ts

@@ -7,6 +7,7 @@ import {
 import type {
 	Admission,
 	BackgroundTarget,
+	BackgroundTurn,
 	ChannelClaim,
 	InboundMessage,
 } from "../contract/channels.ts";
@@ -19,7 +20,7 @@ import { PERSONAL_TARGET } from "../modules/background/personal-target.ts";
 import { withReference } from "../routing/message-text.ts";
 import { outcome } from "../routing/settle-turn.ts";
 import { systemTurn } from "../routing/system-turns.ts";
-import { addressee, attributed } from "../speakers.ts";
+import { addressee, attributed, type Speaker } from "../speakers.ts";
 import type { DiscordAgentTeam } from "./agent-team.ts";
 import { discordIdOf } from "./team-keys.ts";
 
@@ -104,6 +105,19 @@ export function agentClaim(options: AgentClaimOptions): ChannelClaim {
 		}
 	};
 
+	/** Why the agent server would skip a background turn for its checked speaker; the turn's own skips. */
+	const backgroundRefusal = (
+		turn: BackgroundTurn & { speaker: Speaker },
+	): string | undefined => {
+		// Fail closed: a turn for any target but the owner's never reaches the owner's tools.
+		if (turn.target !== PERSONAL_TARGET.name)
+			return `the agent server answers only "${PERSONAL_TARGET.name}" background turns`;
+		if (team.owns(turn.channel) === "group") return "groups have no schedules";
+		if (options.speakers === "owners" && turn.speaker.tier !== "owner")
+			return 'the agent server answers owners only (speakers: "owners")';
+		return undefined;
+	};
+
 	const webhookReport = (message: InboundMessage): Admission | undefined => {
 		const text = message.text.trim();
 		if (!text) return undefined;
@@ -201,16 +215,8 @@ export function agentClaim(options: AgentClaimOptions): ChannelClaim {
 				failure: "agent message handling failed",
 			};
 		},
+		backgroundRefusal,
 		background: async (turn) => {
-			// Fail closed: a turn for any target but the owner's never reaches the owner's tools.
-			if (turn.target !== PERSONAL_TARGET.name)
-				return {
-					status: "skipped",
-					reason: `the agent server answers only "${PERSONAL_TARGET.name}" background turns`,
-				};
-			const owned = team.owns(turn.channel);
-			if (owned === "group")
-				return { status: "skipped", reason: "groups have no schedules" };
 			// Who the turn runs as, checked by the router: its author's principal, at a tier they hold.
 			const { speaker } = turn;
 			if (!speaker)
@@ -219,11 +225,8 @@ export function agentClaim(options: AgentClaimOptions): ChannelClaim {
 					reason:
 						"a background turn reaches the agent server through the router, which says whom it runs as",
 				};
-			if (options.speakers === "owners" && speaker.tier !== "owner")
-				return {
-					status: "skipped",
-					reason: 'the agent server answers owners only (speakers: "owners")',
-				};
+			const reason = backgroundRefusal({ ...turn, speaker });
+			if (reason !== undefined) return { status: "skipped", reason };
 			return outcome(
 				await team.answerBackground(
 					turn.channel,

package/src/core/contract/channels.ts

@@ -197,6 +197,15 @@ export interface ChannelClaim {
 	admit(message: InboundMessage): Admission | undefined;
 	/** A background turn in an owned channel; a claim without one skips them. */
 	background?(turn: BackgroundTurn): Promise<ScheduledOutcome>;
+	/**
+	 * Why `background` would skip the turn for its checked speaker, without running it; undefined
+	 * when it would not. The router asks it in `runsAs`, so work that must not happen for a turn
+	 * the claim will skip, such as a schedule's precheck, does not start. It decides from the turn
+	 * and its speaker alone, and its reasons are the ones `background` skips with.
+	 */
+	backgroundRefusal?(
+		turn: BackgroundTurn & { speaker: Speaker },
+	): string | undefined;
 	/** Starts the channel's conversation over, saying whose it was. */
 	startFresh(channel: ChannelKey): Promise<string>;
 	/**
@@ -230,7 +239,8 @@ export interface ConversationPort {
 	background(turn: BackgroundTurn): Promise<ScheduledOutcome>;
 	/**
 	 * Who a background turn would run as now, checked as `background` checks it, without running
-	 * it: for work that must not happen for an author who may not run the turn, such as a
+	 * it: for work that must not happen for an author who may not run the turn, or one the channel's
+	 * claim would skip for that speaker (an agent server that answers owners only), such as a
 	 * schedule's precheck. Throws when the identity service cannot tell.
 	 */
 	runsAs(turn: BackgroundTurn): Promise<BackgroundRunsAs>;

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

@@ -336,10 +336,23 @@ export class ChannelRouter implements ConversationPort {
 	/**
 	 * Who a background turn runs as: the system principal for the host's own turn, at its tier;
 	 * otherwise its author's principal, which must exist, be enabled, and hold a tier now, at the
-	 * lower of the turn's tier and theirs. Why not, when it may not run; throws when the identity
+	 * lower of the turn's tier and theirs; and the claim that owns the channel must not refuse it
+	 * for that speaker (`backgroundRefusal`). Why not, when it may not run; throws when the identity
 	 * service cannot tell.
 	 */
 	async runsAs(turn: BackgroundTurn): Promise<BackgroundRunsAs> {
+		const runs = await this.#speakerOf(turn);
+		if ("skipped" in runs) return runs;
+		// The claim that owns the channel has the last word, so work that must not start for a turn it
+		// would skip, such as a schedule's precheck, does not.
+		const refusal = this.#owner(turn.channel)?.backgroundRefusal?.({
+			...turn,
+			speaker: runs.speaker,
+		});
+		return refusal === undefined ? runs : { skipped: refusal };
+	}
+
+	async #speakerOf(turn: BackgroundTurn): Promise<BackgroundRunsAs> {
 		const { author, tier } = turn;
 		if (!author?.principalId || !tier)
 			return {