pi-roundtable 0.9.3 → 0.9.5

package/src/core/discord/owner-cards.ts

@@ -4,13 +4,8 @@ import {
 	ButtonBuilder,
 	ButtonStyle,
 	type Interaction,
-	LabelBuilder,
 	MessageFlags,
-	ModalBuilder,
-	StringSelectMenuBuilder,
 	TextDisplayBuilder,
-	TextInputBuilder,
-	TextInputStyle,
 } from "discord.js";
 import { parseChannelKey } from "../contract/surface.ts";
 import type { ChannelKey } from "../domain/conversation.ts";
@@ -21,6 +16,7 @@ import type {
 	OwnerQuestion,
 	PromptScope,
 	Prompts,
+	PromptWait,
 } from "../interactions/prompts.ts";
 import type { Logger } from "../log.ts";
 import {
@@ -28,15 +24,26 @@ import {
 	type CardAudienceOptions,
 	CardAudiences,
 } from "./card-audience.ts";
-import { DiscordOwners, discordUser } from "./discord-owners.ts";
+import {
+	DiscordOwners,
+	type DiscordUser,
+	discordUser,
+} from "./discord-owners.ts";
 import type { InteractionModule } from "./interaction-module.ts";
-import { ownerPanel, type PanelContent, plain } from "./owner-panel.ts";
+import {
+	answeredLine,
+	answerModal,
+	askRows,
+	CARD_PREFIX,
+	OTHER,
+	type Rows,
+	TEXT_FIELD,
+} from "./owner-card-rows.ts";
+import { ownerPanel, type PanelContent } from "./owner-panel.ts";
 
-export const CARD_PREFIX = "roundtable:card:";
-/** An unanswered card expires after this long. */
-export const CARD_TIMEOUT_MS = 30 * 60_000;
-const OTHER = "other";
-const TEXT_FIELD = "text";
+export { CARD_PREFIX };
+/** How long a turn that can be resumed waits on its card before it goes on without the answer. */
+export const CARD_GRACE_MS = 2 * 60_000;
 
 /** A card's message: the panel, led in a thread by a mention of those it is for. */
 export type CardPayload = Omit<
@@ -73,11 +80,38 @@ export interface OwnerCardsOptions {
 	/** The Discord channel by id; throws when it cannot take messages. */
 	channel(channelId: string): Promise<CardChannel>;
 	logger: Logger;
-	/** CARD_TIMEOUT_MS by default. */
-	timeoutMs?: number;
+	/**
+	 * How long a turn that gives a `PromptWait` waits on its card; `CARD_GRACE_MS` (two minutes)
+	 * by default. The card stays open after it, for as long as the process runs.
+	 */
+	graceMs?: number;
+	/**
+	 * Starts a turn in a card's channel with a late answer's text, as a message from whoever
+	 * answered. Without it no turn stops waiting on its cards.
+	 */
+	resume?(turn: LateTurn): void;
 }
 
-type Rows = NonNullable<Parameters<typeof ownerPanel>[0]["rows"]>;
+/** A turn a card answered after its turn stopped waiting starts, as a message in its channel. */
+export interface LateTurn {
+	channelId: string;
+	/** The card's message, which the turn's message stands for. */
+	messageId: string;
+	/** Who answered. */
+	user: DiscordUser;
+	/** The server the channel belongs to; absent in a direct message. */
+	guildId?: string;
+	isDirect: boolean;
+	text: string;
+}
+
+/** Where and by whom a card was answered. */
+interface Answerer {
+	user: DiscordUser;
+	messageId?: string;
+	guildId?: string;
+	isDirect: boolean;
+}
 
 /** One open card: how it looks, and how it ends. */
 interface OpenCard {
@@ -85,8 +119,11 @@ interface OpenCard {
 	sections: string[];
 	/** The card's controls, disabled once it has ended. */
 	rows(disabled: boolean): Rows;
-	/** Ends the card with its answer; the answering interaction shows the outcome. */
-	end(value: unknown): void;
+	/**
+	 * Ends the card with its answer; the answering interaction shows the outcome. A card whose
+	 * turn stopped waiting starts a turn with the answer instead.
+	 */
+	end(value: unknown, by: Answerer): void;
 	question?: OwnerQuestion;
 	/** Options chosen together with "Other…", kept while its form is open. */
 	picked?: string[];
@@ -100,9 +137,11 @@ interface OpenCard {
  * The cards in the assistant's channels: approvals of held actions and ask_user questions,
  * answered with buttons, a menu, or a form, by those the turn's prompt scope names (see
  * `CardAudiences`): the speaker whose turn asks, when the card allows (a question always; an
- * approval at its tier), and, in a shared conversation, the owners. An unanswered card expires
- * after 30 minutes and a stopped turn cancels it. Open cards live in memory, so a restart
- * abandons them; pressing one then says it no longer works.
+ * approval at its tier), and, in a shared conversation, the owners. A turn that can be resumed
+ * (it gives a `PromptWait`) waits on its card for the grace period, then goes on without the
+ * answer while the card stays open; answered later, the card starts a turn in its channel with
+ * the answer. Other cards wait for their answer. A stopped turn cancels a card it still waits on.
+ * Open cards live in memory, so a restart abandons them; pressing one then says to ask again.
  */
 export class OwnerCards implements InteractionModule {
 	readonly #options: OwnerCardsOptions;
@@ -125,12 +164,25 @@ export class OwnerCards implements InteractionModule {
 	prompts(channel: ChannelKey, scope?: PromptScope): Prompts | undefined {
 		const channelId = parseChannelKey(channel).id;
 		return {
-			confirm: async (title, message, signal, minTier = "owner") => {
+			confirm: async (title, message, signal, minTier = "owner", wait) => {
 				const audience = await this.#audiences.approval(scope, minTier);
 				// A private conversation's call above its person's tier is no one's to approve.
 				if (!audience) return "expired";
 				return this.#post<Approval>(channelId, signal, "expired", "cancelled", {
 					audience,
+					...(wait
+						? {
+								wait: {
+									pending: "pending",
+									late: (value, by) =>
+										wait.late({
+											kind: "approval",
+											approved: value === "approved",
+											by,
+										}),
+								},
+							}
+						: {}),
 					title,
 					sections: [message],
 					rows: (id, disabled) => [
@@ -152,16 +204,29 @@ export class OwnerCards implements InteractionModule {
 					footer: messages().cardApprovalFooter,
 				});
 			},
-			ask: async (title, question, signal) => {
+			ask: async (title, question, signal, wait) => {
 				const audience = await this.#audiences.question(scope);
 				if (!audience) return undefined;
-				return this.#post<OwnerAnswer | undefined>(
+				return this.#post<OwnerAnswer | "pending" | undefined>(
 					channelId,
 					signal,
 					undefined,
 					undefined,
 					{
 						audience,
+						...(wait
+							? {
+									wait: {
+										pending: "pending",
+										late: (value, by) =>
+											wait.late({
+												kind: "question",
+												answer: value as OwnerAnswer,
+												by,
+											}),
+									},
+								}
+							: {}),
 						title,
 						sections: [question.question],
 						question,
@@ -173,7 +238,10 @@ export class OwnerCards implements InteractionModule {
 		};
 	}
 
-	/** Posts a card and resolves with its answer, `expired`, or `cancelled`. */
+	/**
+	 * Posts a card and resolves with its answer, `expired` when it could not be posted, or
+	 * `cancelled`; with `wait`, and a way to resume, `wait.pending` once the grace period passes.
+	 */
 	#post<T>(
 		channelId: string,
 		signal: AbortSignal | undefined,
@@ -186,10 +254,15 @@ export class OwnerCards implements InteractionModule {
 			question?: OwnerQuestion;
 			rows(id: string, disabled: boolean): Rows;
 			footer: string;
+			wait?: {
+				pending: T;
+				late(value: unknown, by: string): ReturnType<PromptWait["late"]>;
+			};
 		},
 	): Promise<T> {
-		const { logger, timeoutMs = CARD_TIMEOUT_MS } = this.#options;
+		const { logger, graceMs = CARD_GRACE_MS, resume } = this.#options;
 		if (signal?.aborted) return Promise.resolve(cancelled);
+		const wait = resume ? card.wait : undefined;
 		const id = randomUUID();
 		const sections = [
 			...card.sections,
@@ -198,10 +271,13 @@ export class OwnerCards implements InteractionModule {
 		return new Promise<T>((resolve) => {
 			let message: CardMessage | undefined;
 			let finish: string | undefined;
+			/** The turn went on without the answer; the card is the conversation's now. */
+			let late = false;
 			const settle = (value: T, outcome: string | undefined) => {
 				if (!this.#open.delete(id)) return;
 				clearTimeout(timer);
 				signal?.removeEventListener("abort", abort);
+				if (late) return;
 				// A card ended by an answer is edited by the answering interaction.
 				if (outcome !== undefined) {
 					finish = outcome;
@@ -225,17 +301,39 @@ export class OwnerCards implements InteractionModule {
 					card.audience.mentions,
 				);
 			const abort = () => settle(cancelled, messages().cardStopped);
-			const timer = setTimeout(
-				() => settle(expired, messages().cardExpired),
-				timeoutMs,
-			);
+			const timer = wait
+				? setTimeout(() => {
+						if (!this.#open.has(id)) return;
+						late = true;
+						signal?.removeEventListener("abort", abort);
+						resolve(wait.pending);
+					}, graceMs)
+				: undefined;
 			signal?.addEventListener("abort", abort, { once: true });
 			const open: OpenCard = {
 				title: card.title,
 				sections,
 				rows: (disabled) => card.rows(id, disabled),
 				audience: card.audience,
-				end: (value) => settle(value as T, undefined),
+				end: (value, by) => {
+					const answeredLate = late;
+					settle(value as T, undefined);
+					if (!answeredLate || !wait || !resume) return;
+					try {
+						const text = wait.late(value, by.user.name);
+						if (text === undefined) return;
+						resume({
+							channelId,
+							messageId: by.messageId ?? `card-${id}`,
+							user: by.user,
+							...(by.guildId ? { guildId: by.guildId } : {}),
+							isDirect: by.isDirect,
+							text,
+						});
+					} catch (error) {
+						logger.warn({ channelId, err: error }, "late card answer lost");
+					}
+				},
 				...(card.question ? { question: card.question } : {}),
 			};
 			this.#open.set(id, open);
@@ -299,6 +397,12 @@ export class OwnerCards implements InteractionModule {
 			return true;
 		}
 		const user = discordUser(interaction);
+		const by: Answerer = {
+			user,
+			...(interaction.message ? { messageId: interaction.message.id } : {}),
+			...(interaction.guildId ? { guildId: interaction.guildId } : {}),
+			isDirect: !interaction.inGuild(),
+		};
 		if (!(await card.audience.allows(user))) {
 			await interaction.reply({
 				content: card.audience.refusal,
@@ -319,7 +423,7 @@ export class OwnerCards implements InteractionModule {
 			);
 		if (interaction.isButton() && (action === "yes" || action === "no")) {
 			const approved = action === "yes";
-			card.end(approved ? "approved" : "declined");
+			card.end(approved ? "approved" : "declined", by);
 			await interaction.update(
 				closed(approved ? messages().cardApproved : messages().cardDeclined),
 			);
@@ -343,7 +447,7 @@ export class OwnerCards implements InteractionModule {
 				return true;
 			}
 			const answer = { choices };
-			card.end(answer);
+			card.end(answer, by);
 			await interaction.update(closed(answeredLine(answer)));
 			return true;
 		}
@@ -352,7 +456,7 @@ export class OwnerCards implements InteractionModule {
 				choices: card.picked ?? [],
 				text: interaction.fields.getTextInputValue(TEXT_FIELD),
 			};
-			card.end(answer);
+			card.end(answer, by);
 			if (interaction.isFromMessage())
 				await interaction.update(closed(answeredLine(answer)));
 			else await interaction.deferUpdate();
@@ -361,75 +465,3 @@ export class OwnerCards implements InteractionModule {
 		return true;
 	}
 }
-
-/** A question's controls: a menu of its options, or a button that opens the answer form. */
-function askRows(id: string, question: OwnerQuestion, disabled: boolean): Rows {
-	if (question.options.length === 0)
-		return [
-			new ActionRowBuilder<ButtonBuilder>().addComponents(
-				new ButtonBuilder()
-					.setCustomId(`${CARD_PREFIX}${id}:write`)
-					.setLabel(messages().cardAnswerLabel)
-					.setStyle(ButtonStyle.Primary)
-					.setDisabled(disabled),
-			),
-		];
-	// Discord menus take 25 options; "Other…" takes the last place when the options fill it.
-	const options = question.options
-		.slice(0, question.allowOther ? 24 : 25)
-		.map((option, i) => ({
-			label: option.label.slice(0, 100),
-			value: String(i),
-			...(option.description
-				? { description: option.description.slice(0, 100) }
-				: {}),
-		}));
-	if (question.allowOther)
-		options.push({
-			label: messages().cardOtherLabel,
-			value: OTHER,
-			description: messages().cardOtherDescription,
-		});
-	return [
-		new ActionRowBuilder<StringSelectMenuBuilder>().addComponents(
-			new StringSelectMenuBuilder()
-				.setCustomId(`${CARD_PREFIX}${id}:pick`)
-				.setPlaceholder(
-					question.multi
-						? messages().cardPickManyPlaceholder
-						: messages().cardPickOnePlaceholder,
-				)
-				.setMinValues(1)
-				.setMaxValues(question.multi ? options.length : 1)
-				.addOptions(options)
-				.setDisabled(disabled),
-		),
-	];
-}
-
-function answerModal(id: string): ModalBuilder {
-	return new ModalBuilder()
-		.setCustomId(`${CARD_PREFIX}${id}:text`)
-		.setTitle(messages().cardModalTitle)
-		.addLabelComponents(
-			new LabelBuilder()
-				.setLabel(messages().cardModalField)
-				.setTextInputComponent(
-					new TextInputBuilder()
-						.setCustomId(TEXT_FIELD)
-						.setStyle(TextInputStyle.Paragraph)
-						.setRequired(true)
-						.setMaxLength(1000),
-				),
-		);
-}
-
-function answeredLine(answer: OwnerAnswer): string {
-	const parts = [
-		...answer.choices.map(plain),
-		...(answer.text !== undefined
-			? [messages().cardQuote(plain(answer.text))]
-			: []),
-	];
-	return messages().cardAnswered(parts);
-}

package/src/core/host.ts

@@ -55,6 +55,8 @@ export interface HostEnvironment {
 	rootCommand?: string;
 	/** Exported as `PI_CODING_AGENT_DIR` for Pi packages such as pi-web-access; unset leaves the process's own. */
 	agentDir?: string;
+	/** The host's scratch dir, which plugins read as `env.scratchDir`; unset gives them none. */
+	scratchDir?: string;
 }
 
 export interface RoundtableOptions {
@@ -245,12 +247,18 @@ export class Roundtable {
 			assistant = "Roundtable",
 			rootCommand = "roundtable",
 			agentDir,
+			scratchDir,
 		} = this.#options.environment ?? {};
 		setLocale(locale, { assistant, root: rootCommand });
 		setTimeZone(timeZone);
 		// Pi packages such as pi-web-access read their config from the Pi agent directory.
 		if (agentDir !== undefined) process.env.PI_CODING_AGENT_DIR = agentDir;
-		return { locale, timeZone, now: () => new Date() };
+		return {
+			locale,
+			timeZone,
+			now: () => new Date(),
+			...(scratchDir !== undefined ? { scratchDir } : {}),
+		};
 	}
 
 	async #boot(): Promise<void> {

package/src/core/i18n/cards.ts

@@ -6,10 +6,9 @@ export function cardsEn(ctx: CatalogContext) {
 		cardRunLabel: "Run",
 		cardCancelLabel: "Cancel",
 		cardApprovalFooter:
-			"If nobody answers within 30 minutes, it falls back to waiting for your confirmation in text.",
-		cardQuestionFooter: "Valid for 30 minutes.",
+			"Nothing runs until you approve; answer whenever you are ready.",
+		cardQuestionFooter: "Answer whenever you are ready.",
 		cardStopped: "⏹️ This round was stopped.",
-		cardExpired: "⌛ Timed out with no answer.",
 		cardOwnerOnly: `Only ${ctx.assistant}'s owner can answer this card.`,
 		cardApproversNote: (...userIds: readonly string[]) =>
 			`-# Who can approve: ${userIds.map((id) => `<@${id}>`).join(" ")}`,
@@ -18,7 +17,7 @@ export function cardsEn(ctx: CatalogContext) {
 		cardAskerNote: (...userIds: readonly string[]) =>
 			`-# Who can answer: ${userIds.map((id) => `<@${id}>`).join(" ")}`,
 		cardAskerRefusal: "This question is for another speaker.",
-		cardInactive: `This card is no longer active (it timed out, or ${ctx.assistant} restarted); reply in text if you need to.`,
+		cardInactive: `This card is no longer valid (${ctx.assistant} restarted since it was posted, or it was already answered); ask again, or reply in text.`,
 		cardApproved: "✅ Approved to run.",
 		cardDeclined: "❌ Cancelled.",
 		cardAnswerLabel: "Answer…",
@@ -38,10 +37,9 @@ export function cardsZhTW(ctx: CatalogContext): ReturnType<typeof cardsEn> {
 	return {
 		cardRunLabel: "執行",
 		cardCancelLabel: "取消",
-		cardApprovalFooter: "30 分鐘內沒回覆，就改成等你用文字確認。",
-		cardQuestionFooter: "30 分鐘內有效。",
+		cardApprovalFooter: "你核准之前不會執行；準備好再回覆就好。",
+		cardQuestionFooter: "準備好再回答就好。",
 		cardStopped: "⏹️ 這一輪已停止。",
-		cardExpired: "⌛ 已逾時，沒有回答。",
 		cardOwnerOnly: `只有 ${ctx.assistant} 的擁有者能回答這張卡片。`,
 		cardApproversNote: (...userIds: readonly string[]) =>
 			`-# 可以核准的人：${userIds.map((id) => `<@${id}>`).join(" ")}`,
@@ -49,7 +47,7 @@ export function cardsZhTW(ctx: CatalogContext): ReturnType<typeof cardsEn> {
 		cardAskerNote: (...userIds: readonly string[]) =>
 			`-# 可以回答的人：${userIds.map((id) => `<@${id}>`).join(" ")}`,
 		cardAskerRefusal: "這張問題是問另一位發話者的。",
-		cardInactive: `這張卡片已經失效（逾時，或 ${ctx.assistant} 重新啟動過）；需要的話直接打字回覆。`,
+		cardInactive: `這張卡片已經失效（${ctx.assistant} 在它發出後重新啟動過，或它已經回答過了）；請再問一次，或直接打字回覆。`,
 		cardApproved: "✅ 已核准執行。",
 		cardDeclined: "❌ 已取消。",
 		cardAnswerLabel: "回答…",

package/src/core/i18n/conversation.ts

@@ -1,5 +1,12 @@
 import type { CatalogContext } from "./types.ts";
 
+/** A size in B, KiB, or MiB. */
+function formatBytes(bytes: number): string {
+	if (bytes < 1024) return `${bytes} B`;
+	if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KiB`;
+	return `${(bytes / 1024 / 1024).toFixed(1)} MiB`;
+}
+
 /** Notices, thread lines, and titles a conversation posts on its own. */
 export function conversationEn(ctx: CatalogContext) {
 	return {
@@ -22,6 +29,10 @@ export function conversationEn(ctx: CatalogContext) {
 		thinkingAuto: "auto",
 		confirmTitle: (asker: string) => `${asker} wants to run this action`,
 		askTitle: (asker: string) => `${asker} has a question for you`,
+		cardFile: (path: string, bytes: number | undefined) =>
+			bytes === undefined
+				? `File \`${path}\` (not found now)`
+				: `File \`${path}\` (${formatBytes(bytes)})`,
 	};
 }
 
@@ -47,5 +58,9 @@ export function conversationZhTW(
 		thinkingAuto: "自動",
 		confirmTitle: (asker: string) => `${asker} 要執行這個動作`,
 		askTitle: (asker: string) => `${asker} 想問你`,
+		cardFile: (path: string, bytes: number | undefined) =>
+			bytes === undefined
+				? `檔案 \`${path}\`（目前找不到）`
+				: `檔案 \`${path}\`（${formatBytes(bytes)}）`,
 	};
 }

package/src/core/interactions/prompts.ts

@@ -3,10 +3,33 @@ import type { TurnRequest } from "../domain/ports.ts";
 import type { Speaker, Tier } from "../speakers.ts";
 
 /**
- * How a prompt ended: answered yes or no, unanswered until it expired, or cancelled when its turn
- * stopped.
+ * How a prompt ended: answered yes or no; `expired` when no one could answer it (no one's to
+ * approve, or the card could not be posted); `cancelled` when its turn stopped; or `pending` when
+ * the turn stopped waiting while the card stays open, its answer to come through `PromptWait`.
  */
-export type Approval = "approved" | "declined" | "expired" | "cancelled";
+export type Approval =
+	| "approved"
+	| "declined"
+	| "expired"
+	| "cancelled"
+	| "pending";
+
+/** An answer given on a prompt after its turn stopped waiting; `by` names who gave it. */
+export type LateAnswer = { by: string } & (
+	| { kind: "approval"; approved: boolean }
+	| { kind: "question"; answer: OwnerAnswer }
+);
+
+/**
+ * How a prompt may outlive its turn. Given, a surface may stop the turn's wait after a grace
+ * period, resolving `pending`, and keep the prompt open; an answer that comes later goes to
+ * `late`, and the surface starts a turn in the prompt's conversation with the text `late`
+ * returns, as a message from whoever answered (none when it returns undefined). Without it the
+ * prompt waits for its answer or its turn's stop.
+ */
+export interface PromptWait {
+	late(answer: LateAnswer): string | undefined;
+}
 
 export interface AskOption {
 	label: string;
@@ -64,27 +87,33 @@ export interface PromptScope {
 
 /**
  * Prompts inside a running turn, on its conversation's surface: an approval of a held action and an
- * `ask_user` question, answered by those its `PromptScope` names. Unanswered prompts expire; a
- * stopped turn cancels its open ones.
+ * `ask_user` question, answered by those its `PromptScope` names. A stopped turn cancels the ones
+ * it still waits on; with a `PromptWait`, a prompt may outlive the turn's wait (see there).
  */
 export interface Prompts {
 	/**
 	 * Asks to approve an action; `signal` cancels the prompt when the turn stops. `minTier` is the
 	 * tier the scope's speaker needs to approve it themselves, `owner` when absent; below it the
 	 * prompt goes to the owners, or, when the scope escalates to no one, resolves `expired` at once.
+	 * `pending` comes only with a `wait`.
 	 */
 	confirm(
 		title: string,
 		message: string,
 		signal?: AbortSignal,
 		minTier?: Tier,
+		wait?: PromptWait,
 	): Promise<Approval>;
-	/** Asks a question; undefined when it expired or was cancelled. */
+	/**
+	 * Asks a question; undefined when no one answered it or it was cancelled, and `pending`, only
+	 * with a `wait`, when the turn stopped waiting and the question stays open.
+	 */
 	ask(
 		title: string,
 		question: OwnerQuestion,
 		signal?: AbortSignal,
-	): Promise<OwnerAnswer | undefined>;
+		wait?: PromptWait,
+	): Promise<OwnerAnswer | "pending" | undefined>;
 }
 
 /** @deprecated Since 0.9 the prompts are `Prompts`, answered by those their `PromptScope` names; this name goes away in 1.0. */

package/src/core/modules/discord-admin/discord-admin.ts

@@ -1,8 +1,10 @@
 import type { ExtensionFactory } from "@earendil-works/pi-coding-agent";
 import { type TObject, Type } from "typebox";
+import { resolveChannelFiles } from "../../discord/channel-files.ts";
 import {
 	CHANNEL_TOOLS,
 	ChannelToolError,
+	SESSION_CHANNEL_TOOLS,
 } from "../../discord/channel-operations.ts";
 import { assistantName } from "../../i18n/index.ts";
 import {
@@ -11,6 +13,7 @@ import {
 	ownerWords,
 } from "../../identity.ts";
 import { textToolsExtension } from "../../runtime/text-tools.ts";
+import type { WorkspaceRoots } from "../../shared/workspace-files.ts";
 
 const id = Type.String({ pattern: "^\\d{1,20}$" });
 const guild = { guildId: id };
@@ -259,13 +262,18 @@ export interface OwnerOperations {
 	run(tool: string, args: Record<string, unknown>): Promise<unknown>;
 }
 
+/**
+ * The owner's Discord tools for one session. With `roots`, a file to send may name a path inside
+ * the session's workspace or scratch dir; without, files go inline only.
+ */
 export function discordAdminExtension(
 	discord: OwnerOperations,
 	owner: OwnerIdentity,
+	roots?: WorkspaceRoots,
 ): ExtensionFactory {
 	const o = ownerWords(owner);
 	const specs = [
-		...Object.entries(CHANNEL_TOOLS).map(([name, spec]) => ({
+		...Object.entries(SESSION_CHANNEL_TOOLS).map(([name, spec]) => ({
 			name,
 			label: name,
 			description: spec.description,
@@ -281,7 +289,13 @@ export function discordAdminExtension(
 	return textToolsExtension(
 		specs.map((spec) => ({
 			...spec,
-			run: async (input) => JSON.stringify(await discord.run(spec.name, input)),
+			run: async (input) =>
+				JSON.stringify(
+					await discord.run(
+						spec.name,
+						await resolveChannelFiles(spec.name, input, roots),
+					),
+				),
 		})),
 		ChannelToolError,
 	);

package/src/core/plugin.ts

@@ -271,6 +271,11 @@ export interface HostEnv {
 	readonly timeZone: string;
 	/** The current instant. */
 	now(): Date;
+	/**
+	 * The host's scratch dir, when it has one: the agents' TMPDIR, where writes and removals run
+	 * without a hold. Plugins that run shells of their own (coding workers) give it to them too.
+	 */
+	readonly scratchDir?: string;
 }
 
 /** What the host gives every plugin. */

package/src/core/runtime/conversation-sessions.ts

@@ -107,6 +107,8 @@ export class ConversationSessions {
 						}
 					: {},
 				this.#tiers,
+				// Owner sessions have no shell workspace but still send files from their own directory.
+				agents ? agents.workDir : this.#factory.cwd(undefined),
 			);
 			this.#gates.set(key, gate);
 			this.#restored.delete(key);