pi-roundtable 0.26.0 → 0.26.2

package/src/core/i18n/turn-timeout.ts

@@ -75,7 +75,10 @@ export function turnTimeoutEn() {
 					: t.end === "unanswered"
 						? `⏱️ No answer to the timeout card in ${durationEn(t.graceMs)}, so the turn was stopped after ${durationEn(t.workedMs)} ${what}.`
 						: `⏱️ The turn reached ${limit(t)} and was stopped after ${durationEn(t.workedMs)} ${what}.`;
-			return [head, tools(t)].filter(Boolean).join(" ");
+			const unasked = t.unasked
+				? "No one was in the conversation to ask for more time. To let turns like this run longer, turn on long-running for this conversation, or give the schedule a longer time limit."
+				: "";
+			return [head, tools(t), unasked].filter(Boolean).join(" ");
 		},
 	};
 }
@@ -125,7 +128,10 @@ export function turnTimeoutZhTW(): ReturnType<typeof turnTimeoutEn> {
 					: t.end === "unanswered"
 						? `⏱️ 逾時卡片在 ${durationZh(t.graceMs)}內沒有回答，這一輪在工作 ${durationZh(t.workedMs)} 後停止，${what}。`
 						: `⏱️ 這一輪達到${limit(t)}，在工作 ${durationZh(t.workedMs)} 後停止，${what}。`;
-			return [head, tools(t)].filter(Boolean).join(" ");
+			const unasked = t.unasked
+				? "當時對話裡沒有人可以問要不要再給時間。要讓這類回合跑久一點，可以替這個對話開啟長時間執行，或替排程設定較長的時間上限。"
+				: "";
+			return [head, tools(t), unasked].filter(Boolean).join(" ");
 		},
 	};
 }

package/src/core/modules/background/background-turns.ts

@@ -76,6 +76,9 @@ export class ConversationBackgroundTurns implements BackgroundTurns {
 			tier: schedule.createdTier,
 			turnId: `schedule-${schedule.id}-${firedAt.getTime()}`,
 			text: scheduledTurnText(schedule, firedAt, finding),
+			...(schedule.timeLimitMinutes
+				? { timeLimitMs: schedule.timeLimitMinutes * 60_000 }
+				: {}),
 		};
 	}
 

package/src/core/modules/schedules/precheck-catalog.ts

@@ -0,0 +1,49 @@
+import { PRECHECK_SCRIPT_CHARS } from "./prechecks.ts";
+import type { ScheduleToolContext } from "./schedule-tools.ts";
+
+/** How long schedule_list waits for the script runner to say what a script may call. */
+const DESCRIBE_TIMEOUT_MS = 10_000;
+
+/** The prechecks a schedule may name or write, for schedule_list; empty when the host offers neither. */
+export async function precheckCatalog(
+	ctx: ScheduleToolContext,
+): Promise<string> {
+	const all = ctx.prechecks?.list() ?? [];
+	const runner = ctx.prechecks?.scriptRunner?.();
+	const named =
+		all.length === 0
+			? ""
+			: `\n\nPrechecks you can attach with precheck on schedule_create or schedule_update; the host runs one before each turn and wakes you only when it finds something:\n${all.map((p) => `- ${p.name}: ${p.description.replace(/\n/g, " ")}`).join("\n")}`;
+	if (!runner) return named;
+	// The list still answers when the host cannot say, or is slow to say, what a script may reach here.
+	let timer: ReturnType<typeof setTimeout> | undefined;
+	const late = new Promise<string>((resolve) => {
+		timer = setTimeout(
+			() => resolve("it did not answer in time"),
+			DESCRIBE_TIMEOUT_MS,
+		);
+	});
+	const described = Promise.resolve()
+		.then(() =>
+			runner.describe({
+				channel: ctx.channel,
+				target: ctx.target.name,
+				tier: ctx.author.tier,
+			}),
+		)
+		.then(
+			(text) => ({ text }),
+			(error: unknown) => ({
+				error: error instanceof Error ? error.message : String(error),
+			}),
+		);
+	const answer = await Promise.race([
+		described,
+		late.then((error) => ({ error })),
+	]).finally(() => clearTimeout(timer));
+	const guide =
+		"text" in answer
+			? answer.text
+			: `The host could not say what a script may call here (${answer.error}); a script set now may fail when it runs.`;
+	return `${named}\n\nYou can write a precheck of your own instead, with precheck_script on schedule_create or schedule_update (null removes it): a JavaScript module, at most ${PRECHECK_SCRIPT_CHARS} characters, that the host runs in a sandbox before each turn. A schedule has a precheck or a precheck_script, not both.\n${guide}`;
+}

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

@@ -30,6 +30,8 @@ export interface Schedule {
 	 * absent for a script saved before tools were recorded, which must be saved again if it calls a held tool.
 	 */
 	precheckTools?: PrecheckTool[];
+	/** How long, in minutes, each of its turns may work; absent, the runtime's default time limit. */
+	timeLimitMinutes?: number;
 	lastRun?: Date;
 	lastStatus?: string;
 }
@@ -50,6 +52,8 @@ export interface NewSchedule {
 	precheckScript?: string;
 	/** The tools the script may call, as approved; required with `precheckScript`. */
 	precheckTools?: PrecheckTool[];
+	/** How long, in minutes, each of its turns may work. */
+	timeLimitMinutes?: number;
 }
 
 export interface ScheduleChange {
@@ -63,6 +67,8 @@ export interface ScheduleChange {
 	precheckScript?: string | null;
 	/** The tools a new script may call, as approved; required with a new `precheckScript`. */
 	precheckTools?: PrecheckTool[];
+	/** How long, in minutes, each turn may work; null returns it to the runtime's default. */
+	timeLimitMinutes?: number | null;
 }
 
 interface Row {
@@ -81,6 +87,7 @@ interface Row {
 	precheck: string | null;
 	precheck_script: string | null;
 	precheck_tools: string | null;
+	time_limit_minutes: number | null;
 	last_run: Date | null;
 	last_status: string | null;
 }
@@ -105,6 +112,9 @@ function toSchedule(row: Row): Schedule {
 			? // pi-lens-ignore: unchecked-throwing-call — this store wrote the JSON; a corrupt row should fail loudly
 				{ precheckTools: JSON.parse(row.precheck_tools) as PrecheckTool[] }
 			: {}),
+		...(row.time_limit_minutes
+			? { timeLimitMinutes: row.time_limit_minutes }
+			: {}),
 		...(row.last_run ? { lastRun: row.last_run } : {}),
 		...(row.last_status ? { lastStatus: row.last_status } : {}),
 	};
@@ -126,12 +136,14 @@ async function insert(sql: SQL, schedule: NewSchedule): Promise<Schedule> {
 	checked(schedule);
 	const rows: Row[] = await sql`
 		INSERT INTO schedules (channel_key, mode, title, prompt, recurrence, next_run,
-			created_by_id, created_by_name, created_tier, precheck, precheck_script, precheck_tools)
+			created_by_id, created_by_name, created_tier, precheck, precheck_script, precheck_tools,
+			time_limit_minutes)
 		VALUES (${schedule.channel}, ${schedule.target}, ${schedule.title}, ${schedule.prompt},
 			${JSON.stringify(schedule.recurrence)}, ${schedule.nextRun},
 			${schedule.createdById}, ${schedule.createdByName}, ${schedule.createdTier},
 			${schedule.precheck ?? null}, ${schedule.precheckScript ?? null},
-			${schedule.precheckScript ? JSON.stringify(schedule.precheckTools) : null})
+			${schedule.precheckScript ? JSON.stringify(schedule.precheckTools) : null},
+			${schedule.timeLimitMinutes ?? null})
 		RETURNING *`;
 	const [row] = rows;
 	if (!row) throw new Error("the schedule insert returned no row");
@@ -195,6 +207,13 @@ export class PgScheduleStore implements ScheduleStore {
 					await sql`ALTER TABLE schedules ADD COLUMN IF NOT EXISTS precheck_tools text`;
 				},
 			},
+			{
+				// Schedules made before have none: their turns keep the runtime's default time limit.
+				name: "schedules-time-limit",
+				up: async (sql) => {
+					await sql`ALTER TABLE schedules ADD COLUMN IF NOT EXISTS time_limit_minutes integer`;
+				},
+			},
 		];
 	}
 
@@ -282,6 +301,10 @@ export class PgScheduleStore implements ScheduleStore {
 				: current.precheckTools
 					? JSON.stringify(current.precheckTools)
 					: null;
+		const timeLimit =
+			change.timeLimitMinutes === undefined
+				? (current.timeLimitMinutes ?? null)
+				: change.timeLimitMinutes;
 		const rows: Row[] = await this.#sql`
 			UPDATE schedules SET
 				title = ${change.title ?? current.title},
@@ -290,7 +313,8 @@ export class PgScheduleStore implements ScheduleStore {
 				next_run = ${change.nextRun ?? current.nextRun},
 				precheck = ${precheck},
 				precheck_script = ${precheckScript},
-				precheck_tools = ${precheckTools}
+				precheck_tools = ${precheckTools},
+				time_limit_minutes = ${timeLimit}
 			WHERE id = ${id}
 			RETURNING *`;
 		return rows[0] ? toSchedule(rows[0]) : undefined;

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

@@ -8,12 +8,9 @@ import type { ScheduleStore } from "../../services.ts";
 import type { ScheduleToolName } from "../../shared/schedule-tools.ts";
 import { type Tier, tierAtLeast } from "../../speakers.ts";
 import { timeZone, zonedStamp } from "../../time.ts";
+import { precheckCatalog } from "./precheck-catalog.ts";
 import { type PrecheckTool, precheckScriptTools } from "./precheck-tools.ts";
-import {
-	PRECHECK_SCRIPT_CHARS,
-	type PrecheckFinding,
-	type PrecheckRegistry,
-} from "./prechecks.ts";
+import { PRECHECK_SCRIPT_CHARS, type PrecheckRegistry } from "./prechecks.ts";
 import {
 	describeRecurrence,
 	nextRun,
@@ -22,11 +19,10 @@ import {
 	type RecurrenceInput,
 } from "./recurrence.ts";
 import type { NewSchedule, Schedule } from "./schedule-store.ts";
+import { timeLimitInput, timeLimitText } from "./time-limit.ts";
 
 const TITLE_CHARS = 80;
 const LIST_PROMPT_PREVIEW = 200;
-/** How long schedule_list waits for the script runner to say what a script may call. */
-const DESCRIBE_TIMEOUT_MS = 10_000;
 const DAY_MS = 86_400_000;
 
 export interface ScheduleToolContext {
@@ -40,6 +36,12 @@ export interface ScheduleToolContext {
 	> &
 		Partial<Pick<ScheduleStore, "all" | "createWithin">>;
 	channel: ChannelKey;
+	/**
+	 * Every conversation whose schedules the asker lists, changes, and cancels, `channel` among
+	 * them: an agent's own across all its conversations. Without it, `channel` alone. A new
+	 * schedule is always made in `channel`.
+	 */
+	channels?: readonly ChannelKey[];
 	/** Whose schedules these are; its `schedules` limits apply, and without them nothing is scheduled. */
 	target: BackgroundTarget;
 	/**
@@ -158,48 +160,6 @@ function toolsText(tools: readonly PrecheckTool[] | undefined): string {
 		.join(", ");
 }
 
-/** The prechecks a schedule may name or write, for schedule_list; empty when the host offers neither. */
-async function precheckCatalog(ctx: ScheduleToolContext): Promise<string> {
-	const all = ctx.prechecks?.list() ?? [];
-	const runner = ctx.prechecks?.scriptRunner?.();
-	const named =
-		all.length === 0
-			? ""
-			: `\n\nPrechecks you can attach with precheck on schedule_create or schedule_update; the host runs one before each turn and wakes you only when it finds something:\n${all.map((p) => `- ${p.name}: ${p.description.replace(/\n/g, " ")}`).join("\n")}`;
-	if (!runner) return named;
-	// The list still answers when the host cannot say, or is slow to say, what a script may reach here.
-	let timer: ReturnType<typeof setTimeout> | undefined;
-	const late = new Promise<string>((resolve) => {
-		timer = setTimeout(
-			() => resolve("it did not answer in time"),
-			DESCRIBE_TIMEOUT_MS,
-		);
-	});
-	const described = Promise.resolve()
-		.then(() =>
-			runner.describe({
-				channel: ctx.channel,
-				target: ctx.target.name,
-				tier: ctx.author.tier,
-			}),
-		)
-		.then(
-			(text) => ({ text }),
-			(error: unknown) => ({
-				error: error instanceof Error ? error.message : String(error),
-			}),
-		);
-	const answer = await Promise.race([
-		described,
-		late.then((error) => ({ error })),
-	]).finally(() => clearTimeout(timer));
-	const guide =
-		"text" in answer
-			? answer.text
-			: `The host could not say what a script may call here (${answer.error}); a script set now may fail when it runs.`;
-	return `${named}\n\nYou can write a precheck of your own instead, with precheck_script on schedule_create or schedule_update (null removes it): a JavaScript module, at most ${PRECHECK_SCRIPT_CHARS} characters, that the host runs in a sandbox before each turn. A schedule has a precheck or a precheck_script, not both.\n${guide}`;
-}
-
 function hasTiming(input: Input): boolean {
 	return [
 		"in_minutes",
@@ -225,7 +185,7 @@ function timing(ctx: ScheduleToolContext, input: Input): [Recurrence, Date] {
 	return [recurrence, next];
 }
 
-function line(schedule: Schedule): string {
+function line(schedule: Schedule, where?: ChannelKey): string {
 	const prompt =
 		schedule.prompt.length > LIST_PROMPT_PREVIEW
 			? `${schedule.prompt.slice(0, LIST_PROMPT_PREVIEW)}…`
@@ -235,10 +195,12 @@ function line(schedule: Schedule): string {
 		: schedule.precheckScript
 			? `; precheck script (${schedule.precheckScript.length} characters; tools: ${toolsText(schedule.precheckTools)})`
 			: "";
+	const limit = timeLimitText(schedule.timeLimitMinutes);
 	const last = schedule.lastRun
 		? `; last run ${zonedStamp(schedule.lastRun)} (${schedule.lastStatus ?? "?"})`
 		: "";
-	return `- #${schedule.id} ${schedule.title}: ${describeRecurrence(schedule.recurrence)}, next ${zonedStamp(schedule.nextRun)}; set by ${schedule.createdByName}${precheck}${last}\n  ${prompt.replace(/\n/g, " ")}`;
+	const fires = where ? `; fires in ${where}` : "";
+	return `- #${schedule.id} ${schedule.title}: ${describeRecurrence(schedule.recurrence)}, next ${zonedStamp(schedule.nextRun)}${fires}; set by ${schedule.createdByName}${precheck}${limit}${last}\n  ${prompt.replace(/\n/g, " ")}`;
 }
 
 /** The principal who created a schedule. */
@@ -262,11 +224,15 @@ async function visible(
 	);
 }
 
+/** The conversations whose schedules the asker reaches. */
+const scopeOf = (ctx: ScheduleToolContext): readonly ChannelKey[] =>
+	ctx.channels ?? [ctx.channel];
+
 async function own(ctx: ScheduleToolContext, input: Input): Promise<Schedule> {
 	const schedule = await ctx.store.get(id(input));
 	if (
 		!schedule ||
-		schedule.channel !== ctx.channel ||
+		!scopeOf(ctx).includes(schedule.channel) ||
 		!(await visible(ctx, schedule))
 	)
 		throw new ScheduleError(
@@ -368,6 +334,8 @@ export async function callScheduleTool(
 			const script = given("precheck_script")
 				? precheckScript(ctx, input.precheck_script)
 				: undefined;
+			const timeLimitMinutes =
+				timeLimitInput(input.time_limit_minutes) ?? undefined;
 			const existing = await ctx.store.forChannel(ctx.channel);
 			if (existing.length >= limits.perChannel)
 				throw new ScheduleError(
@@ -384,6 +352,7 @@ export async function callScheduleTool(
 				createdByName: ctx.author.name,
 				createdTier: ctx.author.tier,
 				...(precheck ? { precheck } : {}),
+				...(timeLimitMinutes ? { timeLimitMinutes } : {}),
 				...(script
 					? { precheckScript: script.script, precheckTools: script.tools }
 					: {}),
@@ -393,7 +362,7 @@ export async function callScheduleTool(
 				: script
 					? "; its precheck script runs first"
 					: "";
-			return `Scheduled #${made.id} "${title}": ${describeRecurrence(recurrence)}, first run ${zonedStamp(next)} ${messages().zoneTime(timeZone())}${checked}.`;
+			return `Scheduled #${made.id} "${title}": ${describeRecurrence(recurrence)}, first run ${zonedStamp(next)} ${messages().zoneTime(timeZone())}${checked}${timeLimitText(made.timeLimitMinutes)}.`;
 		}
 		case "schedule_list": {
 			if (input.id !== undefined) {
@@ -404,12 +373,18 @@ export async function callScheduleTool(
 				return `${line(schedule).split("\n")[0]}\n\nPrompt:\n${schedule.prompt}${script}`;
 			}
 			const all: Schedule[] = [];
-			for (const schedule of await ctx.store.forChannel(ctx.channel))
-				if (await visible(ctx, schedule)) all.push(schedule);
+			for (const channel of scopeOf(ctx))
+				for (const schedule of await ctx.store.forChannel(channel))
+					if (await visible(ctx, schedule)) all.push(schedule);
+			// Across several conversations each line says where it fires.
+			const across = scopeOf(ctx).length > 1;
+			if (across) all.sort((a, b) => a.nextRun.getTime() - b.nextRun.getTime());
 			const listed =
 				all.length === 0
-					? "This channel has no schedules."
-					: `It is ${zonedStamp(ctx.now)} in ${messages().zoneName(timeZone())}.\n${all.map(line).join("\n")}`;
+					? across
+						? "You have no schedules in any of your conversations."
+						: "This channel has no schedules."
+					: `It is ${zonedStamp(ctx.now)} in ${messages().zoneName(timeZone())}.\n${all.map((s) => line(s, across ? s.channel : undefined)).join("\n")}`;
 			return `${listed}${await precheckCatalog(ctx)}`;
 		}
 		case "schedule_update": {
@@ -442,25 +417,31 @@ export async function callScheduleTool(
 				change.precheckScript = script.script;
 				change.precheckTools = script.tools;
 			}
+			const timeLimit = timeLimitInput(input.time_limit_minutes);
+			if (timeLimit !== undefined) change.timeLimitMinutes = timeLimit;
 			if (change.precheck) change.precheckScript = null;
 			if (change.precheckScript) change.precheck = null;
 			if (Object.keys(change).length === 0)
 				throw new ScheduleError(
-					"give a title, prompt, timing, precheck, or precheck_script to change",
+					"give a title, prompt, timing, precheck, precheck_script, or time_limit_minutes to change",
 				);
-			const updated = await ctx.store.update(ctx.channel, schedule.id, change);
+			const updated = await ctx.store.update(
+				schedule.channel,
+				schedule.id,
+				change,
+			);
 			if (!updated) throw new ScheduleError(`schedule #${schedule.id} is gone`);
 			const checked = updated.precheck
 				? `; precheck ${updated.precheck} runs first`
 				: updated.precheckScript
 					? "; its precheck script runs first"
 					: "";
-			return `Updated #${updated.id} "${updated.title}": ${describeRecurrence(updated.recurrence)}, next run ${zonedStamp(updated.nextRun)}${checked}.`;
+			return `Updated #${updated.id} "${updated.title}": ${describeRecurrence(updated.recurrence)}, next run ${zonedStamp(updated.nextRun)}${checked}${timeLimitText(updated.timeLimitMinutes)}.`;
 		}
 		case "schedule_cancel": {
 			notTheHost(ctx, "cancel no schedules; ask the owner to cancel it");
 			const schedule = changeable(ctx, await own(ctx, input));
-			await ctx.store.remove(schedule.id, ctx.channel);
+			await ctx.store.remove(schedule.id, schedule.channel);
 			return `Cancelled #${schedule.id} "${schedule.title}".`;
 		}
 		default:
@@ -468,28 +449,4 @@ export async function callScheduleTool(
 	}
 }
 
-/** What the schedule's precheck found, or how it failed, under its own heading after the task. */
-function findingText(finding: PrecheckFinding): string[] {
-	return "error" in finding
-		? [
-				"",
-				`### Precheck failed: ${finding.precheck}`,
-				`The precheck that decides whether this task needs you failed, so you were woken anyway: ${finding.error}. Check what it watches yourself, and say so if it needs fixing.`,
-			]
-		: ["", `### Precheck found (${finding.precheck}):`, finding.context];
-}
-
-/** What a scheduled run receives as its message, with what its precheck found when it has one. */
-export function scheduledTurnText(
-	schedule: Schedule,
-	firedAt: Date,
-	finding?: PrecheckFinding,
-): string {
-	return [
-		`## Scheduled task #${schedule.id}: ${schedule.title}`,
-		`${schedule.createdByName} set this schedule (${describeRecurrence(schedule.recurrence)}). It is due now, ${zonedStamp(firedAt)} ${messages().zoneTime(timeZone())}. Nobody wrote a new message: carry out the task below and write what you would post in this channel. If the task keeps a record for later runs, update it with schedule_update on #${schedule.id}.`,
-		"",
-		schedule.prompt,
-		...(finding ? findingText(finding) : []),
-	].join("\n");
-}
+export { scheduledTurnText } from "./scheduled-turn-text.ts";

package/src/core/modules/schedules/scheduled-turn-text.ts

@@ -0,0 +1,31 @@
+import { messages } from "../../i18n/index.ts";
+import { timeZone, zonedStamp } from "../../time.ts";
+import type { PrecheckFinding } from "./prechecks.ts";
+import { describeRecurrence } from "./recurrence.ts";
+import type { Schedule } from "./schedule-store.ts";
+
+/** What the schedule's precheck found, or how it failed, under its own heading after the task. */
+function findingText(finding: PrecheckFinding): string[] {
+	return "error" in finding
+		? [
+				"",
+				`### Precheck failed: ${finding.precheck}`,
+				`The precheck that decides whether this task needs you failed, so you were woken anyway: ${finding.error}. Check what it watches yourself, and say so if it needs fixing.`,
+			]
+		: ["", `### Precheck found (${finding.precheck}):`, finding.context];
+}
+
+/** What a scheduled run receives as its message, with what its precheck found when it has one. */
+export function scheduledTurnText(
+	schedule: Schedule,
+	firedAt: Date,
+	finding?: PrecheckFinding,
+): string {
+	return [
+		`## Scheduled task #${schedule.id}: ${schedule.title}`,
+		`${schedule.createdByName} set this schedule (${describeRecurrence(schedule.recurrence)}). It is due now, ${zonedStamp(firedAt)} ${messages().zoneTime(timeZone())}. Nobody wrote a new message: carry out the task below and write what you would post in this channel. If the task keeps a record for later runs, update it with schedule_update on #${schedule.id}.`,
+		"",
+		schedule.prompt,
+		...(finding ? findingText(finding) : []),
+	].join("\n");
+}

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

@@ -68,6 +68,18 @@ function withAgentOption(spec: ScheduleToolSpec): ScheduleToolSpec {
 	};
 }
 
+/** The tools that reach every one of an agent's conversations say so, since they read "this channel's" otherwise. */
+function withAgentScope(spec: ScheduleToolSpec): ScheduleToolSpec {
+	if (
+		!["schedule_list", "schedule_update", "schedule_cancel"].includes(spec.name)
+	)
+		return spec;
+	return {
+		...spec,
+		description: `${spec.description} As an agent you reach all your own schedules, whichever of your conversations (Discord, the web app) they were made in; schedule_list says where each fires. A new schedule belongs to the conversation you are in.`,
+	};
+}
+
 /**
  * Registers the schedule tools for one conversation; a schedule's runs speak for the person whose
  * turn set it up, and in a turn nobody is named for the tools refuse. With `agents`,
@@ -79,6 +91,11 @@ export function schedulesExtension(
 	agents?: AgentChannelLookup,
 	/** The person the running turn is for; their schedules run at their tier. */
 	speaker: () => Speaker | undefined = () => undefined,
+	/**
+	 * An agent's conversations, asked when a tool runs: its schedules in all of them are listed,
+	 * changed, and cancelled, `channel`'s among them; without it, `channel`'s alone.
+	 */
+	conversations?: () => readonly ChannelKey[],
 ): ExtensionFactory {
 	const {
 		store,
@@ -94,7 +111,8 @@ export function schedulesExtension(
 		timeZone: timeZone(),
 		precheckScripts: prechecks?.scriptRunner?.() !== undefined,
 	}).map((base) => {
-		const spec = agents ? withAgentOption(base) : base;
+		const named = agents ? withAgentOption(base) : base;
+		const spec = conversations ? withAgentScope(named) : named;
 		return {
 			...spec,
 			run: async (input: ToolInput) => {
@@ -104,14 +122,20 @@ export function schedulesExtension(
 						"schedules are kept only in a turn someone is named for, whose schedules they are",
 					);
 				const peer =
-					agents && typeof input.agent === "string" && input.agent
+					spec.name === "schedule_list" &&
+					agents &&
+					typeof input.agent === "string" &&
+					input.agent
 						? agents(input.agent, channel)
 						: undefined;
 				const target = peer ?? (await channelFor(channel, author.principalId));
+				// Another agent's schedules are read in its one channel; an agent's own span its conversations.
+				const own = peer ? undefined : conversations?.();
 				const answer = await callScheduleTool(
 					{
 						store,
 						channel: target,
+						...(own ? { channels: [...new Set([target, ...own])] } : {}),
 						target: kept,
 						author: {
 							principalId: author.principalId,

package/src/core/modules/schedules/time-limit.ts

@@ -0,0 +1,27 @@
+import { ScheduleError } from "../../domain/errors.ts";
+import { MAX_SCHEDULE_TIME_LIMIT_MINUTES } from "../../shared/schedule-tools.ts";
+
+/**
+ * A schedule's time limit from a tool's input: undefined when it names none, null when it asks
+ * for the runtime's default again, else whole minutes within the schedule limit's maximum.
+ */
+export function timeLimitInput(value: unknown): number | null | undefined {
+	if (value === undefined || value === null) return value;
+	if (
+		typeof value !== "number" ||
+		!Number.isInteger(value) ||
+		value < 1 ||
+		value > MAX_SCHEDULE_TIME_LIMIT_MINUTES
+	)
+		throw new ScheduleError(
+			`time_limit_minutes must be a whole number of minutes from 1 to ${MAX_SCHEDULE_TIME_LIMIT_MINUTES}`,
+		);
+	return value;
+}
+
+/** The time limit as the schedule's lines and replies say it; empty for the default. */
+export function timeLimitText(minutes: number | undefined): string {
+	return minutes === undefined
+		? ""
+		: `; each run may work up to ${minutes} min`;
+}

package/src/core/presentation/reply-body.ts

@@ -23,3 +23,11 @@ export function replyBody(result: TurnResult): {
 		...(result.files?.length ? { files: result.files } : {}),
 	};
 }
+
+/**
+ * Whether a turn ended with nothing to post: an unattended turn, such as a schedule's, that had
+ * nothing to say. It is no failure and shows no notice.
+ */
+export function isQuiet(result: TurnResult): boolean {
+	return result.ok && !result.text.trim() && !result.files?.length;
+}

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

@@ -13,7 +13,7 @@ import { HostStoppingError, PluginError } from "../errors.ts";
 import { SYSTEM_PRINCIPAL } from "../identity/principal-store.ts";
 import type { Logger } from "../log.ts";
 import type { EventSink } from "../plugin.ts";
-import { replyBody } from "../presentation/reply-body.ts";
+import { isQuiet, replyBody } from "../presentation/reply-body.ts";
 import { withReplyFiles } from "../reply-files.ts";
 import type { ChannelKey, ToolSelection, TurnSelection } from "../sessions.ts";
 import type { Speaker } from "../speakers.ts";
@@ -45,8 +45,17 @@ export interface ConversationTurnInput {
 	selection?: TurnSelection;
 	/** The owner's own chat turn, which their next messages may steer. */
 	steerable?: boolean;
+	/** The speaker's message started the turn (not a schedule or report): it may spend a late approval. */
+	byMessage?: boolean;
 	/** The turn may ask the owner on the surface's prompts, such as approvals of held actions. */
 	interactive?: boolean;
+	/**
+	 * No person waits on the answer, as for a schedule's turn: an empty final answer then ends the
+	 * turn quietly, with nothing posted and `reply` not called, instead of failing it.
+	 */
+	unattended?: boolean;
+	/** How long the turn may work, in ms, in place of the runtime's default; a schedule's own limit. */
+	timeLimitMs?: number;
 	/**
 	 * The speaker confirmed the channel's held actions, so they may run in this turn, except those
 	 * that named approvers the speaker is neither among nor an owner of, which stay held.
@@ -205,7 +214,12 @@ export function conversationTurns(
 									: {}),
 								...(input.confirmed ? { confirmed: true } : {}),
 								...(input.steerable ? { steerable: true } : {}),
+								...(input.byMessage ? { byMessage: true } : {}),
 								...(input.interactive ? { interactive: true } : {}),
+								...(input.unattended ? { unattended: true } : {}),
+								...(input.timeLimitMs === undefined
+									? {}
+									: { timeLimitMs: input.timeLimitMs }),
 								...(interim ? { interim } : {}),
 								progress,
 							}),
@@ -223,7 +237,12 @@ export function conversationTurns(
 			try {
 				if (!result.ok && !result.stopped)
 					logger.error({ channel, kind, err: result.error }, "turn failed");
-				if (input.reply) await input.reply(result);
+				if (isQuiet(result))
+					logger.info(
+						{ channel, kind },
+						"unattended turn had nothing to say; nothing posted",
+					);
+				else if (input.reply) await input.reply(result);
 				else await surfaces.sendReply(channel, replyBody(result));
 			} catch (error) {
 				logger.error({ channel, kind, err: error }, "reply not posted");

package/src/core/runtime/extensions/ask-user.ts

@@ -87,7 +87,7 @@ export function askUserExtension(
 				const prompts = slot.prompts;
 				if (!prompts)
 					return toolText(
-						`${o.name} cannot answer buttons in this turn, such as a schedule's. Ask ${o.him} in your reply instead.`,
+						`${o.name} cannot answer buttons in this turn: no one wrote to you, a schedule or another agent started it, so nothing waits. Do not call ask_user again. Write the question as your final answer instead; it is posted to this channel for ${o.him} to read, and ${o.his} answer comes in a new turn.`,
 					);
 				const p = params as {
 					questions: {