jeo-code 0.12.13 → 0.12.16

package/src/messenger/discord-setup.ts

@@ -1,14 +1,22 @@
 import * as fs from "node:fs/promises";
+import * as os from "node:os";
 import * as path from "node:path";
-import { loadMessengerConfig, resolveMessengerToken, validateMessengerEnvironment } from "./config";
+import { DEFAULT_MESSENGER_TOOLS, loadMessengerConfig, messengerProfilePrivatePaths, parseMessengerSandbox, resolveMessengerToken, validateMessengerEnvironment } from "./config";
 import { DISCORD_API, DISCORD_GATEWAY_INTENTS, discordGatewayUrl } from "./discord";
 import { MessengerHttpError, messengerFetchJson } from "./http";
 import { installMessengerService, messengerServicePlan } from "./service";
 import { isEnoent, isRecord } from "./types";
+import { jeoHomeDir, notifyDir, notifySessionsDir } from "../agent/notify/paths";
+import { createSandboxPolicy } from "../agent/sandbox/policy";
+import type { SandboxConfig } from "../agent/sandbox/types";
 
 export const DISCORD_TOKEN_ENV = "JEO_DISCORD_BOT_TOKEN";
 const TOKEN_FILE = "discord-token";
-const RUN_SCRIPT = "run-discord.sh";
+/** Fresh-setup workspace: a jeo-owned directory in the user's home, outside every sandbox-private root. */
+const WORKSPACE_DIR = "jeo-discord-workspace";
+const WORKSPACE_MARKER = ".jeo-workspace";
+const RUN_SCRIPT_POSIX = "run-discord.sh";
+const RUN_SCRIPT_WINDOWS = "run-discord.cmd";
 const MESSAGE_CONTENT = 1 << 18;
 const MESSAGE_CONTENT_LIMITED = 1 << 19;
 /** The only application flags a bot token may change: the limited presence, member, and message intents. */
@@ -32,6 +40,28 @@ const INVITE_POLL_MS = 3_000;
 const GATEWAY_PROBE_MS = 20_000;
 const DM_TEST_MESSAGE = "jeo messenger is set up for this bot. Reply here to test the connection.";
 
+function throwIfAborted(signal?: AbortSignal): void {
+	if (signal?.aborted) throw new Error("Discord setup cancelled");
+}
+
+async function interruptibleSleep(sleep: (ms: number) => Promise<void>, ms: number, signal?: AbortSignal): Promise<void> {
+	if (!signal) return sleep(ms);
+	if (signal.aborted) throw new Error("Discord setup cancelled");
+	let cancel: (() => void) | undefined;
+	try {
+		await Promise.race([
+			sleep(ms),
+			new Promise<never>((_resolve, reject) => {
+				cancel = () => reject(new Error("Discord setup cancelled"));
+				signal.addEventListener("abort", cancel, { once: true });
+				if (signal.aborted) cancel();
+			}),
+		]);
+	} finally {
+		if (cancel) signal.removeEventListener("abort", cancel);
+	}
+}
+
 export interface DiscordSetupIO {
 	readonly interactive: boolean;
 	say(line: string): void;
@@ -60,6 +90,11 @@ export interface DiscordSetupDeps {
 	/** argv that starts this jeo build; defaults to the running runtime and entry. */
 	jeoCommand?: string[];
 	installService?: typeof installMessengerService;
+	/** Cancels invite polling and the remaining setup work (the CLI wires Ctrl+C here). */
+	signal?: AbortSignal;
+	/** Injectable platform/path separator for cross-platform release tests. */
+	platform?: NodeJS.Platform;
+	pathDelimiter?: string;
 }
 
 export interface DiscordSetupResult {
@@ -89,18 +124,23 @@ export interface RequestChannel {
 
 type DiscordApiFn = (method: string, route: string, body?: unknown) => Promise<unknown>;
 
-function discordApi(token: string, fetchImpl: typeof fetch): DiscordApiFn {
-	return (method, route, body) =>
-		messengerFetchJson(
+function discordApi(token: string, fetchImpl: typeof fetch, signal?: AbortSignal): DiscordApiFn {
+	return async (method, route, body) => {
+		throwIfAborted(signal);
+		const result = await messengerFetchJson(
 			`${DISCORD_API}${route}`,
 			{
 				method,
+				signal,
 				headers: { Authorization: `Bot ${token}`, "Content-Type": "application/json" },
 				...(body === undefined ? {} : { body: JSON.stringify(body) }),
 			},
 			undefined,
 			fetchImpl,
 		);
+		throwIfAborted(signal);
+		return result;
+	};
 }
 
 function str(value: unknown): string | undefined {
@@ -201,15 +241,21 @@ export async function waitForDiscordGuilds(
 	io: DiscordSetupIO,
 	sleep: (ms: number) => Promise<void>,
 	waitMs: number,
+	signal?: AbortSignal,
 ): Promise<Record<string, unknown>[]> {
+	throwIfAborted(signal);
 	let guilds = records(await api("GET", "/users/@me/guilds"));
+	throwIfAborted(signal);
 	if (guilds.length) return guilds;
 	if (!io.interactive) throw new Error(`Invite the bot to a server, then rerun: ${inviteUrl}`);
 	io.say(`Invite the bot to your server (choose the server and authorize):\n  ${inviteUrl}`);
 	io.say("Waiting for the bot to join…");
 	for (const deadline = Date.now() + waitMs; Date.now() < deadline; ) {
-		await sleep(INVITE_POLL_MS);
+		throwIfAborted(signal);
+		await interruptibleSleep(sleep, Math.min(INVITE_POLL_MS, Math.max(0, deadline - Date.now())), signal);
+		throwIfAborted(signal);
 		guilds = records(await api("GET", "/users/@me/guilds"));
+		throwIfAborted(signal);
 		if (guilds.length) return guilds;
 	}
 	throw new Error(`The bot has not joined a server yet; invite it, then rerun: ${inviteUrl}`);
@@ -363,8 +409,11 @@ export async function probeDiscordGateway(
 	api: DiscordApiFn,
 	token: string,
 	WebSocketImpl: typeof WebSocket,
+	signal?: AbortSignal,
 ): Promise<void> {
+	throwIfAborted(signal);
 	const discovery = await api("GET", "/gateway/bot");
+	throwIfAborted(signal);
 	const url = discordGatewayUrl(isRecord(discovery) ? discovery.url : undefined);
 	const result = Promise.withResolvers<void>();
 	const socket = new WebSocketImpl(url);
@@ -372,7 +421,11 @@ export async function probeDiscordGateway(
 		() => result.reject(new Error("Discord Gateway did not confirm the bot session in time")),
 		GATEWAY_PROBE_MS,
 	);
+	const cancel = () => result.reject(new Error("Discord setup cancelled"));
+	signal?.addEventListener("abort", cancel, { once: true });
+	if (signal?.aborted) cancel();
 	socket.addEventListener("message", (event: MessageEvent) => {
+		if (signal?.aborted) return;
 		let packet: unknown;
 		try {
 			packet = typeof event.data === "string" ? JSON.parse(event.data) : undefined;
@@ -404,8 +457,10 @@ export async function probeDiscordGateway(
 	socket.addEventListener("error", () => result.reject(new Error("Discord Gateway connection failed")));
 	try {
 		await result.promise;
+		throwIfAborted(signal);
 	} finally {
 		clearTimeout(timer);
+		signal?.removeEventListener("abort", cancel);
 		try {
 			socket.close(1000);
 		} catch {
@@ -434,11 +489,30 @@ exec ${command.map(quote).join(" ")} messenger run --config "$dir/${configName}"
 `;
 }
 
-async function writePrivate(file: string, content: string, mode: number): Promise<void> {
+/** The Windows launcher inherits PATH at launch; the token remains in the private sidecar. */
+export function discordRunCommand(command: string[], configName: string, tokenEnv: string): string {
+	if (!/^[A-Za-z_]/u.test(tokenEnv) || /[^A-Za-z0-9_]/u.test(tokenEnv)) throw new Error("discord.tokenEnv must name an environment variable");
+	const literal = (value: string, label: string): string => {
+		if (/["\r\n]/.test(value)) throw new Error(`Windows launcher ${label} must not contain quotes or newlines`);
+		if (/[^\x00-\x7f]/.test(value)) throw new Error(`Windows launcher ${label} must contain only ASCII characters; use ASCII paths`);
+		return value.replace(/%/g, "%%");
+	};
+	const quote = (value: string): string => `"${literal(value, "command")}"`;
+	return `@echo off\r\nsetlocal DisableDelayedExpansion\r\nset /p "${tokenEnv}="<"%~dp0${TOKEN_FILE}"\r\n${command.map(quote).join(" ")} messenger run --config "%~dp0${literal(configName, "config name")}"\r\n`;
+}
+
+/** Stage `content` beside `file`, run `validate` on the staged copy, and only then replace `file`; failure leaves `file` untouched. */
+async function writePrivate(file: string, content: string, mode: number, validate?: (staged: string) => Promise<void>): Promise<void> {
 	const temporary = `${file}.${process.pid}.tmp`;
-	await Bun.write(temporary, content);
-	await fs.chmod(temporary, mode);
-	await fs.rename(temporary, file);
+	try {
+		await Bun.write(temporary, content);
+		await fs.chmod(temporary, mode);
+		await validate?.(temporary);
+		await fs.rename(temporary, file);
+	} catch (error) {
+		await fs.unlink(temporary).catch(() => undefined);
+		throw error;
+	}
 }
 
 async function readExistingConfig(configPath: string): Promise<Record<string, unknown> | undefined> {
@@ -458,9 +532,69 @@ async function readExistingConfig(configPath: string): Promise<Record<string, un
 	throw new Error(`${configPath} exists but is not a JSON object; fix or move it before setup`);
 }
 
-function currentJeoCommand(): string[] {
-	const entry = Bun.main;
-	return entry === process.execPath || entry.startsWith("/$bunfs/") ? [process.execPath] : [process.execPath, entry];
+/**
+ * The policy admission `messenger run` performs before starting the sandbox worker (commands/launch.ts), with the same
+ * private roots: the authority state directory, the session directory, the jeo home, the notify sessions directory and
+ * the profile paths from messengerProfilePrivatePaths, which also refuses a workspace that overlaps the profile. The authority state
+ * directory is a fresh random temp directory at launch, so a representative path under os.tmpdir() stands in for it.
+ * Throws on any refusal, so setup cannot succeed for a workspace that launch would reject.
+ */
+async function admitSandboxWorkspace(sandbox: SandboxConfig, profileDir: string, sessionDir: string, cwd: string): Promise<void> {
+	const profilePaths = await messengerProfilePrivatePaths(profileDir, cwd);
+	await createSandboxPolicy({
+		sessionKey: "setup",
+		revision: 0,
+		cwd,
+		config: sandbox,
+		privatePaths: [path.join(os.tmpdir(), "jeo-sandbox-authority-setup"), sessionDir, jeoHomeDir(), notifySessionsDir(), ...profilePaths],
+	});
+}
+
+/**
+ * Create the default workspace (or reuse one that carries the marker an earlier setup run left), then prove `admit`
+ * accepts it. The marker is a re-run convention, not proof of ownership; reuse is still gated by `admit`, and an
+ * unmarked existing directory is never adopted. Failure cleanup is non-recursive and best-effort: it can only remove
+ * the marker this call wrote and the then-empty directory, so concurrently added data survives.
+ */
+async function createDefaultWorkspace(admit: (workspace: string) => Promise<void>): Promise<string> {
+	const workspace = path.join(os.homedir(), WORKSPACE_DIR);
+	const marker = path.join(workspace, WORKSPACE_MARKER);
+	let created = false;
+	let wroteMarker = false;
+	try {
+		await fs.mkdir(workspace, { mode: 0o700 });
+		created = true;
+	} catch (error) {
+		if ((error as NodeJS.ErrnoException).code !== "EEXIST") throw error;
+	}
+	try {
+		if (created) {
+			await fs.writeFile(marker, "", { flag: "wx", mode: 0o600 });
+			wroteMarker = true;
+		} else {
+			const [stat, tag] = await Promise.all([fs.lstat(workspace), fs.lstat(marker).catch(() => undefined)]);
+			if (!stat.isDirectory() || !tag?.isFile()) {
+				throw new Error(`${workspace} already exists without the jeo setup marker`);
+			}
+		}
+		await admit(workspace);
+	} catch (error) {
+		if (wroteMarker) await fs.unlink(marker).catch(() => undefined);
+		// rmdir refuses a non-empty directory, so anything added meanwhile is preserved.
+		if (created) await fs.rmdir(workspace).catch(() => undefined);
+		throw new Error(`Default workspace ${workspace} is unusable (${error instanceof Error ? error.message : String(error)}); set "cwd" in the config to a directory outside private jeo and config roots`, { cause: error });
+	}
+	return workspace;
+}
+
+export function currentJeoCommand(entry = Bun.main, execPath = process.execPath): string[] {
+	return entry === execPath || entry.startsWith("/$bunfs/") || entry.replaceAll("\\", "/").startsWith("B:/~BUN/") ? [execPath] : [execPath, entry];
+}
+
+export function messengerExecutablePath(execPath: string, inheritedPath: string | undefined, delimiter: string, platform: NodeJS.Platform): string {
+	const fallbackPath = platform === "win32" ? "" : "/usr/bin:/bin";
+	const runtimeDirectory = platform === "win32" ? path.win32.dirname(execPath) : path.dirname(execPath);
+	return [...new Set([runtimeDirectory, ...(inheritedPath ?? fallbackPath).split(delimiter).filter(Boolean)])].join(delimiter);
 }
 
 /** Create or repair a Discord messenger profile with as few manual steps as Discord allows. */
@@ -473,20 +607,47 @@ export async function setupDiscordMessenger(
 	const configPath = path.resolve(options.configPath);
 	const directory = path.dirname(configPath);
 	const tokenPath = path.join(directory, TOKEN_FILE);
-	const runScript = path.join(directory, RUN_SCRIPT);
+	const platform = deps.platform ?? process.platform;
+	throwIfAborted(deps.signal);
+	if (options.service && platform !== "darwin" && platform !== "linux") {
+		throw new Error("Background services are supported only on macOS and Linux");
+	}
+	const runScript = path.join(directory, platform === "win32" ? RUN_SCRIPT_WINDOWS : RUN_SCRIPT_POSIX);
+	const delimiter = deps.pathDelimiter ?? path.delimiter;
+	const envPath = messengerExecutablePath(process.execPath, env.PATH, delimiter, platform);
+	const command = deps.jeoCommand ?? currentJeoCommand();
+	const existing = await readExistingConfig(configPath);
+	const sandbox = existing?.sandbox !== undefined ? parseMessengerSandbox(existing.sandbox) : parseMessengerSandbox({
+		image: await io.ask("Existing local Linux sandbox image (no image will be pulled): "),
+		limits: {
+			memoryBytes: Number(await io.ask("Sandbox memory limit in bytes: ")),
+			pids: Number(await io.ask("Sandbox process limit: ")),
+			cpus: Number(await io.ask("Sandbox CPU limit: ")),
+		},
+	});
+	if (existing && Object.hasOwn(existing, "independentSessions")) {
+		delete existing.independentSessions;
+		io.say("Removed obsolete independentSessions setting. Discord threads now keep one persistent session.");
+	}
+	if (platform === "win32") discordRunCommand(command, path.basename(configPath), DISCORD_TOKEN_ENV);
 
 	const token = await resolveToken(env, tokenPath, io);
-	const api = discordApi(token, deps.fetch ?? fetch);
+	throwIfAborted(deps.signal);
+	const api = discordApi(token, deps.fetch ?? fetch, deps.signal);
 	const bot = await inspectDiscordBot(api);
+	throwIfAborted(deps.signal);
 	io.say(`Bot ${bot.username} (${bot.id}), application ${bot.applicationId}`);
 	await ensureMessageContentIntent(api, bot, io);
+	throwIfAborted(deps.signal);
 
 	await fs.mkdir(directory, { recursive: true, mode: 0o700 });
+	throwIfAborted(deps.signal);
 	await writePrivate(tokenPath, `${token}\n`, 0o600);
+	throwIfAborted(deps.signal);
 
 	const inviteUrl = discordInviteUrl(bot.applicationId);
-	const guilds = await waitForDiscordGuilds(api, inviteUrl, io, deps.sleep ?? Bun.sleep, options.inviteWaitMs ?? 300_000);
-	const existing = await readExistingConfig(configPath);
+	const guilds = await waitForDiscordGuilds(api, inviteUrl, io, deps.sleep ?? Bun.sleep, options.inviteWaitMs ?? 300_000, deps.signal);
+	throwIfAborted(deps.signal);
 	const platforms = isRecord(existing?.platforms) ? existing.platforms : {};
 	const previous = isRecord(platforms.discord) ? platforms.discord : {};
 	const previousList = (key: string): string[] | undefined => {
@@ -499,52 +660,71 @@ export async function setupDiscordMessenger(
 	let channelIds: string[];
 	if (options.channelIds?.length || !previousList("allowedChannelIds")) {
 		const channels = await selectDiscordChannels(api, bot, guilds, options.channelIds, inviteUrl, io);
+		throwIfAborted(deps.signal);
 		for (const channel of channels) io.say(`Request channel: #${channel.name} in ${channel.guildName}`);
 		channelIds = channels.map(channel => channel.id);
 	} else {
 		channelIds = previousList("allowedChannelIds") as string[];
 	}
 	const dmChannel = options.dmTest === false ? undefined : await openOwnerDm(api, userIds[0]!, io);
+	throwIfAborted(deps.signal);
 	const allowedChannelIds = [...new Set([...channelIds, ...(dmChannel ? [dmChannel] : [])])];
 	const tokenEnv = str(previous.tokenEnv) ?? DISCORD_TOKEN_ENV;
+	if (platform === "win32") discordRunCommand(command, path.basename(configPath), tokenEnv);
 
 	const discord: Record<string, unknown> = { ...previous, tokenEnv, allowedUserIds: userIds, allowedChannelIds };
 	if (options.artifacts) discord.artifactDir = "./artifacts";
-	const defaultTools = ["read", "find", "search", "write", "edit", "bash", "computer"];
+	const sessionDir = str(existing?.sessionDir) ?? path.join(notifyDir(), "messenger-sessions");
+	let cwd: unknown;
+	if (existing && Object.hasOwn(existing, "cwd")) {
+		// An explicit value is never replaced; an unusable one fails the loader below before the config is touched.
+		cwd = existing.cwd;
+	} else {
+		cwd = await createDefaultWorkspace(workspace => admitSandboxWorkspace(sandbox, directory, path.resolve(directory, sessionDir), workspace));
+		if (existing) io.say(`The existing config had no "cwd"; its sandbox workspace is now ${cwd}. No existing files were moved or deleted.`);
+	}
+	throwIfAborted(deps.signal);
 	const config = {
 		...existing,
-		cwd: str(existing?.cwd) ?? "./workspace",
-		sessionDir: str(existing?.sessionDir) ?? "./sessions",
-		toolNames: options.toolNames ?? (Array.isArray(existing?.toolNames) ? existing.toolNames : defaultTools),
-		independentSessions: existing?.independentSessions !== undefined ? Boolean(existing.independentSessions) : true,
+		cwd,
+		sessionDir,
+		sandbox,
+		toolNames: options.toolNames ?? (Array.isArray(existing?.toolNames) ? existing.toolNames : [...DEFAULT_MESSENGER_TOOLS]),
 		platforms: { ...platforms, discord },
 	};
 	for (const relative of [config.cwd, config.sessionDir, discord.artifactDir]) {
 		if (typeof relative === "string")
 			await fs.mkdir(path.resolve(directory, relative), { recursive: true, mode: 0o700 });
+		throwIfAborted(deps.signal);
 	}
-	await writePrivate(configPath, `${JSON.stringify(config, null, 2)}\n`, 0o600);
-	const envPath = [...new Set([path.dirname(process.execPath), ...(env.PATH ?? "/usr/bin:/bin").split(":")])].join(
-		":",
-	);
+	// The loader `messenger run` uses, then the policy admission it performs, must accept the staged file before it replaces a working config.
+	await writePrivate(configPath, `${JSON.stringify(config, null, 2)}\n`, 0o600, async staged => {
+		const loaded = await loadMessengerConfig(staged);
+		validateMessengerEnvironment({ ...loaded, platforms: { discord: loaded.platforms.discord } }, { [tokenEnv]: token });
+		try {
+			await admitSandboxWorkspace(sandbox, loaded.profileDir ?? directory, loaded.sessionDir, loaded.cwd);
+		} catch (error) {
+			throw new Error(`Sandbox workspace ${loaded.cwd} would be refused at launch (${error instanceof Error ? error.message : String(error)}); set "cwd" in the config to a directory outside private jeo and config roots`, { cause: error });
+		}
+	});
+	throwIfAborted(deps.signal);
 	await writePrivate(
 		runScript,
-		discordRunScript(deps.jeoCommand ?? currentJeoCommand(), path.basename(configPath), tokenEnv, envPath),
+		platform === "win32"
+			? discordRunCommand(command, path.basename(configPath), tokenEnv)
+			: discordRunScript(command, path.basename(configPath), tokenEnv, envPath),
 		0o700,
 	);
-	// The same loader `messenger run` uses must accept what was written.
-	const written = await loadMessengerConfig(configPath);
-	validateMessengerEnvironment(
-		{ ...written, platforms: { discord: written.platforms.discord } },
-		{ [tokenEnv]: token },
-	);
+	throwIfAborted(deps.signal);
 
-	await probeDiscordGateway(api, token, deps.WebSocket ?? WebSocket);
+	await probeDiscordGateway(api, token, deps.WebSocket ?? WebSocket, deps.signal);
+	throwIfAborted(deps.signal);
 	io.say("Discord Gateway accepted the bot session and intents.");
 
 	let service: string | undefined;
 	if (options.service) {
 		service = await (deps.installService ?? installMessengerService)(messengerServicePlan(directory, runScript));
+		throwIfAborted(deps.signal);
 		io.say(`Gateway running as ${service}`);
 	}
 	if (dmChannel) {
@@ -555,8 +735,10 @@ export async function setupDiscordMessenger(
 			io.say(
 				"Could not send the test DM (the owner may block DMs from server members); server requests still work.",
 			);
+			throwIfAborted(deps.signal);
 		}
 	}
+	throwIfAborted(deps.signal);
 	return {
 		configPath,
 		botName: bot.username,

package/src/messenger/discord.ts

@@ -335,14 +335,15 @@ export function createDiscordAdapter(
 ): MessengerAdapter {
 	const token = resolveMessengerToken(config.tokenEnv, env)?.trim();
 	const clock = deps.clock ?? defaultClock;
-	const createdThreads = new Map<string, { parentChannelId: string; senderId: string }>();
-	const rememberThread = (threadId: string, parentChannelId: string, senderId: string): void => {
-		createdThreads.set(threadId, { parentChannelId, senderId });
+	const createdThreads = new Map<string, { parentChannelId: string }>();
+	const rememberThread = (threadId: string, parentChannelId: string): void => {
+		createdThreads.set(threadId, { parentChannelId });
 		if (createdThreads.size > 10_000) {
 			const oldest = createdThreads.keys().next().value;
 			if (oldest !== undefined) createdThreads.delete(oldest);
 		}
 	};
+	const normalizationTails = new Map<string, Promise<void>>();
 	const activityMessages = new Map<string, string>();
 	const headers = (): Record<string, string> => {
 		if (!token) throw new DiscordConfigurationError("Discord bot token is missing");
@@ -386,57 +387,50 @@ export function createDiscordAdapter(
 						initialUrl = discordGatewayUrl(gateway.url);
 					}
 					const deliver = async (message: MessengerMessage): Promise<void> => {
-						const thread = createdThreads.get(message.channelId);
-						if (thread && thread.senderId === message.senderId) {
-							await onMessage({
-								...message,
-								threadId: message.channelId,
-								parentChannelId: thread.parentChannelId,
-							});
-						} else if (
-							!message.direct &&
-							config.allowedUserIds.includes(message.senderId) &&
-							config.allowedChannelIds &&
-							(!message.mentioned || !config.allowedChannelIds.includes(message.channelId))
-						) {
-							try {
+						const previous = normalizationTails.get(message.channelId) ?? Promise.resolve();
+						const ready = Promise.withResolvers<void>();
+						const tail = previous.then(() => ready.promise);
+						normalizationTails.set(message.channelId, tail);
+						const forward = (destination: MessengerMessage): Promise<void> => {
+							ready.resolve();
+							return onMessage(destination);
+						};
+						await previous;
+						try {
+							if (signal.aborted) return;
+							const thread = createdThreads.get(message.channelId);
+							if (thread && config.allowedUserIds.includes(message.senderId)) {
+								await forward({ ...message, threadId: message.channelId, parentChannelId: thread.parentChannelId });
+							} else if (!message.direct && config.allowedUserIds.includes(message.senderId)) {
 								const channel = await messengerFetchJson(
 									`${DISCORD_API}/channels/${encodeURIComponent(message.channelId)}`,
-									{ headers: headers() },
-									signal,
-									deps.fetch,
+									{ headers: headers() }, signal, deps.fetch,
 								);
-								if (
-									isRecord(channel) &&
-									channel.id === message.channelId &&
-									typeof channel.type === "number" &&
-									[10, 11, 12].includes(channel.type) &&
-									typeof channel.parent_id === "string" &&
-									channel.parent_id
-								) {
+								if (!isRecord(channel) || channel.id !== message.channelId) return;
+								if (typeof channel.type === "number" && [10, 11, 12].includes(channel.type)) {
+									if (typeof channel.parent_id !== "string" || !channel.parent_id) return;
 									if (!message.mentioned) {
 										const originalId = typeof channel.name === "string" ? /^Request (\d{1,20})$/.exec(channel.name)?.[1] : undefined;
 										if (channel.owner_id !== accountId || !originalId ||
-											(!config.allowedChannelIds.includes(channel.parent_id) && !config.allowedChannelIds.includes(message.channelId))) return;
+											(config.allowedChannelIds && !config.allowedChannelIds.includes(channel.parent_id) && !config.allowedChannelIds.includes(message.channelId))) return;
 										const original = await messengerFetchJson(
 											`${DISCORD_API}/channels/${encodeURIComponent(channel.parent_id)}/messages/${originalId}`,
 											{ headers: headers() }, signal, deps.fetch,
 										);
 										if (!isRecord(original) || original.id !== originalId || original.channel_id !== channel.parent_id ||
-											!isRecord(original.author) || original.author.id !== message.senderId || original.author.bot === true || original.webhook_id) return;
-										rememberThread(message.channelId, channel.parent_id, message.senderId);
+											!isRecord(original.author) || typeof original.author.id !== "string" || original.author.bot === true || original.webhook_id) return;
 									}
-									await onMessage({
-										...message,
-										threadId: message.channelId,
-										parentChannelId: channel.parent_id,
-									});
+									rememberThread(message.channelId, channel.parent_id);
+									await forward({ ...message, threadId: message.channelId, parentChannelId: channel.parent_id });
+								} else {
+									await forward(message);
 								}
-							} catch {
-								/* ignore thread lookup failure */
+							} else {
+								await forward(message);
 							}
-						} else {
-							await onMessage(message);
+						} finally {
+							ready.resolve();
+							if (normalizationTails.get(message.channelId) === tail) normalizationTails.delete(message.channelId);
 						}
 					};
 					await connectGateway(
@@ -479,7 +473,7 @@ export function createDiscordAdapter(
 		async prepare(message, signal) {
 			if (message.direct) return message;
 			if (message.threadId) {
-				if (message.parentChannelId) rememberThread(message.threadId, message.parentChannelId, message.senderId);
+				if (message.parentChannelId) rememberThread(message.threadId, message.parentChannelId);
 				return message;
 			}
 			const channel = await messengerFetchJson(
@@ -493,7 +487,7 @@ export function createDiscordAdapter(
 			if ([10, 11, 12].includes(channel.type)) {
 				if (typeof channel.parent_id !== "string" || !channel.parent_id)
 					throw new Error("Discord thread parent unavailable");
-				rememberThread(message.channelId, channel.parent_id, message.senderId);
+				rememberThread(message.channelId, channel.parent_id);
 				return { ...message, threadId: message.channelId, parentChannelId: channel.parent_id };
 			}
 			if (channel.type !== 0 && channel.type !== 5) throw new Error("Discord channel cannot host a reply thread");
@@ -505,7 +499,7 @@ export function createDiscordAdapter(
 			);
 			if (!isRecord(thread) || typeof thread.id !== "string" || !thread.id)
 				throw new Error("Discord thread creation returned no ID");
-			rememberThread(thread.id, message.channelId, message.senderId);
+			rememberThread(thread.id, message.channelId);
 			return { ...message, threadId: thread.id };
 		},
 		async status(message, state, signal) {