pi-roundtable 0.26.0 → 0.26.1

package/CHANGELOG.md

@@ -5,6 +5,31 @@ The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ## [Unreleased]
 
+## [0.26.1] - 2026-10-30
+
+### Added
+
+- `pi-roundtable-web`: typing `@AI` as the first word of the composer works as the toggle in a room that offers it: the switch shows on while it is there, and the page sends an explicit turn with the token cut from the text. Pasted text, a mention later in the text and an address like `a@ai.com` do not count, and the server never reads a message's text for it.
+- `pi-roundtable-web`: internal notes in an agent or group room: an agent or group room that more than one person reads (the host has more than one owner) gets an `@AI` switch on the composer, on by default. Off, the message is an internal note: it is stored in the room's log with its author, shown live to every other owner and in the history with the author's name and picture and an "Internal note" marker (zh-TW has its own wording), and never given to the agent: no turn runs, it is not in the agent's session, and it is not in any channel context. The server says which rooms take notes: `RoomView.notes` is `true` on the agent and group rooms of a host with more than one owner, absent otherwise, so the page does not guess. A note is a `send` frame with `mode: "note"` (the frame the host rooms already use); a stored note carries `RoomMessage.note: true` (additive column `web_room_messages.note`, migration `web-room-messages-note`). A host with one owner behaves exactly as before: no switch, no new field in the room list or the history, and a `note` frame is still refused as `bad_frame`. The fixture takes `FIXTURE_OWNERS=2` to try it with Ada and Bob.
+
+### Fixed
+
+- `pi-roundtable-web`: a folder's header no longer turns into an unreadable light fill with white text when the pointer rests on it (on a phone the highlight stuck after a tap), and its title is left-aligned, not centered. The base rule `button:hover:not(:disabled)` out-specified the header's own style; its hover, press and keyboard focus now tint the label and keep its text colour in every look and scheme.
+- `pi-roundtable-web`: a row of the room list that is held and dragged on an iPhone now lifts and reorders. iOS Safari lets a page stop a finger's scroll only if a non-passive `touchmove` listener existed when the finger went down; the lift added its own after the hold, so the first move scrolled the page and the browser cancelled the drag. While a row that can be lifted is on the page, a no-op non-passive `touchmove` listener is now held.
+- `pi-roundtable-web`: the plain room list (no pin and no folder yet) keeps Agents and Groups by latest activity, as the arranged list and the drawer do. Before, it kept the order the server listed them in, so a room you had just talked to did not move up, even after a reload.
+
+### Added
+
+- `HoldDescription.onDeclined` (hold answers `{ text, onDeclined }`): called once when the call's approval card is declined, also after the turn stopped waiting, so the plugin that held the call can close what it opened for it, such as its own approval notice. Not called for an approval, an expiry, a withdrawal through `supersede` or a message that does not confirm the call; what it throws is ignored. See [Hearing that the card was declined](docs/plugins.md#hearing-that-the-card-was-declined).
+- `pi-roundtable-web`: `HostCard.keep`: a card the host still wants (a ticket's pinned card while the ticket is open) survives its kind's `retention.textDays` sweep for as long as `card` or `updateCard` passes `keep: true`; `updateCard` without it makes the card ordinary again. Adds the migration `web-host-cards-keep` (a `keep` column).
+- `conversations.keep(record)` (config; `ResolvedConfig.conversations.keep`): asked for each conversation the retention sweep would delete after its kind's `keepDays`; `true` keeps it until the next sweep, so a host can hold a conversation it still wants, such as a support conversation whose ticket is open. A `keep` that throws keeps the conversation and is logged. `ConversationSweep` gains `kept`. See [Conversation retention](docs/plugins.md#conversation-retention-conversationskeepdays).
+- `pi-roundtable-web`: `WebApp.rooms.context(room, { limit?, messageChars? })`: a host room's recent messages as the channel-context block `CHANNEL_CONTEXT.read` gives a turn, for a host that starts a turn from a room's `send` hook and has no addressing message. It marks nothing handed over, so a retry reads the same.
+- `pi-roundtable-web`: `auth.onSessionVerified(principalId)` for `oidc`: called when a request or an open socket proves a live session, at most once per session every five minutes, so a host can count a person who only has the app open as present. It is not awaited; an error it throws is logged and never fails the request.
+
+### Changed
+
+- `pi-roundtable-web`: an ordinary folder is a light section header (chevron, name, count, ⋯), left-aligned like the Home and Pinned labels, not the boxed grey card, which stays for the archive. A folded folder shows a small overlapping stack of the pictures of its first four rooms and, when it holds more, how many more (`+2`).
+
 ## [0.26.0] - 2026-10-30
 
 ### Added

package/docs/plugins.md

@@ -1006,6 +1006,22 @@ A rule whose verdict depends on the input, such as one that holds only a `delete
 It is asked when the input is not known yet, as for a [precheck script](#precheck-scripts-prechecks-the-agent-writes)'s call whose arguments are computed when it runs; a rule without it is judged by `describe` with an empty input.
 A rule whose held call stands for others can answer `approvalTier(tool, input, context)`: the lowest tier that may approve it when higher than the tool's own. The held call keeps it as `minTier`, and both its card and a confirming message require it. A card is answered, and a confirming message accepted, from the speaker whose turn held the call, when their tier is at least `minTier`, and from the owners where the conversation is shared ([who answers a prompt](#who-answers-a-prompt-promptscope)); nobody else in the channel may approve it. The held call records that speaker as `PendingConfirmation.speakerId` and their principal as `principalId`, so a confirming message from another identity of theirs counts after a restart too; a call held without them is the owners' to approve, and one held before 0.9, without a principal, is matched by `speakerId`.
 
+#### Hearing that the card was declined
+
+A hold that opened something of its own for the call, such as a notice that asks for the approval, closes it when the owner declines the card by answering `{ text, onDeclined }` (`HoldDescription.onDeclined`, beside `supersede`; a tool's `hold` and a rule's `describeInTurn` both may):
+
+```ts
+hold: (args) => {
+	const notice = openNotice(`Send ${args.to} the quote?`);
+	return { text: `send ${args.to} the quote`, onDeclined: () => notice.close() };
+},
+```
+
+`onDeclined` is called once when the call's approval card is declined, whether the turn was still waiting on it or the owner declined after the turn stopped waiting (the call is refused either way, as before).
+It is not called when the card is approved, goes unanswered or expires, is cancelled with the turn, or when the plugin withdrew the call with `supersede` first (the plugin did that itself), and a held call that a message does not confirm is simply dropped without it.
+A hook belongs to the process that holds the card: a restart loses it with the card, so a plugin that must clean up after a restart does so when the hold describes the repeated call again.
+What the hook throws or rejects with is ignored, and so is anything but a function.
+
 #### A hold that makes its card the speaker's alone
 
 By default the speaker whose turn made a held call may answer its card, and in a shared conversation so may every owner. A hold that wants only the speaker to press, such as one whose tool books something under the speaker's name, answers `{ text, approval: "speaker" }` (`HoldDescription.approval`, beside `copy` and `supersede`; a tool's `hold` and a rule's `describeInTurn` both may):
@@ -2223,6 +2239,17 @@ The key is a conversation's kind (`ConversationRecord.kind`) and the value a who
 A sweep runs when the host starts and once a day after: for each recorded conversation of a listed kind past its days, it calls `ConversationPort.deleteConversation`, which its claim carries out, and then forgets the record (`ConversationRegistry.remove`, optional on a hand-built registry).
 A conversation with a turn running or waiting (`"busy"`) is skipped and tried again at the next sweep; one whose claim cannot delete it is logged and kept.
 A kind not listed, and a host without the key, keeps its conversations as before.
+
+A conversation can be wanted for longer than its kind's days, such as a support conversation whose ticket is still open.
+`conversations.keep(record)` is asked for each conversation past its days, before it is deleted; answering `true` keeps it for now, and it is asked again at the next sweep, so the conversation goes once the host stops wanting it.
+A `keep` that throws or rejects keeps the conversation for this sweep and is logged.
+
+```ts
+conversations: {
+	keepDays: { support: 365 },
+	keep: async (conversation) => (await tickets.isOpen(conversation.key)),
+},
+```
 The agents' own channels are not recorded conversations and are not touched.
 
 ### `piPackages`: Pi extensions every session loads

package/package.json

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

package/src/core/config/config.ts

@@ -271,7 +271,10 @@ export interface ResolvedConfig extends ResolvedLimits {
 	/** Absent `retention`: used files live as long as their conversation. */
 	attachments: AttachmentsConfig;
 	/** Days to keep each conversation kind after its last activity; a kind not listed is kept. */
-	conversations: { keepDays: Readonly<Record<string, number>> };
+	conversations: {
+		keepDays: Readonly<Record<string, number>>;
+		keep?: ConversationsConfig["keep"];
+	};
 	agentDir: string;
 	model: ModelRef;
 	thinking: ThinkingLevel;
@@ -373,7 +376,12 @@ export function resolveConfig(input: unknown): ResolvedConfig {
 		attachments: config.attachments?.retention
 			? { retention: config.attachments.retention }
 			: {},
-		conversations: { keepDays: { ...config.conversations?.keepDays } },
+		conversations: {
+			keepDays: { ...config.conversations?.keepDays },
+			...(config.conversations?.keep
+				? { keep: config.conversations.keep }
+				: {}),
+		},
 		agentDir: config.agentDir ?? `${config.dataDir}/pi`,
 		model,
 		thinking,

package/src/core/config/conversations.ts

@@ -1,4 +1,5 @@
-import { integer, optional, record, shape } from "./schema.ts";
+import type { ConversationRecord } from "../conversations/conversation-registry.ts";
+import { guarded, integer, optional, record, shape } from "./schema.ts";
 
 /** The configuration's `conversations`: what the host does with the conversations it has recorded. */
 export interface ConversationsConfig {
@@ -10,6 +11,15 @@ export interface ConversationsConfig {
 	 * which is what a host without this key does.
 	 */
 	keepDays?: Readonly<Record<string, number>>;
+	/**
+	 * Asked for each conversation the sweep would delete, after its kind's `keepDays` ran out:
+	 * answer `true` to keep it for now, such as a support conversation whose ticket is still open.
+	 * It is asked again at the next sweep, so a conversation kept today is deleted once the host
+	 * stops wanting it. A function that throws or rejects keeps the conversation for this sweep and
+	 * is logged. Without it
+	 * every conversation past its days is deleted.
+	 */
+	keep?: (conversation: ConversationRecord) => boolean | Promise<boolean>;
 }
 
 /** The longest keep the configuration accepts, in days: a hundred years. */
@@ -17,5 +27,14 @@ const MAX_DAYS = 36_500;
 
 /** The `conversations` key's shape. */
 export const conversationsShape = optional(
-	shape({ keepDays: optional(record(integer(1, MAX_DAYS))) }),
+	shape({
+		keepDays: optional(record(integer(1, MAX_DAYS))),
+		keep: optional(
+			guarded(
+				"a function from a conversation record to true to keep it",
+				(value): value is NonNullable<ConversationsConfig["keep"]> =>
+					typeof value === "function",
+			),
+		),
+	}),
 );

package/src/core/conversations/conversation-retention.ts

@@ -1,7 +1,10 @@
 import type { ConversationPort } from "../contract/channels.ts";
 import type { Logger } from "../log.ts";
 import type { Service } from "../plugin.ts";
-import type { ConversationRegistry } from "./conversation-registry.ts";
+import type {
+	ConversationRecord,
+	ConversationRegistry,
+} from "./conversation-registry.ts";
 
 const DAY_MS = 24 * 60 * 60_000;
 
@@ -12,6 +15,8 @@ export interface ConversationRetentionOptions {
 	conversations: Pick<ConversationPort, "deleteConversation">;
 	/** Days to keep each kind after its last activity; a kind not listed is kept. */
 	keepDays: Readonly<Record<string, number>>;
+	/** True keeps a conversation past its days for this sweep; a throw keeps it too and is logged. */
+	keep?: (record: ConversationRecord) => boolean | Promise<boolean>;
 	now: () => Date;
 	logger: Logger;
 }
@@ -21,8 +26,10 @@ export interface ConversationSweep {
 	deleted: number;
 	/** A turn was running or waiting: tried again at the next sweep. */
 	busy: number;
-	/** Its claim could not delete it: logged, and tried again at the next sweep. */
+	/** Its claim could not delete it, or `keep` threw: logged, and tried again at the next sweep. */
 	failed: number;
+	/** `keep` wanted it: asked again at the next sweep. */
+	kept: number;
 }
 
 /**
@@ -33,8 +40,13 @@ export interface ConversationSweep {
 export async function sweepConversations(
 	options: ConversationRetentionOptions,
 ): Promise<ConversationSweep> {
-	const { registry, conversations, keepDays, now, logger } = options;
-	const result: ConversationSweep = { deleted: 0, busy: 0, failed: 0 };
+	const { registry, conversations, keepDays, keep, now, logger } = options;
+	const result: ConversationSweep = {
+		deleted: 0,
+		busy: 0,
+		failed: 0,
+		kept: 0,
+	};
 	const at = now().getTime();
 	for (const record of await registry.list()) {
 		const days = keepDays[record.kind];
@@ -44,6 +56,10 @@ export async function sweepConversations(
 		)
 			continue;
 		try {
+			if (keep && (await keep(record))) {
+				result.kept += 1;
+				continue;
+			}
 			const outcome = await conversations.deleteConversation(record.key);
 			if (outcome === "busy") {
 				result.busy += 1;
@@ -55,7 +71,7 @@ export async function sweepConversations(
 			result.failed += 1;
 			logger.warn(
 				{ channel: record.key, kind: record.kind, err: error },
-				"conversation past its keepDays not deleted",
+				"conversation past its keepDays not deleted (keep or its claim failed)",
 			);
 		}
 	}
@@ -77,7 +93,7 @@ export function conversationRetentionService(
 	const sweep = async (): Promise<void> => {
 		try {
 			const result = await sweepConversations(options);
-			if (result.deleted + result.busy + result.failed > 0)
+			if (result.deleted + result.busy + result.failed + result.kept > 0)
 				options.logger.info(result, "conversations past their keepDays swept");
 		} catch (error) {
 			options.logger.warn(

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

@@ -2,7 +2,10 @@ import type { SQL } from "bun";
 import type { RoundtablePlugin } from "../plugin.ts";
 import { CONVERSATIONS } from "../services.ts";
 import type { ConversationRegistry } from "./conversation-registry.ts";
-import { conversationRetentionService } from "./conversation-retention.ts";
+import {
+	type ConversationRetentionOptions,
+	conversationRetentionService,
+} from "./conversation-retention.ts";
 import { PgConversationRegistry } from "./conversation-store.ts";
 
 /** The name of the conversation registry's plugin, as the migration ledger names it. */
@@ -19,6 +22,8 @@ export function conversationsPlugin(
 		PgConversationRegistry.attach(sql),
 	/** Days to keep each conversation kind after its last activity (`conversations.keepDays`); none = keep them all. */
 	keepDays: Readonly<Record<string, number>> = {},
+	/** Asked before a conversation past its days is deleted (`conversations.keep`); true keeps it. */
+	keep?: ConversationRetentionOptions["keep"],
 ): RoundtablePlugin {
 	return {
 		name: CONVERSATIONS_PLUGIN,
@@ -35,6 +40,7 @@ export function conversationsPlugin(
 						registry,
 						conversations,
 						keepDays,
+						...(keep ? { keep } : {}),
 						now: () => env.now(),
 						logger,
 					}),

package/src/core/define-roundtable.ts

@@ -372,7 +372,11 @@ export async function defineRoundtable(
 			}),
 			...(assembly?.admin ?? []),
 			...(agentTeam?.skills ?? []),
-			conversationsPlugin(undefined, config.conversations.keepDays),
+			conversationsPlugin(
+				undefined,
+				config.conversations.keepDays,
+				config.conversations.keep,
+			),
 			modesPlugin(),
 			runtimePlugin({
 				owner,

package/src/core/holds.ts

@@ -47,6 +47,14 @@ export interface HoldContext {
  *
  * `classes` are the hold classes of the call, for a rule that describes it in a turn (see
  * `HoldRule.holdClasses`); a rule that leaves them out leaves its call unclassed.
+ *
+ * `onDeclined` is called once when the call's approval card is declined, whether the turn was
+ * still waiting on it or the owner declined after the turn stopped waiting, so a plugin can close
+ * what it opened for the call, such as its own notice that asks for the approval. It is not
+ * called when the call is withdrawn through `supersede` (the plugin did that itself), approved,
+ * left unanswered or expired, or dropped by a message that does not confirm it: only a declined
+ * card calls it, in the process that holds the card (a restart loses it with the card). It
+ * must not throw; whatever it throws or rejects with is ignored, and the call is refused either way.
  */
 export type HoldDescription =
 	| string
@@ -56,6 +64,7 @@ export type HoldDescription =
 			supersede?: AbortSignal;
 			approval?: "speaker";
 			classes?: readonly string[];
+			onDeclined?: () => void | Promise<void>;
 	  };
 
 /**

package/src/core/runtime/extensions/confirmation-gate.ts

@@ -20,7 +20,7 @@ import {
 	approverOf,
 	askSpeaker,
 	awaitingText,
-	declinedText,
+	declinedRefusal,
 	type GateDecision,
 	type Needing,
 	namesOf,
@@ -337,7 +337,7 @@ export class ConfirmationGate {
 				wait: {
 					// A late answer on the card: the text of the turn that tells the model, and the release it earned.
 					late: (late) => {
-						const outcome = lateOutcome(call, late, watch);
+						const outcome = lateOutcome(call, late, watch, needing.onDeclined);
 						if (outcome?.release) this.#lateApproved.push(outcome.release);
 						return outcome?.text;
 					},
@@ -372,13 +372,8 @@ export class ConfirmationGate {
 				reason: awaitingText(this.#addressee, call),
 				refused: "pending",
 			};
-		if (answer === "declined") {
-			watch?.end();
-			return {
-				reason: declinedText(this.#addressee, call),
-				refused: "declined",
-			};
-		}
+		if (answer === "declined")
+			return declinedRefusal(this.#addressee, call, watch, needing.onDeclined);
 		if (answer === "cancelled") {
 			watch?.end();
 			return { reason: "The turn was stopped." };
@@ -449,6 +444,7 @@ export class ConfirmationGate {
 			...(judged.copy ? { copy: judged.copy } : {}),
 			...(judged.supersede ? { supersede: judged.supersede } : {}),
 			...(judged.speakerOnly ? { speakerOnly: judged.speakerOnly } : {}),
+			...(judged.onDeclined ? { onDeclined: judged.onDeclined } : {}),
 		};
 	}
 

package/src/core/runtime/extensions/gate-refusals.ts

@@ -37,6 +37,8 @@ export type Needing =
 			supersede?: AbortSignal;
 			/** The card is the speaker's alone; see `HoldDescription`. */
 			speakerOnly?: true;
+			/** Called when the call's card is declined; see `HoldDescription`. */
+			onDeclined?: () => void | Promise<void>;
 	  }
 	| { released: Release };
 
@@ -76,6 +78,36 @@ export function declinedText(addressee: OwnerIdentity, call: HeldCall): string {
 	return `${o.name} declined this on its approval card: it would ${call.action}. Do not retry it; go on without it, or ask ${o.him} what ${o.he} wants instead.`;
 }
 
+/**
+ * Tells the plugin that held a call that its card was declined (`HoldDescription.onDeclined`).
+ * The call is refused whatever the plugin does, so what its hook throws or rejects with is ignored.
+ */
+export function notifyDeclined(
+	onDeclined: (() => void | Promise<void>) | undefined,
+): void {
+	if (!onDeclined) return;
+	try {
+		Promise.resolve(onDeclined()).catch(() => undefined);
+	} catch {
+		// A hook that throws changes nothing: the call is refused already.
+	}
+}
+
+/**
+ * The refusal of a call declined on its card the turn was still waiting on: ends the plugin's
+ * watch of the call, tells it through `onDeclined`, and gives the turn the text and the reason.
+ */
+export function declinedRefusal(
+	addressee: OwnerIdentity,
+	call: HeldCall,
+	watch: { end(): void } | undefined,
+	onDeclined: (() => void | Promise<void>) | undefined,
+): { reason: string; refused: "declined" } {
+	watch?.end();
+	notifyDeclined(onDeclined);
+	return { reason: declinedText(addressee, call), refused: "declined" };
+}
+
 /** The text for a held call that the speaker's own message confirms. */
 export function askSpeaker(addressee: OwnerIdentity, call: HeldCall): string {
 	const o = ownerWords(addressee);

package/src/core/runtime/extensions/hold-lookups.ts

@@ -36,6 +36,8 @@ export interface Judgment {
 	speakerOnly?: true;
 	/** The hold classes of the call; see `HoldRule.holdClasses`. Absent when the holds gave none. */
 	classes?: readonly string[] | undefined;
+	/** Called when the call's card is declined; see `HoldDescription`. */
+	onDeclined?: () => void | Promise<void>;
 }
 
 export type Judged = Judgment | undefined | typeof STOPPED;
@@ -59,11 +61,14 @@ function isSignal(value: unknown): value is AbortSignal {
 export function described(
 	answer: HoldDescription,
 	tool: string,
-): Pick<Judgment, "action" | "copy" | "supersede" | "speakerOnly" | "classes"> {
+): Pick<
+	Judgment,
+	"action" | "copy" | "supersede" | "speakerOnly" | "classes" | "onDeclined"
+> {
 	if (typeof answer === "string") return { action: answer };
 	if (typeof answer !== "object" || answer === null)
 		return { action: messages().holdGeneric(tool) };
-	const { text, copy, supersede, approval, classes } = answer;
+	const { text, copy, supersede, approval, classes, onDeclined } = answer;
 	if (typeof text !== "string") return { action: messages().holdGeneric(tool) };
 	const named = Array.isArray(classes)
 		? classes.filter((id): id is string => typeof id === "string" && id !== "")
@@ -72,6 +77,7 @@ export function described(
 		...(isSignal(supersede) ? { supersede } : {}),
 		...(approval === "speaker" ? { speakerOnly: true as const } : {}),
 		...(named.length > 0 ? { classes: named } : {}),
+		...(typeof onDeclined === "function" ? { onDeclined } : {}),
 	};
 	if (
 		!copy ||
@@ -142,6 +148,7 @@ export function joinApprovers(
 			supersede,
 			speakerOnly,
 			classes,
+			onDeclined,
 		} = described(action, tool);
 		const joined = (approvers: readonly string[] | undefined): Judgment => ({
 			action: text,
@@ -149,6 +156,7 @@ export function joinApprovers(
 			...(supersede ? { supersede } : {}),
 			...(speakerOnly ? { speakerOnly } : {}),
 			...(classes ? { classes } : {}),
+			...(onDeclined ? { onDeclined } : {}),
 			...(approvers ? { approvers } : {}),
 		});
 		const controller = new AbortController();

package/src/core/runtime/extensions/late-answer.ts

@@ -1,6 +1,6 @@
 import type { HeldCall } from "../../domain/conversation.ts";
 import type { LateAnswer } from "../../interactions/prompts.ts";
-import type { Release } from "./gate-refusals.ts";
+import { notifyDeclined, type Release } from "./gate-refusals.ts";
 import { namedApprover } from "./held-calls.ts";
 import type { Watch } from "./withdrawals.ts";
 
@@ -8,12 +8,14 @@ import type { Watch } from "./withdrawals.ts";
  * What a card answered after its turn stopped waiting comes to: the text of the turn that tells
  * the model, and, for an approval that stands, the release that lets the identical call run once
  * in whichever turn makes it next. Undefined when the answer changes nothing: a question's, a
- * card its plugin withdrew, or an approval by someone the call does not name.
+ * card its plugin withdrew, or an approval by someone the call does not name. A card declined
+ * tells the plugin through `onDeclined`.
  */
 export function lateOutcome(
 	call: HeldCall,
 	late: LateAnswer,
 	watch: Watch | undefined,
+	onDeclined?: () => void | Promise<void>,
 ): { text: string; release?: Release } | undefined {
 	// A card the plugin withdrew answers nothing, whatever a surface that kept it open reports.
 	if (watch?.withdrawn || late.kind !== "approval") return undefined;
@@ -21,6 +23,7 @@ export function lateOutcome(
 	if (late.approved && !namedApprover(call, late.approvedBy)) return undefined;
 	if (!late.approved) {
 		watch?.end();
+		notifyDeclined(onDeclined);
 		return {
 			text: `(${late.by} declined on its card the action you were waiting on: it would ${call.action}. It did not run; do not make the call again. Go on without it, or ask what ${late.by} wants instead.)`,
 		};