@agentconnect.md/daemon 1.0.0-rc.237 → 1.0.0-rc.238

package/dist/{run-foreground-C389T7yc.js → run-foreground-R9O-KCZr.js}

@@ -67655,7 +67655,7 @@ function clampTo$2(s, max) {
 	const t = s.trim();
 	return t.length > max ? `${t.slice(0, max - 1)}…` : t;
 }
-function clampLabel(s) {
+function clampLabel$1(s) {
 	return clampTo$2(s, MAX_LABEL$2);
 }
 /** Wrap tool activity (a command line, tool title, or tool output) in a CommonMark code
@@ -67722,7 +67722,7 @@ function planIcon$2(status) {
 /** Render an ACP plan (full entry list, resent on every update) as a compact summary.
 *  Posted as a `markdown` block, so emphasis is CommonMark (`**bold**`), not mrkdwn. */
 function renderPlan$2(entries) {
-	return [":clipboard: **Plan**", ...entries.map((e) => `${planIcon$2(e.status)} ${clampLabel(e.content ?? "")}`)].join("\n");
+	return [":clipboard: **Plan**", ...entries.map((e) => `${planIcon$2(e.status)} ${clampLabel$1(e.content ?? "")}`)].join("\n");
 }
 /** Render the accumulated reasoning trace (high mode) as one in-place message. Posted as
 *  a `markdown` block (verbatim CommonMark, so `**bold**`), tail-clamped to a compact cap
@@ -67733,7 +67733,7 @@ function renderReasoning$2(buf) {
 	return `:thought_balloon: **Thinking**\n${trimmed.length > MAX_REASONING$2 ? `…${trimmed.slice(-2800)}` : trimmed}`;
 }
 /** Compact a token count as `1.2k` / `3.4M` (whole numbers under 1000 stay verbatim). */
-function compactCount$1(n) {
+function compactCount$2(n) {
 	if (n < 1e3) return String(n);
 	if (n < 1e6) return `${(n / 1e3).toFixed(n < 1e4 ? 1 : 0)}k`;
 	return `${(n / 1e6).toFixed(1)}M`;
@@ -67749,9 +67749,9 @@ function renderStatusBar(info) {
 	if (info.fastMode) parts.push("fast");
 	if (info.contextUsed !== void 0 && info.contextSize !== void 0 && info.contextSize > 0) {
 		const pct = Math.round(info.contextUsed / info.contextSize * 100);
-		parts.push(`ctx ${compactCount$1(info.contextUsed)}/${compactCount$1(info.contextSize)} (${pct}%)`);
-	} else if (info.contextUsed !== void 0) parts.push(`ctx ${compactCount$1(info.contextUsed)}`);
-	if (info.totalTokens !== void 0) parts.push(`${compactCount$1(info.totalTokens)} tok`);
+		parts.push(`ctx ${compactCount$2(info.contextUsed)}/${compactCount$2(info.contextSize)} (${pct}%)`);
+	} else if (info.contextUsed !== void 0) parts.push(`ctx ${compactCount$2(info.contextUsed)}`);
+	if (info.totalTokens !== void 0) parts.push(`${compactCount$2(info.totalTokens)} tok`);
 	return `:bar_chart: ${parts.length ? parts.join(" · ") : "—"}`;
 }
 /** Slack action_ids for the interactive status bar + modal (matched by the connection's
@@ -195004,12 +195004,14 @@ function humanizeDiscordText(text) {
 /** Normalize a Discord gateway message into the platform-agnostic contract. */
 function normalizeDiscordMessage(msg, ctx) {
 	const attachments = msg.attachments.map(toAttachment).filter((a) => a !== null);
+	const isDm = !msg.inGuild;
 	return {
 		msgId: `discord:${msg.channelId}:${msg.id}`,
 		traceId: ctx.traceId,
 		source: "user",
 		platform: "discord",
 		channel: msg.channelId,
+		thread: msg.channelId,
 		sender: {
 			id: msg.authorId,
 			isBot: msg.authorIsBot
@@ -195017,10 +195019,101 @@ function normalizeDiscordMessage(msg, ctx) {
 		text: humanizeDiscordText(msg.content),
 		mentionedBots: msg.mentionUserIds,
 		...attachments.length ? { attachments } : {},
-		isDm: !msg.inGuild
+		isDm,
+		...!isDm && !msg.isThread ? { discordTopLevel: true } : {}
 	};
 }
 //#endregion
+//#region src/discord/app-commands.ts
+/**
+* Native Discord application (slash) command definitions, registered globally on
+* connect (see DiscordConnection.start → registerCommands). They make the same
+* control vocabulary the daemon already parses from plain `/text` messages
+* (see commands.ts) show up in Discord's `/` autocomplete menu with descriptions
+* and typed arguments.
+*
+* These are NOT a second command engine: a slash invocation is reconstructed back
+* into its `/text` form (DiscordConnection.slashCommandText) and fed through the
+* SAME onInbound → parseCommand → handleCommand path as a typed message, so the
+* names/args here MUST stay in lockstep with parseCommand's vocabulary (guarded by
+* discord-app-commands.test.ts).
+*
+* PREREQUISITE: the bot must be invited with the `applications.commands` OAuth2
+* scope, else `commands.set` fails with 403 Missing Access and nothing appears.
+*
+* The select commands (`/models` `/effort` `/permission`) take an OPTIONAL free-text
+* argument — omitting it lists the choices as a tappable button card (buildDiscord-
+* SelectComponents); passing it selects directly. Choices aren't pre-declared because
+* the offered options are model-dependent and only known once a session is warm.
+*/
+const DISCORD_APP_COMMANDS = [
+	{
+		name: "status",
+		description: "Show this session's model, context and token usage"
+	},
+	{
+		name: "models",
+		description: "List models, or switch (leave blank for a tappable picker)",
+		options: [{
+			name: "model",
+			description: "Model id, name, or list number",
+			type: import_src.ApplicationCommandOptionType.String
+		}]
+	},
+	{
+		name: "effort",
+		description: "List reasoning-effort levels, or switch",
+		options: [{
+			name: "level",
+			description: "Effort level or list number",
+			type: import_src.ApplicationCommandOptionType.String
+		}]
+	},
+	{
+		name: "permission",
+		description: "List permission modes, or switch",
+		options: [{
+			name: "mode",
+			description: "Permission mode or list number",
+			type: import_src.ApplicationCommandOptionType.String
+		}]
+	},
+	{
+		name: "fast",
+		description: "Toggle fast mode for this session",
+		options: [{
+			name: "state",
+			description: "on or off",
+			type: import_src.ApplicationCommandOptionType.String,
+			choices: [{
+				name: "on",
+				value: "on"
+			}, {
+				name: "off",
+				value: "off"
+			}]
+		}]
+	},
+	{
+		name: "stop",
+		description: "Stop the agent and mute this thread until @mentioned"
+	},
+	{
+		name: "cancel",
+		description: "Cancel the in-flight turn (session stays live)"
+	},
+	{
+		name: "queue",
+		description: "Queue a message to run once the agent is idle",
+		options: [{
+			name: "message",
+			description: "The message to queue",
+			type: import_src.ApplicationCommandOptionType.String,
+			required: true
+		}]
+	}
+];
+//#endregion
 //#region src/discord/render.ts
 /** Discord single-message hard cap (2000 chars) — vs Telegram's 4096, Slack's 12000-char block. */
 const DISCORD_MESSAGE_LIMIT = 2e3;
@@ -195100,6 +195193,23 @@ function renderReasoning$1(buf) {
 	const trimmed = buf.trim();
 	return `💭 **Thinking**\n${trimmed.length > MAX_REASONING$1 ? `…${trimmed.slice(-2800)}` : trimmed}`;
 }
+function compactCount$1(n) {
+	if (n < 1e3) return String(n);
+	if (n < 1e6) return `${(n / 1e3).toFixed(n < 1e4 ? 1 : 0)}k`;
+	return `${(n / 1e6).toFixed(1)}M`;
+}
+/** The compact status line (markdown), e.g. `📊 **opus-4.8** · fast · ctx 120k/200k (60%) · 45.2k tok`. */
+function renderStatusText$1(info) {
+	const parts = [];
+	if (info.model) parts.push(`**${info.model}**`);
+	if (info.fastMode) parts.push("fast");
+	if (info.contextUsed !== void 0 && info.contextSize !== void 0 && info.contextSize > 0) {
+		const pct = Math.round(info.contextUsed / info.contextSize * 100);
+		parts.push(`ctx ${compactCount$1(info.contextUsed)}/${compactCount$1(info.contextSize)} (${pct}%)`);
+	} else if (info.contextUsed !== void 0) parts.push(`ctx ${compactCount$1(info.contextUsed)}`);
+	if (info.totalTokens !== void 0) parts.push(`${compactCount$1(info.totalTokens)} tok`);
+	return `📊 ${parts.length ? parts.join(" · ") : "—"}`;
+}
 /** custom_id verbs for the status button row. Discord caps custom_id at 100 chars
 *  but we keep the verb STATELESS (mirroring Telegram's callback_data) — the
 *  connection maps the button's message (channel+message_id) back to its session
@@ -195123,6 +195233,78 @@ function parseDiscordCallback(data) {
 	};
 	return null;
 }
+/** One-char code ↔ kind for the compact select custom_id (`ac_sel:<code>:<index>`). */
+const DISCORD_SELECT_CODE = {
+	model: "m",
+	effort: "e",
+	permission: "p"
+};
+const SELECT_CODE_KIND$1 = {
+	m: "model",
+	e: "effort",
+	p: "permission"
+};
+const SELECT_PREFIX = "ac_sel";
+/** Discord caps a button label at 80 chars and an action row at 5 buttons / a message
+*  at 5 rows → 25 options fit as a card; past that the daemon falls back to a text list. */
+const MAX_BUTTON_LABEL = 80;
+const MAX_BUTTONS_PER_ROW = 5;
+const MAX_SELECT_OPTIONS = MAX_BUTTONS_PER_ROW * 5;
+function clampLabel(s) {
+	return s.length > MAX_BUTTON_LABEL ? `${s.slice(0, MAX_BUTTON_LABEL - 1)}…` : s;
+}
+/** Parse a select-button custom_id (`ac_sel:<code>:<index>`) into a kind + option index
+*  (null if it isn't one). Stateless like the status verbs — the connection maps the
+*  button's message back to its session key (see parseDiscordCallback's note). */
+function parseDiscordSelect(data) {
+	const m = new RegExp(`^${SELECT_PREFIX}:([mep]):(\\d+)$`).exec(data);
+	if (!m) return null;
+	const kind = SELECT_CODE_KIND$1[m[1]];
+	const index = Number(m[2]);
+	if (!kind || !Number.isInteger(index)) return null;
+	return {
+		kind,
+		index
+	};
+}
+/**
+* Build a `/models` `/effort` `/permission` select as tappable button rows — one button
+* per option (the current flagged ✅, styled Success), custom_id = `ac_sel:<code>:<index>`.
+* The Discord analog of the daemon's buildSelectCard (Telegram inline keyboard). Returns
+* null when there are no options or too many to fit Discord's 25-button ceiling, so the
+* caller falls back to a numbered text list.
+*/
+function buildDiscordSelectComponents(kind, current, options) {
+	if (options.length === 0 || options.length > MAX_SELECT_OPTIONS) return null;
+	const code = DISCORD_SELECT_CODE[kind];
+	const rows = [];
+	for (let i = 0; i < options.length; i += MAX_BUTTONS_PER_ROW) rows.push({
+		type: 1,
+		components: options.slice(i, i + MAX_BUTTONS_PER_ROW).map((o, j) => {
+			const isCurrent = o === current;
+			return {
+				type: 2,
+				style: isCurrent ? 3 : 2,
+				label: clampLabel(`${isCurrent ? "✅ " : ""}${o}`),
+				custom_id: `${SELECT_PREFIX}:${code}:${i + j}`
+			};
+		})
+	});
+	return rows;
+}
+/** A lone "View session" link-button row (Discord style-5). Used by `/status`, where a
+*  raw Slack `<url|text>` link would render as literal text on Discord. */
+function buildLinkComponents(link, label = "🔗 View session") {
+	return [{
+		type: 1,
+		components: [{
+			type: 2,
+			style: 5,
+			label,
+			url: link
+		}]
+	}];
+}
 var DiscordConverger = class {
 	mode;
 	buf = "";
@@ -195307,21 +195489,37 @@ var DiscordConnection = class {
 			}
 		});
 		client.on(import_src.Events.InteractionCreate, (interaction) => {
+			if (interaction.isChatInputCommand()) {
+				this.onSlashCommand(interaction);
+				return;
+			}
 			if (!interaction.isButton()) return;
 			interaction.deferUpdate().catch(() => {});
-			const action = parseDiscordCallback(interaction.customId);
-			if (!action) return;
-			const sessionKey = this.statusKeys.get(`${interaction.channelId}:${interaction.message.id}`);
+			const channel = interaction.channelId;
+			const sessionKey = this.statusKeys.get(`${channel}:${interaction.message.id}`);
 			if (!sessionKey) return;
-			if (action.kind === "cancel") this.deps.onStatusAction?.({
-				kind: "cancel",
-				sessionKey
-			});
-			else this.deps.onStatusAction?.({
-				kind: "set-fast",
-				sessionKey,
-				fastMode: action.fastMode
-			});
+			const status = parseDiscordCallback(interaction.customId);
+			if (status) {
+				if (status.kind === "cancel") this.deps.onStatusAction?.({
+					kind: "cancel",
+					sessionKey
+				});
+				else this.deps.onStatusAction?.({
+					kind: "set-fast",
+					sessionKey,
+					fastMode: status.fastMode
+				});
+				return;
+			}
+			const sel = parseDiscordSelect(interaction.customId);
+			if (sel && this.deps.onSelectAction) {
+				const rendered = this.deps.onSelectAction({
+					kind: sel.kind,
+					index: sel.index,
+					sessionKey
+				});
+				if (rendered) this.updateMessage(channel, interaction.message.id, rendered.text, { keyboard: rendered.components });
+			}
 		});
 		client.on(import_src.Events.Error, (err) => log?.debug(`discord: client error: ${err.message}`));
 		log?.debug("discord: login → opening Gateway…");
@@ -195330,11 +195528,68 @@ var DiscordConnection = class {
 				this.botUserId = c.user.id;
 				this.botUsername = c.user.username;
 				log?.debug(`discord: ready → bot @${this.botUsername} (id ${this.botUserId})`);
+				this.registerCommands();
 				resolve();
 			});
 			client.login(this.botToken).catch(reject);
 		});
 	}
+	/** Register the control vocabulary as global Discord application commands so it shows
+	*  up in the `/` autocomplete menu. Global registration covers every guild + DMs;
+	*  first-time propagation can take up to ~1h (edits are near-instant thereafter).
+	*  Best-effort — a 403 almost always means the bot wasn't invited with the
+	*  `applications.commands` scope, so we log that hint rather than throwing. */
+	async registerCommands() {
+		try {
+			await this.client.application?.commands.set(DISCORD_APP_COMMANDS);
+			this.deps.log?.info(`discord: registered ${DISCORD_APP_COMMANDS.length} slash commands (global) for @${this.botUsername}`);
+		} catch (err) {
+			this.deps.log?.error(`discord: slash-command registration failed — is the bot invited with the applications.commands scope? (${err.message})`);
+		}
+	}
+	/**
+	* A native slash-command invocation. Ack within Discord's 3s window (an ephemeral
+	* echo, seen only by the invoker), then reconstruct the `/text` form and feed it
+	* through the SAME onMessage path as a typed command — so routing, authz, the reply,
+	* and the tappable cards all reuse handleCommand. The real output posts to the
+	* channel/thread (public), matching how a typed `/command` behaves today.
+	*/
+	onSlashCommand(interaction) {
+		const text = this.slashCommandText(interaction);
+		interaction.reply({
+			content: text,
+			flags: import_src.MessageFlags.Ephemeral
+		}).catch(() => {});
+		try {
+			const msg = normalizeDiscordMessage(this.slashToLike(interaction, text), { traceId: this.deps.newTraceId() });
+			this.deps.log?.debug(`discord: slash ${text} ch=${msg.channel} user=${msg.sender.id}`);
+			this.deps.onMessage(msg);
+		} catch (err) {
+			this.deps.log?.debug(`discord: slash command failed: ${err.message}`);
+		}
+	}
+	/** Reconstruct a slash invocation into its `/text` form (`/models opus`, `/queue do X`)
+	*  so parseCommand handles it exactly like a typed message. Options are appended in
+	*  declaration order; our control commands take at most one. */
+	slashCommandText(interaction) {
+		const args = interaction.options.data.map((o) => o.value === void 0 || o.value === null ? "" : String(o.value)).join(" ").trim();
+		return args ? `/${interaction.commandName} ${args}` : `/${interaction.commandName}`;
+	}
+	/** Adapt a slash interaction to the pure normalizer's plain-object view (text = the
+	*  reconstructed command). Mirrors toLike; no attachments/mentions on a command. */
+	slashToLike(interaction, text) {
+		return {
+			id: interaction.id,
+			channelId: interaction.channelId,
+			content: text,
+			authorId: interaction.user.id,
+			authorIsBot: interaction.user.bot,
+			inGuild: interaction.inGuild(),
+			isThread: interaction.channel?.isThread() ?? false,
+			mentionUserIds: [],
+			attachments: []
+		};
+	}
 	/** Adapt a live gateway Message to the pure normalizer's plain-object view. */
 	toLike(message) {
 		return {
@@ -195344,6 +195599,7 @@ var DiscordConnection = class {
 			authorId: message.author.id,
 			authorIsBot: message.author.bot,
 			inGuild: message.inGuild(),
+			isThread: message.channel.isThread(),
 			mentionUserIds: [...message.mentions.users.keys()],
 			attachments: [...message.attachments.values()].map((a) => ({
 				id: a.id,
@@ -195361,6 +195617,25 @@ var DiscordConnection = class {
 		return null;
 	}
 	/**
+	* Open a thread off a channel message so a turn's reply + chrome live in the thread
+	* rather than the parent channel (Slack-parity — see daemon's Discord ingress). The
+	* created thread's id EQUALS the source message id (a Discord guarantee), so the
+	* caller re-keys the session onto it and follow-ups posted in the thread (which
+	* arrive with `channelId` = thread id) continue the same session. Best-effort:
+	* returns the thread id, or undefined when the message/channel can't be resolved or
+	* the bot lacks the Create Public Threads permission (caller then replies in-channel).
+	*/
+	async createThread(channelId, messageId, name) {
+		try {
+			const ch = await this.sendableChannel(channelId);
+			if (!ch?.messages) return void 0;
+			return (await (await ch.messages.fetch(messageId)).startThread({ name: name.slice(0, 100) || "Agent thread" })).id;
+		} catch (err) {
+			this.deps.log?.debug(`discord: createThread failed (ch=${channelId} msg=${messageId}): ${err.message}`);
+			return;
+		}
+	}
+	/**
 	* Post a message. `channel` is already the concrete channel/thread id (Discord
 	* threads are their own channels — see normalize.ts), so `threadTs` is unused —
 	* the session channel IS the reply target. Long text is chunked to the 2000-char
@@ -213463,6 +213738,12 @@ function pendingSessionKey(p) {
 		channel: p.channel
 	};
 }
+/** Name for a Discord thread opened off a top-level @mention: the first line of the
+*  prompt, collapsed to one line and clamped to Discord's 100-char thread-name cap
+*  (createThread also clamps). Empty prompts (e.g. attachment-only) get a default. */
+function discordThreadName(text) {
+	return text.replace(/\s+/g, " ").trim().slice(0, 90) || "Agent thread";
+}
 var Daemon = class Daemon {
 	opts;
 	store;
@@ -213966,6 +214247,7 @@ var Daemon = class Daemon {
 				newTraceId: () => randomUUID(),
 				onMessage: (msg) => this.onInbound(msg),
 				onStatusAction: (a) => this.handleStatusAction(a),
+				onSelectAction: (a) => this.handleDiscordSelect(a),
 				log: this.log
 			});
 			try {
@@ -214186,9 +214468,33 @@ var Daemon = class Daemon {
 			this.log.info(`routing: agent "${result.agentId}" un-muted in ch=${msg.channel} (explicit @mention)`);
 		}
 		this.log.info(`routing: ch=${msg.channel} → agent "${result.agentId}" (integration ${result.integrationId})`);
+		if (msg.platform === "discord" && msg.discordTopLevel) {
+			this.dispatchDiscordTopLevel(result.agentId, msg, result.integrationId).catch((err) => this.log.error(`dispatch failed for agent "${result.agentId}": ${formatErr(err)}`));
+			return;
+		}
 		this.dispatch(result.agentId, msg, result.integrationId).catch((err) => this.log.error(`dispatch failed for agent "${result.agentId}": ${formatErr(err)}`));
 	}
 	/**
+	* Discord top-level channel @mention (§Slack-parity threading): open a thread off the
+	* triggering message so the whole turn — reply + progress/status chrome — lands in a
+	* thread instead of flooding the channel. The new thread's id equals the message id, so
+	* we re-key the turn onto the thread channel; every follow-up posted there arrives with
+	* `channelId` = thread id and normalizes to the SAME session, giving the conversation
+	* continuity. Best-effort: if thread creation fails (e.g. the bot lacks Create Public
+	* Threads), we fall back to replying in the channel (the pre-thread behavior).
+	*/
+	async dispatchDiscordTopLevel(agentId, msg, integrationId) {
+		const conn = this.dcConnByIntegration.get(integrationId);
+		const messageId = msg.msgId.split(":").pop() ?? "";
+		const threadId = conn ? await conn.createThread(msg.channel, messageId, discordThreadName(msg.text)) : void 0;
+		if (threadId) {
+			this.log.info(`discord: opened thread ${threadId} for ch=${msg.channel} msg=${messageId}`);
+			msg.channel = threadId;
+			msg.thread = threadId;
+		} else this.log.debug(`discord: no thread opened for ch=${msg.channel} — replying in channel`);
+		await this.dispatch(agentId, msg, integrationId);
+	}
+	/**
 	* Handle an inbound webchat turn (C→D `webchat/message`). webchat is the one
 	* integration whose data plane is the daemon↔CP control WS itself — the far end is
 	* the CP/browser, so the body arrives inline and the reply streams back over the
@@ -214388,6 +214694,28 @@ var Daemon = class Daemon {
 			if (a.outputMode) this.setOutputModeByKey(a.sessionKey, a.outputMode);
 		}
 	}
+	/**
+	* A tapped Discord select-card button (`/models` `/effort` `/permission`): resolve the
+	* session from the button's key, apply the chosen option, and return the re-rendered
+	* card so the connection edits the message in place (new current flagged). Undefined
+	* when the session is gone or the option index is stale (options changed) — the
+	* connection then leaves the card as-is. Mirrors handleTelegramCallback.
+	*/
+	handleDiscordSelect(a) {
+		const rec = this.store.getSession(a.sessionKey);
+		if (!rec) return void 0;
+		const info = this.statusInfoFrom(rec.agentId, a.sessionKey, rec.acpSessionId ?? void 0);
+		const { options } = this.selectOptions(a.kind, info);
+		const value = options[a.index];
+		if (value === void 0) return void 0;
+		this.applySelect(a.kind, a.sessionKey, value);
+		const components = buildDiscordSelectComponents(a.kind, value, options);
+		if (!components) return void 0;
+		return {
+			text: this.selectCardText(a.kind, value),
+			components
+		};
+	}
 	/** All of our own connections' bot identities (both `U…` user ids and `B…`
 	*  bot_ids), so we recognize self-echoes regardless of which field Slack sends. */
 	ownBotIdentities() {
@@ -214532,6 +214860,7 @@ var Daemon = class Daemon {
 				threadTs: replyThread,
 				replyTo: tgReplyTo
 			});
+			else if (msg.platform === "discord") conn?.postChrome(msg.channel, renderStatusText$1(info), link ? { keyboard: buildLinkComponents(link) } : {});
 			else reply(link ? `${renderStatusBar(info)}  ·  <${link}|View session>` : renderStatusBar(info));
 			return;
 		}
@@ -214553,11 +214882,23 @@ var Daemon = class Daemon {
 				reply("No active session here to configure.");
 				return;
 			}
-			const card = msg.platform === "telegram" && conn ? (text, buttons) => void conn.postCard(msg.channel, text, buttons, {
-				threadTs: replyThread,
-				replyTo: tgReplyTo
-			}) : void 0;
-			this.handleSelectCommand(command.kind, command.value, target.agentId, key, acpSessionId ?? void 0, reply, card);
+			const renderCard = msg.platform === "telegram" && conn ? (kind, current, options) => {
+				const { text, buttons } = this.buildSelectCard(kind, current, options);
+				conn.postCard(msg.channel, text, buttons, {
+					threadTs: replyThread,
+					replyTo: tgReplyTo
+				});
+				return true;
+			} : msg.platform === "discord" && conn ? (kind, current, options) => {
+				const components = buildDiscordSelectComponents(kind, current, options);
+				if (!components) return false;
+				conn.postChrome(msg.channel, this.selectCardText(kind, current), {
+					keyboard: components,
+					sessionKey: key
+				});
+				return true;
+			} : void 0;
+			this.handleSelectCommand(command.kind, command.value, target.agentId, key, acpSessionId ?? void 0, reply, renderCard);
 			return;
 		}
 		if (!command.text) {
@@ -214609,6 +214950,11 @@ var Daemon = class Daemon {
 		else if (kind === "effort") this.setEffortByKey(key, value);
 		else this.setPermissionModeByKey(key, value);
 	}
+	/** Header line for a select card (shared by the Telegram inline-keyboard card and the
+	*  Discord button card). */
+	selectCardText(kind, current) {
+		return `${this.selectLabel(kind)} — tap to switch (current: ${current ?? "default"}):`;
+	}
 	/** Build a session-control card: a header line + one tappable button per option (the
 	*  current one flagged), with `callback_data` = `<kindCode>:<optionIndex>`. */
 	buildSelectCard(kind, current, options) {
@@ -214618,7 +214964,7 @@ var Daemon = class Daemon {
 			callbackData: `${code}:${i}`
 		}]);
 		return {
-			text: `${this.selectLabel(kind)} — tap to switch (current: ${current ?? "default"}):`,
+			text: this.selectCardText(kind, current),
 			buttons
 		};
 	}
@@ -214630,7 +214976,7 @@ var Daemon = class Daemon {
 	* live host's config selectors (statusInfoFrom); when the host is cold a given value is
 	* accepted optimistically and takes effect on the next turn.
 	*/
-	handleSelectCommand(kind, value, agentId, key, acpSessionId, reply, card) {
+	handleSelectCommand(kind, value, agentId, key, acpSessionId, reply, renderCard) {
 		const label = this.selectLabel(kind);
 		const info = this.statusInfoFrom(agentId, key, acpSessionId);
 		const { current, options } = this.selectOptions(kind, info);
@@ -214640,11 +214986,7 @@ var Daemon = class Daemon {
 				reply(current ? `${label}: ${current} (no other options offered${kind === "effort" ? " — the current model may not support effort" : ""}).` : `No ${label.toLowerCase()} options available yet — send me a message first, then try /${cmd} again.`);
 				return;
 			}
-			if (card) {
-				const { text, buttons } = this.buildSelectCard(kind, current, options);
-				card(text, buttons);
-				return;
-			}
+			if (renderCard?.(kind, current, options)) return;
 			reply(`${label} — reply \`/${cmd} <name or number>\`:\n${options.map((o, i) => `${i + 1}. ${o}${o === current ? "  ✓ (current)" : ""}`).join("\n")}`);
 			return;
 		}
@@ -216065,4 +216407,4 @@ async function runForeground(opts, deps = {}) {
 //#endregion
 export { ClientTransport as i, CP_SUBPROTOCOL as n, CP_WS_PATH as r, runForeground as t };
 
-//# sourceMappingURL=run-foreground-C389T7yc.js.map
+//# sourceMappingURL=run-foreground-R9O-KCZr.js.map