clawmini 0.0.8 → 0.0.9

package/dist/adapter-discord/index.mjs

@@ -1,63 +1,22 @@
 #!/usr/bin/env node
-import { c as getClawminiDir, d as getSocketPath, f as getWorkspaceRoot } from "../workspace-BJmJBfKi.mjs";
+import { g as getWorkspaceRoot, h as getSocketPath, u as getClawminiDir } from "../workspace-oWmVh5mi.mjs";
 import { t as createUnixSocketFetch } from "../fetch-Cn1XNyiO.mjs";
-import { a as createUnixSocketEventSource, i as shouldDisplayMessage, n as handleAdapterCommand, r as formatMessage, t as handleRoutingCommand } from "../routing-D8rTxtaV.mjs";
+import { n as initDiscordConfig, r as readDiscordConfig } from "../config-CPFQIGdG.mjs";
+import { a as handleAdapterCommand, c as routeMessage, i as handleRoutingCommand, n as createUnixSocketEventSource, o as createInboundCache, r as prependBlockquote, s as formatMessage, t as createTurnLogBuffer } from "../turn-log-buffer-DRgW53gl.mjs";
 import fs from "node:fs";
 import path from "node:path";
-import fs$1 from "node:fs/promises";
+import fsPromises from "node:fs/promises";
 import { z } from "zod";
 import { createTRPCClient, httpLink, httpSubscriptionLink, splitLink } from "@trpc/client";
-import { ActionRowBuilder, ButtonBuilder, ButtonStyle, Client, Colors, EmbedBuilder, Events, GatewayIntentBits, ModalBuilder, Partials, TextInputBuilder, TextInputStyle } from "discord.js";
+import { ActionRowBuilder, ButtonBuilder, ButtonStyle, Client, Colors, EmbedBuilder, Events, GatewayIntentBits, ModalBuilder, Partials, REST, Routes, SlashCommandBuilder, TextInputBuilder, TextInputStyle } from "discord.js";
 
-//#region src/adapter-discord/config.ts
-const DiscordConfigSchema = z.looseObject({
-	botToken: z.string().min(1, "Discord Bot Token is required."),
-	authorizedUserId: z.string().min(1, "Authorized Discord User ID is required."),
-	chatId: z.string().default("default"),
-	maxAttachmentSizeMB: z.number().default(25),
-	requireMention: z.boolean().default(false)
-});
-function getDiscordConfigPath(startDir = process.cwd()) {
-	return path.join(getClawminiDir(startDir), "adapters", "discord", "config.json");
-}
-async function readDiscordConfig(startDir = process.cwd()) {
-	const configPath = getDiscordConfigPath(startDir);
-	try {
-		const data = await fs$1.readFile(configPath, "utf-8");
-		const parsed = JSON.parse(data);
-		return DiscordConfigSchema.parse(parsed);
-	} catch (err) {
-		if (err.code === "ENOENT") return null;
-		throw err;
-	}
-}
-async function initDiscordConfig(startDir = process.cwd()) {
-	const configPath = getDiscordConfigPath(startDir);
-	const configDir = path.dirname(configPath);
-	await fs$1.mkdir(configDir, { recursive: true });
-	if (fs.existsSync(configPath)) {
-		console.log(`Config file already exists at ${configPath}`);
-		return;
-	}
-	await fs$1.writeFile(configPath, JSON.stringify({
-		botToken: "YOUR_DISCORD_BOT_TOKEN",
-		authorizedUserId: "YOUR_DISCORD_USER_ID",
-		chatId: "default"
-	}, null, 2), "utf-8");
-	console.log(`Created template configuration file at ${configPath}`);
-	console.log("Please update it with your actual Discord Bot Token and User ID.");
-}
-function isAuthorized$1(userId, authorizedUserId) {
-	return userId === authorizedUserId;
-}
-
-//#endregion
 //#region src/adapter-discord/state.ts
 const DiscordStateSchema = z.object({
 	lastSyncedMessageIds: z.record(z.string(), z.string()).optional(),
 	channelChatMap: z.record(z.string(), z.object({
 		chatId: z.string().nullable().optional(),
-		requireMention: z.boolean().optional()
+		requireMention: z.boolean().optional(),
+		threadsDisabled: z.boolean().optional()
 	})).optional(),
 	filters: z.record(z.string(), z.boolean()).optional()
 });
@@ -67,7 +26,7 @@ function getDiscordStatePath(startDir = process.cwd()) {
 async function readDiscordState(startDir = process.cwd()) {
 	const statePath = getDiscordStatePath(startDir);
 	try {
-		const data = await fs$1.readFile(statePath, "utf-8");
+		const data = await fsPromises.readFile(statePath, "utf-8");
 		const parsed = JSON.parse(data);
 		if (parsed.lastSyncedMessageId && !parsed.lastSyncedMessageIds) parsed.lastSyncedMessageIds = { default: parsed.lastSyncedMessageId };
 		if (parsed.channelChatMap) {
@@ -83,8 +42,8 @@ async function writeDiscordState(state, startDir = process.cwd()) {
 	const statePath = getDiscordStatePath(startDir);
 	const dir = path.dirname(statePath);
 	try {
-		await fs$1.mkdir(dir, { recursive: true });
-		await fs$1.writeFile(statePath, JSON.stringify(state, null, 2), "utf-8");
+		await fsPromises.mkdir(dir, { recursive: true });
+		await fsPromises.writeFile(statePath, JSON.stringify(state, null, 2), "utf-8");
 	} catch (err) {
 		console.error(`Failed to write Discord state to ${statePath}:`, err);
 	}
@@ -110,13 +69,160 @@ function updateDiscordState(updates, startDir = process.cwd()) {
 	});
 }
 
+//#endregion
+//#region src/adapter-discord/inbound-cache.ts
+/**
+* Discord-side wrapper around the shared inbound-message TTL cache.
+*
+* On every inbound user message, the gateway records `{ messageId, channelId
+* }`. The same `messageId` is sent to the daemon as `externalRef` on the
+* `sendMessage` mutation. When the forwarder later sees `turnStarted` with
+* that `externalRef`, it resolves the channel + message id and starts a
+* Discord thread anchored on the user's message.
+*/
+const INBOUND_TTL_MS = 600 * 1e3;
+const cache = createInboundCache(INBOUND_TTL_MS);
+function recordInbound(entry) {
+	cache.record(entry.messageId, { channelId: entry.channelId });
+}
+function resolveInbound(messageId) {
+	const value = cache.resolve(messageId);
+	return value ? {
+		messageId,
+		channelId: value.channelId
+	} : null;
+}
+
+//#endregion
+//#region src/adapter-discord/processMessage.ts
+async function processDiscordMessage(content, author, channelId, guild, reply, config, trpc, filteringConfig, options = {}) {
+	if (author.bot) return;
+	const externalContextId = channelId || "default";
+	const currentState = await readDiscordState();
+	const mappedChatId = options.explicitChatId || (channelId ? currentState.channelChatMap?.[channelId]?.chatId : null);
+	const isRoutingCommand = content.startsWith("/chat") || content.startsWith("/agent");
+	if (guild && channelId) {
+		const channelConfig = currentState.channelChatMap?.[channelId];
+		if (channelConfig?.requireMention !== void 0 ? channelConfig.requireMention : config.requireMention) {
+			if (!options.mentionsBot && !options.isReplyToBot) return;
+		}
+	}
+	function isAuthorized(userId, authorizedUserId) {
+		return userId === authorizedUserId;
+	}
+	if (!isAuthorized(author.id, config.authorizedUserId)) {
+		console.log(`Unauthorized message from ${author.tag} (${author.id}) ignored.`);
+		return;
+	}
+	console.log(`Received message from ${author.tag}: ${content}`);
+	if (isRoutingCommand) {
+		const routingResult = await handleRoutingCommand(content, externalContextId, Object.fromEntries(Object.entries(currentState.channelChatMap || {}).map(([k, v]) => [k, v.chatId || ""])), "discord", trpc);
+		if (routingResult) {
+			if (routingResult.type === "mapped") await updateDiscordState((latestState) => ({ channelChatMap: {
+				...latestState.channelChatMap || {},
+				[externalContextId]: {
+					...latestState.channelChatMap?.[externalContextId] || {},
+					chatId: routingResult.newChatId
+				}
+			} }));
+			await reply(routingResult.text);
+			return;
+		}
+	}
+	let targetChatId = mappedChatId;
+	if (!targetChatId && !isRoutingCommand) if (!currentState.channelChatMap || Object.values(currentState.channelChatMap).every((entry) => !entry.chatId)) {
+		targetChatId = config.chatId || "default";
+		console.log(`First contact detected. Automatically mapping channel ${externalContextId} to chat ${targetChatId}.`);
+		await updateDiscordState((latestState) => ({ channelChatMap: {
+			...latestState.channelChatMap || {},
+			[externalContextId]: {
+				...latestState.channelChatMap?.[externalContextId] || {},
+				chatId: targetChatId
+			}
+		} }));
+	} else {
+		const isDirectMessage = !guild;
+		const isSlashCommand = content.startsWith("/");
+		if (isDirectMessage || options.mentionsBot || isSlashCommand) {
+			console.log(`Unmapped channel ${externalContextId}, sending first contact warning.`);
+			await reply("This channel/space is not currently mapped to a daemon chat. Please use `/chat [chat-id]` or `/agent [agent-id]` to map it.");
+		} else console.log(`Unmapped channel ${externalContextId}, silently ignoring background message.`);
+		return;
+	}
+	if (!targetChatId) targetChatId = config.chatId || "default";
+	const commandResult = await handleAdapterCommand(content, filteringConfig, trpc, targetChatId);
+	if (commandResult) {
+		if (commandResult.type === "text") {
+			if (commandResult.newConfig) {
+				filteringConfig.filters = commandResult.newConfig.filters;
+				await updateDiscordState({ filters: filteringConfig.filters });
+			}
+			await reply(commandResult.text);
+		} else if (commandResult.type === "debug") await reply(commandResult.messages.length === 0 ? "No ignored background messages found." : `**Debug Output (${commandResult.messages.length} ignored messages):**\n\n` + commandResult.messages.map((msg) => formatMessage(msg)).join("\n\n---\n\n"));
+		return;
+	}
+	const downloadedFiles = [];
+	if (options.attachments && options.attachments.length > 0) {
+		const tmpDir = path.join(getClawminiDir(process.cwd()), "tmp", "discord");
+		await fsPromises.mkdir(tmpDir, { recursive: true });
+		const maxSizeMB = config.maxAttachmentSizeMB ?? 25;
+		const maxSizeBytes = maxSizeMB * 1024 * 1024;
+		for (const attachment of options.attachments) {
+			if (attachment.size > maxSizeBytes) {
+				console.warn(`Attachment ${attachment.name} exceeds size limit (${maxSizeMB}MB). Ignoring.`);
+				await reply(`Warning: Attachment ${attachment.name} exceeds the size limit of ${maxSizeMB}MB and was ignored.`);
+				continue;
+			}
+			try {
+				const res = await fetch(attachment.url);
+				if (!res.ok) {
+					console.error(`Failed to download attachment ${attachment.name}`);
+					continue;
+				}
+				const uniqueName = `${Date.now()}-${attachment.name}`;
+				const filePath = path.join(tmpDir, uniqueName);
+				const arrayBuffer = await res.arrayBuffer();
+				await fsPromises.writeFile(filePath, Buffer.from(arrayBuffer));
+				downloadedFiles.push(filePath);
+			} catch (err) {
+				console.error(`Error downloading attachment ${attachment.name}:`, err);
+			}
+		}
+	}
+	let finalContent = content;
+	if (options.referenceContent) finalContent = prependBlockquote(options.referenceContent, finalContent, options.referenceAuthor);
+	console.log(`Forwarding message to daemon: ${finalContent}`);
+	if (options.messageId && channelId) recordInbound({
+		messageId: options.messageId,
+		channelId
+	});
+	try {
+		await trpc.sendMessage.mutate({
+			type: "send-message",
+			client: "cli",
+			data: {
+				message: finalContent,
+				chatId: targetChatId,
+				files: downloadedFiles.length > 0 ? downloadedFiles : void 0,
+				adapter: "discord",
+				noWait: true,
+				...options.messageId ? { externalRef: options.messageId } : {}
+			}
+		});
+		console.log("Message forwarded to daemon successfully.");
+	} catch (error) {
+		console.error("Failed to forward message to daemon:", error);
+		await reply("Failed to forward message to the daemon. Please check the logs.");
+	}
+}
+
 //#endregion
 //#region src/adapter-discord/interactions.ts
 function isAuthorized(userId, authorizedUserId) {
 	return userId === authorizedUserId;
 }
-async function handleDiscordInteraction(interaction, config, trpc) {
-	if (!interaction.isButton() && !interaction.isModalSubmit()) return;
+async function handleDiscordInteraction(interaction, config, trpc, filteringConfig) {
+	if (!interaction.isButton() && !interaction.isModalSubmit() && !interaction.isChatInputCommand()) return;
 	if (!isAuthorized(interaction.user.id, config.authorizedUserId)) {
 		if (interaction.isRepliable()) await interaction.reply({
 			content: "You are not authorized to perform this action.",
@@ -124,6 +230,34 @@ async function handleDiscordInteraction(interaction, config, trpc) {
 		});
 		return;
 	}
+	if (interaction.isChatInputCommand()) {
+		const { commandName } = interaction;
+		let commandStr = `/${commandName}`;
+		if (commandName === "approve" || commandName === "reject") {
+			const policyId = interaction.options.getString("policy_id");
+			if (policyId) commandStr += ` ${policyId}`;
+		}
+		if (commandName === "reject") {
+			const rationale = interaction.options.getString("rationale");
+			if (rationale) commandStr += ` ${rationale}`;
+		}
+		await interaction.deferReply({ ephemeral: true });
+		const currentState = await readDiscordState();
+		const targetChatId = interaction.channelId ? currentState.channelChatMap?.[interaction.channelId]?.chatId || config.chatId : config.chatId;
+		let replied = false;
+		await processDiscordMessage(commandStr, interaction.user, interaction.channelId, interaction.guild, async (text) => {
+			replied = true;
+			await interaction.followUp({
+				content: text,
+				ephemeral: true
+			});
+		}, config, trpc, filteringConfig, {
+			explicitChatId: targetChatId,
+			mentionsBot: true
+		});
+		if (!replied) await interaction.deleteReply();
+		return;
+	}
 	if (interaction.isButton()) {
 		if (interaction.customId.startsWith("approve_") || interaction.customId.startsWith("approve|")) {
 			let policyId, explicitChatId;
@@ -137,26 +271,17 @@ async function handleDiscordInteraction(interaction, config, trpc) {
 				content: `Approving policy ${policyId}...`,
 				ephemeral: true
 			});
-			try {
-				const currentState = await readDiscordState();
-				const targetChatId = explicitChatId || (interaction.channelId ? currentState.channelChatMap?.[interaction.channelId]?.chatId || config.chatId : config.chatId);
-				await trpc.sendMessage.mutate({
-					type: "send-message",
-					client: "cli",
-					data: {
-						message: `/approve ${policyId}`,
-						chatId: targetChatId,
-						adapter: "discord",
-						noWait: true
-					}
-				});
-			} catch (error) {
-				console.error("Failed to send approve command to daemon:", error);
+			const currentState = await readDiscordState();
+			const targetChatId = explicitChatId || (interaction.channelId ? currentState.channelChatMap?.[interaction.channelId]?.chatId || config.chatId : config.chatId);
+			await processDiscordMessage(`/approve ${policyId}`, interaction.user, interaction.channelId, interaction.guild, async (text) => {
 				await interaction.followUp({
-					content: `Failed to approve policy ${policyId}.`,
+					content: text,
 					ephemeral: true
 				});
-			}
+			}, config, trpc, filteringConfig, {
+				explicitChatId: targetChatId,
+				mentionsBot: true
+			});
 		} else if (interaction.customId.startsWith("reject_") || interaction.customId.startsWith("reject|")) {
 			let policyId, explicitChatId;
 			if (interaction.customId.startsWith("reject|")) {
@@ -189,30 +314,24 @@ async function handleDiscordInteraction(interaction, config, trpc) {
 					content: `Rejecting policy ${policyId}...`,
 					ephemeral: true
 				});
-			} else await interaction.reply({
-				content: `Rejecting policy ${policyId}...`,
-				ephemeral: true
-			});
-			try {
-				const currentState = await readDiscordState();
-				const targetChatId = explicitChatId || (interaction.channelId ? currentState.channelChatMap?.[interaction.channelId]?.chatId || config.chatId : config.chatId);
-				await trpc.sendMessage.mutate({
-					type: "send-message",
-					client: "cli",
-					data: {
-						message: command,
-						chatId: targetChatId,
-						adapter: "discord",
-						noWait: true
-					}
-				});
-			} catch (error) {
-				console.error("Failed to send reject command to daemon:", error);
+			} else {
+				await interaction.deferReply({ ephemeral: true });
 				await interaction.followUp({
-					content: `Failed to reject policy ${policyId}.`,
+					content: `Rejecting policy ${policyId}...`,
 					ephemeral: true
 				});
 			}
+			const currentState = await readDiscordState();
+			const targetChatId = explicitChatId || (interaction.channelId ? currentState.channelChatMap?.[interaction.channelId]?.chatId || config.chatId : config.chatId);
+			await processDiscordMessage(command, interaction.user, interaction.channelId, interaction.guild, async (text) => {
+				await interaction.followUp({
+					content: text,
+					ephemeral: true
+				});
+			}, config, trpc, filteringConfig, {
+				explicitChatId: targetChatId,
+				mentionsBot: true
+			});
 		}
 	}
 }
@@ -246,6 +365,20 @@ function getTRPCClient(options = {}) {
 
 //#endregion
 //#region src/adapter-discord/forwarder.ts
+const DEFAULT_THREAD_LOG_OPTS = {
+	maxToolPreview: 400,
+	maxLogMessageChars: 1800,
+	editDebounceMs: 1e3
+};
+function resolveThreadLogOpts(config) {
+	const v = config?.visibility?.threadLog;
+	return {
+		maxToolPreview: v?.maxToolPreview ?? DEFAULT_THREAD_LOG_OPTS.maxToolPreview,
+		maxLogMessageChars: v?.maxLogMessageChars ?? DEFAULT_THREAD_LOG_OPTS.maxLogMessageChars,
+		editDebounceMs: v?.editDebounceMs ?? DEFAULT_THREAD_LOG_OPTS.editDebounceMs
+	};
+}
+const NO_MENTIONS = { allowedMentions: { parse: [] } };
 async function resolveDiscordDestination(client, discordUserId, chatId) {
 	const channelChatMap = (await readDiscordState()).channelChatMap || {};
 	let targetDiscordChannelId;
@@ -265,6 +398,8 @@ async function startDaemonToDiscordForwarder(client, trpc, discordUserId, option
 	const defaultChatId = options.chatId ?? "default";
 	const signal = options.signal;
 	const config = options.config ?? {};
+	const threadLogOpts = resolveThreadLogOpts(options.discordConfig);
+	const threadsGloballyEnabled = options.discordConfig?.visibility?.threads !== false;
 	const activeSubscriptions = /* @__PURE__ */ new Map();
 	const activeTypingSubscriptions = /* @__PURE__ */ new Map();
 	let currentLastSyncedMessageIds = (await readDiscordState()).lastSyncedMessageIds || {};
@@ -278,6 +413,170 @@ async function startDaemonToDiscordForwarder(client, trpc, discordUserId, option
 			...currentLastSyncedMessageIds
 		} }));
 	};
+	const postThreaded = async (anchor, text) => {
+		return (await anchor.send({
+			content: text || "​",
+			...NO_MENTIONS
+		})).id;
+	};
+	const editThreaded = async (anchor, messageId, text) => {
+		await (await anchor.messages.fetch(messageId)).edit({
+			content: text || "​",
+			...NO_MENTIONS
+		});
+	};
+	const isMissingMessageError = (err) => {
+		const code = err?.code ?? 0;
+		return code === 404 || code === 10008;
+	};
+	const turnLog = createTurnLogBuffer({
+		postThreaded,
+		editThreaded,
+		isMissingMessageError,
+		options: threadLogOpts,
+		threadsEnabled: threadsGloballyEnabled
+	});
+	const collapseDestination = (dest, turnId) => {
+		if (dest.kind !== "thread-log") return dest;
+		if (!threadsGloballyEnabled) return { kind: "drop" };
+		if (turnId && turnLog.threadsDisabledFor(turnId)) return { kind: "drop" };
+		return dest;
+	};
+	const channelThreadsDisabled = async (chatId) => {
+		const state = await readDiscordState();
+		for (const [, entry] of Object.entries(state.channelChatMap || {})) if (entry?.chatId === chatId) return entry.threadsDisabled === true;
+		return false;
+	};
+	const openThreadForTurn = async (externalRef) => {
+		if (!externalRef) return void 0;
+		const inbound = resolveInbound(externalRef);
+		if (!inbound) return void 0;
+		let channel;
+		try {
+			channel = await client.channels.fetch(inbound.channelId);
+		} catch (err) {
+			console.warn(`Failed to fetch channel ${inbound.channelId} for turn anchor:`, err);
+			return;
+		}
+		if (!channel || !channel.isTextBased() || channel.isDMBased() || channel.isThread()) return;
+		const guildChannel = channel;
+		let userMessage;
+		try {
+			userMessage = await guildChannel.messages.fetch(inbound.messageId);
+		} catch (err) {
+			console.warn(`Failed to fetch user message ${inbound.messageId} for turn anchor:`, err);
+			return;
+		}
+		if (userMessage.hasThread && userMessage.thread) return userMessage.thread;
+		try {
+			return await userMessage.startThread({
+				name: "Activity log",
+				autoArchiveDuration: 1440
+			});
+		} catch (err) {
+			if (err?.code === 160004) try {
+				const refreshed = await guildChannel.messages.fetch(inbound.messageId);
+				if (refreshed.hasThread && refreshed.thread) return refreshed.thread;
+			} catch (refetchErr) {
+				console.warn(`Failed to refetch user message ${inbound.messageId} after thread-exists race:`, refetchErr);
+			}
+			console.warn(`Failed to start thread on message ${inbound.messageId}:`, err);
+			return;
+		}
+	};
+	const handleTurnStarted = async (chatId, turnId, externalRef) => {
+		const threadsDisabled = !threadsGloballyEnabled || await channelThreadsDisabled(chatId);
+		const anchor = threadsDisabled ? void 0 : await openThreadForTurn(externalRef);
+		if (!anchor && !threadsDisabled) return;
+		turnLog.start({
+			turnId,
+			threadsDisabled,
+			anchorThread: anchor
+		});
+	};
+	const handleTurnEnded = async (turnId) => {
+		await turnLog.end(turnId);
+	};
+	const sendPolicyCard = async (chatId, message) => {
+		if (message.role !== "policy" || message.status !== "pending") return false;
+		try {
+			const dm = await resolveDiscordDestination(client, discordUserId, chatId);
+			const embed = new EmbedBuilder().setTitle("Action Required: Policy Request").setDescription(message.content || "A pending policy request requires your attention.").setColor(Colors.Yellow);
+			const policyId = "requestId" in message && message.requestId || message.id;
+			const row = new ActionRowBuilder().addComponents(new ButtonBuilder().setCustomId(`approve|${policyId}|${chatId}`).setLabel("Approve").setStyle(ButtonStyle.Success), new ButtonBuilder().setCustomId(`reject|${policyId}|${chatId}`).setLabel("Reject").setStyle(ButtonStyle.Danger));
+			const optionsMsg = {
+				embeds: [embed],
+				components: [row],
+				...NO_MENTIONS
+			};
+			try {
+				await dm.send(optionsMsg);
+			} catch (richError) {
+				console.warn(`Failed to send rich message to Discord user ${discordUserId}, falling back to plain text:`, richError);
+				await dm.send({
+					content: `Action Required: Policy Request\n\n${message.content || "A pending policy request requires your attention."}\n\nApprove: \`/approve ${policyId}\`\nReject: \`/reject ${policyId} <optional_rationale>\``,
+					...NO_MENTIONS
+				});
+			}
+		} catch (error) {
+			console.error(`Failed to send message to Discord user ${discordUserId}:`, error);
+		}
+		return true;
+	};
+	const sendTopLevel = async (chatId, message) => {
+		if ("level" in message && message.level === "verbose") return;
+		const hasContent = !!message.content?.trim();
+		const files = "files" in message ? message.files ?? [] : [];
+		const hasFiles = Array.isArray(files) && files.length > 0;
+		let absoluteFiles = [];
+		if (hasFiles) {
+			const workspaceRoot = getWorkspaceRoot(process.cwd());
+			absoluteFiles = files.map((f) => path.resolve(workspaceRoot, f));
+		}
+		if (!hasContent && !hasFiles) return;
+		try {
+			const dm = await resolveDiscordDestination(client, discordUserId, chatId);
+			const formattedContent = formatMessage(message);
+			if (formattedContent && formattedContent.length > 2e3) {
+				const chunks = chunkString(formattedContent, 2e3);
+				for (let i = 0; i < chunks.length; i++) {
+					if (signal?.aborted) break;
+					const chunkOptions = {
+						content: chunks[i],
+						...NO_MENTIONS
+					};
+					if (i === chunks.length - 1 && hasFiles) chunkOptions.files = absoluteFiles;
+					await dm.send(chunkOptions);
+				}
+			} else {
+				const optionsMsg = { ...NO_MENTIONS };
+				if (formattedContent) optionsMsg.content = formattedContent;
+				if (hasFiles) optionsMsg.files = absoluteFiles;
+				await dm.send(optionsMsg);
+			}
+		} catch (error) {
+			console.error(`Failed to send message to Discord user ${discordUserId}:`, error);
+			throw error;
+		}
+	};
+	const handleMessageForChat = async (chatId, message) => {
+		const effective = collapseDestination(routeMessage(message, config), message.turnId);
+		if (effective.kind === "drop") return;
+		if (effective.kind === "thread-log") {
+			if (!message.turnId) {
+				console.warn(`thread-log event for ${message.role} has no turnId — dropping.`);
+				return;
+			}
+			if (!turnLog.has(message.turnId)) return;
+			turnLog.append(message.turnId, message);
+			return;
+		}
+		if (message.role === "policy" && message.status === "pending") {
+			await sendPolicyCard(chatId, message);
+			return;
+		}
+		await sendTopLevel(chatId, message);
+	};
 	const startSubscriptionForChat = async (chatId) => {
 		if (activeSubscriptions.has(chatId)) return;
 		if (signal?.aborted) return;
@@ -309,82 +608,33 @@ async function startDaemonToDiscordForwarder(client, trpc, discordUserId, option
 				chatId,
 				lastMessageId
 			}, {
-				onData: (messages) => {
+				onData: (items) => {
 					retryDelay = 1e3;
-					if (!Array.isArray(messages) || messages.length === 0) return;
+					if (!Array.isArray(items) || items.length === 0) return;
 					messageQueue = messageQueue.then(async () => {
-						for (const rawMessage of messages) {
+						for (const raw of items) {
 							if (signal?.aborted || !activeSubscriptions.has(chatId)) break;
-							const message = rawMessage;
-							if (shouldDisplayMessage(message, config)) {
-								const logMessage = message;
-								if (logMessage.role === "policy" && logMessage.status === "pending") {
-									try {
-										const dm = await resolveDiscordDestination(client, discordUserId, chatId);
-										const embed = new EmbedBuilder().setTitle("Action Required: Policy Request").setDescription(logMessage.content || "A pending policy request requires your attention.").setColor(Colors.Yellow);
-										const policyId = "requestId" in logMessage && logMessage.requestId || logMessage.id;
-										const row = new ActionRowBuilder().addComponents(new ButtonBuilder().setCustomId(`approve|${policyId}|${chatId}`).setLabel("Approve").setStyle(ButtonStyle.Success), new ButtonBuilder().setCustomId(`reject|${policyId}|${chatId}`).setLabel("Reject").setStyle(ButtonStyle.Danger));
-										const optionsMsg = {
-											embeds: [embed],
-											components: [row]
-										};
-										try {
-											await dm.send(optionsMsg);
-										} catch (richError) {
-											console.warn(`Failed to send rich message to Discord user ${discordUserId}, falling back to plain text:`, richError);
-											await dm.send({ content: `Action Required: Policy Request\n\n${logMessage.content || "A pending policy request requires your attention."}\n\nApprove: \`/approve ${policyId}\`\nReject: \`/reject ${policyId} <optional_rationale>\`` });
-										}
-									} catch (error) {
-										console.error(`Failed to send message to Discord user ${discordUserId}:`, error);
-									}
-									await saveLastMessageId(chatId, logMessage.id).catch(console.error);
-									lastMessageId = logMessage.id;
-									continue;
-								}
-								if ("level" in logMessage && logMessage.level === "verbose") {
-									await saveLastMessageId(chatId, logMessage.id).catch(console.error);
-									lastMessageId = logMessage.id;
-									continue;
-								}
-								const hasContent = !!logMessage.content?.trim();
-								const files = "files" in logMessage ? logMessage.files : void 0;
-								const hasFiles = Array.isArray(files) && files.length > 0;
-								let absoluteFiles = [];
-								if (hasFiles && files) {
-									const workspaceRoot = getWorkspaceRoot(process.cwd());
-									absoluteFiles = files.map((f) => path.resolve(workspaceRoot, f));
-								}
-								if (!hasContent && !hasFiles) {
-									await saveLastMessageId(chatId, logMessage.id).catch(console.error);
-									lastMessageId = logMessage.id;
-									continue;
-								}
+							const item = raw;
+							if (item.kind === "turn") {
 								try {
-									const dm = await resolveDiscordDestination(client, discordUserId, chatId);
-									const formattedContent = formatMessage(message);
-									if (formattedContent && formattedContent.length > 2e3) {
-										const chunks = chunkString(formattedContent, 2e3);
-										for (let i = 0; i < chunks.length; i++) {
-											if (signal?.aborted || !activeSubscriptions.has(chatId)) break;
-											const chunkOptions = { content: chunks[i] };
-											if (i === chunks.length - 1 && hasFiles) chunkOptions.files = absoluteFiles;
-											await dm.send(chunkOptions);
-										}
-									} else {
-										const optionsMsg = {};
-										if (formattedContent) optionsMsg.content = formattedContent;
-										if (hasFiles) optionsMsg.files = absoluteFiles;
-										await dm.send(optionsMsg);
-									}
-								} catch (error) {
-									console.error(`Failed to send message to Discord user ${discordUserId}:`, error);
-									break;
+									if (item.event.type === "started") await handleTurnStarted(chatId, item.event.turnId, item.event.externalRef);
+									else await handleTurnEnded(item.event.turnId);
+								} catch (err) {
+									console.error("Failed to handle turn event:", err);
 								}
+								continue;
+							}
+							const message = item.message;
+							try {
+								await handleMessageForChat(chatId, message);
+							} catch (err) {
+								console.error("Failed to handle message:", err);
+								break;
 							}
 							await saveLastMessageId(chatId, message.id).catch(console.error);
 							lastMessageId = message.id;
 						}
-					});
+					}).catch((err) => console.error("Message queue chain error:", err));
 				},
 				onError: (error) => {
 					console.error(`Error in daemon-to-discord forwarder subscription for ${chatId}. Retrying in ${retryDelay}ms.`, error);
@@ -477,6 +727,7 @@ async function startDaemonToDiscordForwarder(client, trpc, discordUserId, option
 			watcher.close();
 			for (const sub of activeSubscriptions.values()) sub.unsubscribe();
 			for (const sub of activeTypingSubscriptions.values()) sub.unsubscribe();
+			turnLog.shutdown();
 			resolve();
 		});
 	});
@@ -488,6 +739,19 @@ function chunkString(str, size) {
 	return chunks;
 }
 
+//#endregion
+//#region src/adapter-discord/commands.ts
+const slashCommands = [
+	new SlashCommandBuilder().setName("new").setDescription("Start a new chat or operation."),
+	new SlashCommandBuilder().setName("stop").setDescription("Stop the current operation."),
+	new SlashCommandBuilder().setName("approve").setDescription("Approve a pending policy request.").addStringOption((option) => option.setName("policy_id").setDescription("The ID of the policy to approve").setRequired(true)),
+	new SlashCommandBuilder().setName("reject").setDescription("Reject a pending policy request.").addStringOption((option) => option.setName("policy_id").setDescription("The ID of the policy to reject").setRequired(true)).addStringOption((option) => option.setName("rationale").setDescription("Optional rationale for rejecting the policy").setRequired(false)),
+	new SlashCommandBuilder().setName("pending").setDescription("List pending policy requests."),
+	new SlashCommandBuilder().setName("show").setDescription("Show background messages."),
+	new SlashCommandBuilder().setName("hide").setDescription("Hide background messages."),
+	new SlashCommandBuilder().setName("debug").setDescription("Output debug information about ignored background messages.")
+];
+
 //#endregion
 //#region src/adapter-discord/index.ts
 async function main() {
@@ -512,146 +776,65 @@ async function main() {
 		partials: [Partials.Channel]
 	});
 	const filteringConfig = { filters: (await readDiscordState()).filters };
-	client.once(Events.ClientReady, (readyClient) => {
+	client.once(Events.ClientReady, async (readyClient) => {
 		console.log(`Ready! Logged in as ${readyClient.user.tag}`);
+		try {
+			await (await readyClient.users.fetch(config.authorizedUserId)).createDM();
+		} catch (err) {
+			console.error(`Failed to pre-cache DM channel for authorized user ${config.authorizedUserId}:`, err);
+		}
+		try {
+			const rest = new REST({ version: "10" }).setToken(config.botToken);
+			console.log("Started refreshing application (/) commands.");
+			await rest.put(Routes.applicationCommands(readyClient.user.id), { body: slashCommands.map((cmd) => cmd.toJSON()) });
+			console.log("Successfully reloaded application (/) commands.");
+		} catch (error) {
+			console.error("Error registering slash commands:", error);
+		}
 		startDaemonToDiscordForwarder(readyClient, trpc, config.authorizedUserId, {
 			chatId: config.chatId,
-			config: filteringConfig
+			config: filteringConfig,
+			discordConfig: config
 		}).catch((error) => {
 			console.error("Error in daemon-to-discord forwarder:", error);
 		});
 	});
 	client.on(Events.MessageCreate, async (message) => {
-		if (message.author.id === client.user?.id) return;
-		if (message.author.bot) return;
-		const externalContextId = message.channelId;
-		const currentState = await readDiscordState();
-		const mappedChatId = currentState.channelChatMap?.[externalContextId]?.chatId;
-		const isRoutingCommand = message.content.startsWith("/chat") || message.content.startsWith("/agent");
-		if (message.guild) {
-			const channelConfig = currentState.channelChatMap?.[externalContextId];
-			if (channelConfig?.requireMention !== void 0 ? channelConfig.requireMention : config.requireMention) {
-				const isMentioned = message.mentions.has(client.user.id);
-				let isReplyToBot = false;
-				if (message.reference && message.reference.messageId) try {
-					isReplyToBot = (await message.channel.messages.fetch(message.reference.messageId)).author.id === client.user.id;
-				} catch (err) {
-					console.error("Failed to fetch referenced message for mention check:", err);
-				}
-				if (!isMentioned && !isReplyToBot) return;
-			}
-		}
-		if (!isAuthorized$1(message.author.id, config.authorizedUserId)) {
-			console.log(`Unauthorized message from ${message.author.tag} (${message.author.id}) ignored.`);
-			return;
-		}
-		console.log(`Received message from ${message.author.tag}: ${message.content}`);
-		if (isRoutingCommand) {
-			const stringChatMap = Object.fromEntries(Object.entries(currentState.channelChatMap || {}).map(([k, v]) => [k, v.chatId || ""]));
-			const routingResult = await handleRoutingCommand(message.content, externalContextId, stringChatMap, "discord", trpc);
-			if (routingResult) {
-				if (routingResult.type === "mapped") await updateDiscordState((latestState) => ({ channelChatMap: {
-					...latestState.channelChatMap || {},
-					[externalContextId]: {
-						...latestState.channelChatMap?.[externalContextId] || {},
-						chatId: routingResult.newChatId
-					}
-				} }));
-				await message.reply(routingResult.text);
-				return;
-			}
-		}
-		let targetChatId = mappedChatId;
-		if (!targetChatId && !isRoutingCommand) if (!currentState.channelChatMap || Object.values(currentState.channelChatMap).every((entry) => !entry.chatId)) {
-			targetChatId = config.chatId || "default";
-			console.log(`First contact detected. Automatically mapping channel ${externalContextId} to chat ${targetChatId}.`);
-			await updateDiscordState((latestState) => ({ channelChatMap: {
-				...latestState.channelChatMap || {},
-				[externalContextId]: {
-					...latestState.channelChatMap?.[externalContextId] || {},
-					chatId: targetChatId
-				}
-			} }));
-		} else {
-			const isDirectMessage = !message.guild;
-			const isMentioned = message.mentions.has(client.user.id);
-			const isSlashCommand = message.content.startsWith("/");
-			if (isDirectMessage || isMentioned || isSlashCommand) {
-				console.log(`Unmapped channel ${externalContextId}, sending first contact warning.`);
-				await message.reply("This channel/space is not currently mapped to a daemon chat. Please use `/chat [chat-id]` or `/agent [agent-id]` to map it.");
-			} else console.log(`Unmapped channel ${externalContextId}, silently ignoring background message.`);
-			return;
-		}
-		if (!targetChatId) targetChatId = config.chatId || "default";
-		const commandResult = await handleAdapterCommand(message.content, filteringConfig, trpc, targetChatId);
-		if (commandResult) {
-			if (commandResult.type === "text") {
-				if (commandResult.newConfig) {
-					filteringConfig.filters = commandResult.newConfig.filters;
-					await updateDiscordState({ filters: filteringConfig.filters });
-				}
-				await message.reply(commandResult.text);
-			} else if (commandResult.type === "debug") {
-				const formatted = commandResult.messages.length === 0 ? "No ignored background messages found." : `**Debug Output (${commandResult.messages.length} ignored messages):**\n\n` + commandResult.messages.map((msg) => formatMessage(msg)).join("\n\n---\n\n");
-				await message.reply(formatted);
-			}
-			return;
-		}
-		const downloadedFiles = [];
-		if (message.attachments.size > 0) {
-			const tmpDir = path.join(getClawminiDir(process.cwd()), "tmp", "discord");
-			await fs$1.mkdir(tmpDir, { recursive: true });
-			const maxSizeMB = config.maxAttachmentSizeMB ?? 25;
-			const maxSizeBytes = maxSizeMB * 1024 * 1024;
-			for (const attachment of message.attachments.values()) {
-				if (attachment.size > maxSizeBytes) {
-					console.warn(`Attachment ${attachment.name} exceeds size limit (${maxSizeMB}MB). Ignoring.`);
-					await message.reply(`Warning: Attachment ${attachment.name} exceeds the size limit of ${maxSizeMB}MB and was ignored.`);
-					continue;
-				}
-				try {
-					const res = await fetch(attachment.url);
-					if (!res.ok) {
-						console.error(`Failed to download attachment ${attachment.name}`);
-						continue;
-					}
-					const uniqueName = `${Date.now()}-${attachment.name}`;
-					const filePath = path.join(tmpDir, uniqueName);
-					const arrayBuffer = await res.arrayBuffer();
-					await fs$1.writeFile(filePath, Buffer.from(arrayBuffer));
-					downloadedFiles.push(filePath);
-				} catch (err) {
-					console.error(`Error downloading attachment ${attachment.name}:`, err);
-				}
-			}
-		}
-		let finalContent = message.content;
+		let isReplyToBot = false;
+		let referenceContent;
+		let referenceAuthor;
 		if (message.reference && message.reference.messageId) try {
 			const referencedMessage = await message.fetchReference();
-			if (referencedMessage && referencedMessage.content) finalContent = `${referencedMessage.content.split("\n").map((line) => `> ${line}`).join("\n")}\n${finalContent}`;
+			isReplyToBot = referencedMessage?.author.id === client.user.id;
+			referenceContent = referencedMessage?.content;
+			if (referencedMessage) {
+				if (referencedMessage.author.bot) referenceAuthor = "Assistant";
+				else if (referencedMessage.author.id !== config.authorizedUserId) referenceAuthor = referencedMessage.author.username;
+			}
 		} catch (err) {
-			console.error("Failed to fetch referenced message:", err);
+			console.error("Failed to fetch referenced message for mention check:", err);
 		}
-		console.log(`Forwarding message to daemon: ${finalContent}`);
-		try {
-			await trpc.sendMessage.mutate({
-				type: "send-message",
-				client: "cli",
-				data: {
-					message: finalContent,
-					chatId: targetChatId,
-					files: downloadedFiles.length > 0 ? downloadedFiles : void 0,
-					adapter: "discord",
-					noWait: true
-				}
+		const attachments = message.attachments ? Array.from(message.attachments.values()).map((att) => ({
+			name: att.name,
+			size: att.size,
+			url: att.url
+		})) : [];
+		await processDiscordMessage(message.content, message.author, message.channelId, message.guild, async (text) => {
+			await message.reply({
+				content: text,
+				allowedMentions: { parse: [] }
 			});
-			console.log("Message forwarded to daemon successfully.");
-		} catch (error) {
-			console.error("Failed to forward message to daemon:", error);
-		}
+		}, config, trpc, filteringConfig, {
+			mentionsBot: !!message.mentions?.has(client.user.id),
+			isReplyToBot,
+			attachments,
+			messageId: message.id,
+			...referenceContent ? { referenceContent } : {},
+			...referenceAuthor ? { referenceAuthor } : {}
+		});
 	});
 	client.on(Events.InteractionCreate, async (interaction) => {
-		await handleDiscordInteraction(interaction, config, trpc);
+		await handleDiscordInteraction(interaction, config, trpc, filteringConfig);
 	});
 	try {
 		await client.login(config.botToken);