openryoko 2026.9.2 → 2026.9.4

package/dist/package.json

@@ -1,6 +1,6 @@
 {
     "name": "openryoko",
-    "version": "2026.9.2",
+    "version": "2026.9.4",
     "description": "OpenRyoko — Slackで空気を読んで働くAIアシスタント・ゲートウェイ（Jinnベース、Claude Code/Codex/Gemini CLI対応）",
     "license": "MIT",
     "type": "module",

package/dist/src/connectors/discord/engaged-threads.d.ts

@@ -0,0 +1,24 @@
+/**
+ * In-memory record of conversation anchors the bot has engaged: threads it
+ * replied or reacted in, plus the IDs of eligible messages it sent or
+ * reacted to — a Discord public thread created from a message reuses that
+ * message's ID, so recording message IDs makes future threads rooted on the
+ * bot's own messages count as engaged from their first reply.
+ *
+ * Backs the `respondTo.engagedThreads` continuation. No eviction, matching
+ * the Slack ConversationTracker: engagement is a promise ("mention once,
+ * then converse"), and silently evicting it would re-arm the mention
+ * requirement mid-conversation. Memory stays bounded by what the connector
+ * feeds in (see `DiscordConnector.recordEngagement`): nothing at all unless
+ * a consumer exists, and only anchor-eligible IDs — DM and in-thread message
+ * IDs can never root a thread and are never recorded. At the ~60-70 bytes a
+ * Set entry really costs, even hundreds of thousands of anchors stay in the
+ * tens of megabytes. Entries live until the connector is recreated (gateway
+ * restart, config save, connector reload).
+ */
+export declare class EngagedThreadTracker {
+    private readonly ids;
+    record(id: string): void;
+    has(id: string): boolean;
+}
+//# sourceMappingURL=engaged-threads.d.ts.map

package/dist/src/connectors/discord/engaged-threads.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engaged-threads.d.ts","sourceRoot":"","sources":["../../../../src/connectors/discord/engaged-threads.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,oBAAoB;IAC/B,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAqB;IAEzC,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI;IAIxB,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO;CAGzB"}

package/dist/src/connectors/discord/engaged-threads.js

@@ -0,0 +1,28 @@
+/**
+ * In-memory record of conversation anchors the bot has engaged: threads it
+ * replied or reacted in, plus the IDs of eligible messages it sent or
+ * reacted to — a Discord public thread created from a message reuses that
+ * message's ID, so recording message IDs makes future threads rooted on the
+ * bot's own messages count as engaged from their first reply.
+ *
+ * Backs the `respondTo.engagedThreads` continuation. No eviction, matching
+ * the Slack ConversationTracker: engagement is a promise ("mention once,
+ * then converse"), and silently evicting it would re-arm the mention
+ * requirement mid-conversation. Memory stays bounded by what the connector
+ * feeds in (see `DiscordConnector.recordEngagement`): nothing at all unless
+ * a consumer exists, and only anchor-eligible IDs — DM and in-thread message
+ * IDs can never root a thread and are never recorded. At the ~60-70 bytes a
+ * Set entry really costs, even hundreds of thousands of anchors stay in the
+ * tens of megabytes. Entries live until the connector is recreated (gateway
+ * restart, config save, connector reload).
+ */
+export class EngagedThreadTracker {
+    ids = new Set();
+    record(id) {
+        this.ids.add(id);
+    }
+    has(id) {
+        return this.ids.has(id);
+    }
+}
+//# sourceMappingURL=engaged-threads.js.map

package/dist/src/connectors/discord/engaged-threads.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"engaged-threads.js","sourceRoot":"","sources":["../../../../src/connectors/discord/engaged-threads.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,OAAO,oBAAoB;IACd,GAAG,GAAG,IAAI,GAAG,EAAU,CAAC;IAEzC,MAAM,CAAC,EAAU;QACf,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;IACnB,CAAC;IAED,GAAG,CAAC,EAAU;QACZ,OAAO,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;IAC1B,CAAC;CACF"}

package/dist/src/connectors/discord/index.d.ts

@@ -1,4 +1,4 @@
-import type { Connector, ConnectorCapabilities, ConnectorHealth, IncomingMessage, Target } from "../../shared/types.js";
+import type { Connector, ConnectorCapabilities, ConnectorHealth, DiscordReplyStyle, DiscordRespondToConfig, IncomingMessage, Target } from "../../shared/types.js";
 export interface DiscordConnectorConfig {
     /** Unique instance identifier (e.g. "discord-vox") */
     id?: string;
@@ -14,6 +14,10 @@ export interface DiscordConnectorConfig {
     channelRouting?: Record<string, string>;
     /** If set, this instance proxies all Discord operations through the primary instance at this URL */
     proxyVia?: string;
+    /** Deterministic per-scope response gate (DM / channel). See DiscordRespondToConfig. */
+    respondTo?: DiscordRespondToConfig;
+    /** Where responses land in flat guild channels. Default: "channel". */
+    replyStyle?: DiscordReplyStyle;
 }
 export declare class DiscordConnector implements Connector {
     name: string;
@@ -26,6 +30,16 @@ export declare class DiscordConnector implements Connector {
     private status;
     private lastError;
     private typingIntervals;
+    private engagedThreads;
+    private readonly replyStyle;
+    /**
+     * Channels where thread creation failed for a channel-level reason
+     * (missing permission / access). Both the session keying and the reply
+     * destination consult this, so after one failed turn the channel settles
+     * into consistent reply-style behavior instead of splitting every turn
+     * into a fresh thread-keyed session. In-memory; resets with the connector.
+     */
+    private readonly threadStyleFailed;
     constructor(config: DiscordConnectorConfig);
     onMessage(handler: (msg: IncomingMessage) => void): void;
     getEmployee(): string | undefined;
@@ -36,11 +50,77 @@ export declare class DiscordConnector implements Connector {
     reconstructTarget(replyContext: Record<string, unknown> | null | undefined): Target;
     sendMessage(target: Target, text: string): Promise<string | undefined>;
     replyMessage(target: Target, text: string): Promise<string | undefined>;
+    /**
+     * Send a response in Discord-sized chunks. Only the first chunk carries
+     * the reply reference — one visual attachment per response, the rest
+     * reads as its continuation. Engagement is recorded per delivered chunk,
+     * so a partial send still counts. Failures are returned, not thrown, so
+     * the caller can see how far the send got.
+     */
+    private sendChunks;
+    /**
+     * Where a response physically lands. Threads and DMs are already precise
+     * destinations and ignore replyStyle. In flat guild channels: "reply"
+     * attaches the response to the triggering message, "thread" opens (or
+     * reuses) the thread rooted on it, and "channel" keeps the legacy plain
+     * send. The thread path falls back to "reply" when the channel can't host
+     * message threads (voice/stage text chat) or when Discord refuses — a
+     * channel-level refusal (missing permission/access) is remembered so the
+     * session keying in handleMessage stops splitting turns into thread keys.
+     */
+    private resolveReplyDestination;
     editMessage(target: Target, text: string): Promise<void>;
     addReaction(target: Target, emoji: string): Promise<void>;
     removeReaction(target: Target, emoji: string): Promise<void>;
     setTypingStatus(channelId: string, _threadTs: string | undefined, status: string): Promise<void>;
     private handleMessage;
+    /**
+     * True when this flat-channel message's session should be keyed to the
+     * thread the reply will open (replyStyle=thread). Mirrors exactly the
+     * conditions under which resolveReplyDestination will actually attempt a
+     * thread, so the session key and the reply destination never diverge:
+     * channels that can't host message threads, channels where the bot lacks
+     * the thread permissions right now (checked per turn against the live
+     * permission cache), and channels where creation already failed at the
+     * channel level all stay channel-keyed from the first turn.
+     */
+    private threadSessionEligible;
+    /**
+     * Pre-flight permission check for thread style, evaluated against the
+     * cached guild permissions so it costs no request. Optimistic when the
+     * answer is unknowable (no permissionsFor on the channel shape, member
+     * not cached) — the failure path in replyMessage self-heals those.
+     */
+    private canOpenThreads;
+    /**
+     * Track engagement for the `respondTo.engagedThreads` continuation. Only
+     * anchor-eligible IDs whose engagement can actually be consumed are kept:
+     * the thread itself, or — in flat guild channels — the acted-on message,
+     * since a public thread created from a message reuses its ID. DM and
+     * in-thread message IDs can never root a thread and are never recorded,
+     * which keeps the unbounded tracker's real footprint small.
+     */
+    private recordEngagement;
+    /**
+     * True when engagement recorded under this id can ever be read back. The
+     * local gate consults the tracker only when the channel scope is
+     * mention-gated with engagedThreads on (DMs have no threads, so dm=mention
+     * alone consumes nothing). The routed path consults it for messages whose
+     * channel id — or, for threads, parent channel id — is a channelRouting
+     * key; for a flat-channel anchor the future thread's parent is the channel
+     * itself, so its route counts too.
+     */
+    private consumesEngagement;
+    /**
+     * Resolve who the message addresses. Reply attribution applies only to
+     * actual replies (`MessageType.Reply`) — a crosspost or forward also
+     * carries a `reference` but addresses nobody. `mentions.repliedUser` comes
+     * from the gateway's resolved reference and works whether or not the reply
+     * pinged; when Discord omitted the resolution and `allowFetch` is set,
+     * fall back to one fetch of the referenced message. A deleted reference
+     * stays undefined — no addressee.
+     */
+    private resolveAddressing;
     /** Forward a message to a remote Jinn instance via HTTP */
     private proxyToRemote;
 }

package/dist/src/connectors/discord/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/connectors/discord/index.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EACV,SAAS,EACT,qBAAqB,EACrB,eAAe,EACf,eAAe,EACf,MAAM,EACP,MAAM,uBAAuB,CAAC;AAM/B,MAAM,WAAW,sBAAsB;IACrC,sDAAsD;IACtD,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,+DAA+D;IAC/D,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IAC9B,uBAAuB,CAAC,EAAE,OAAO,CAAC;IAClC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,uFAAuF;IACvF,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,qEAAqE;IACrE,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACxC,oGAAoG;IACpG,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,qBAAa,gBAAiB,YAAW,SAAS;IAChD,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,MAAM,CAAyB;IACvC,OAAO,CAAC,OAAO,CAAiD;IAChE,OAAO,CAAC,UAAU,CAAc;IAChC,OAAO,CAAC,cAAc,CAAc;IACpC,OAAO,CAAC,MAAM,CAA4D;IAC1E,OAAO,CAAC,SAAS,CAAuB;IACxC,OAAO,CAAC,eAAe,CAAqD;gBAEhE,MAAM,EAAE,sBAAsB;IA+B1C,SAAS,CAAC,OAAO,EAAE,CAAC,GAAG,EAAE,eAAe,KAAK,IAAI,GAAG,IAAI;IAIxD,WAAW,IAAI,MAAM,GAAG,SAAS;IAI3B,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAuBtB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAM3B,eAAe,IAAI,qBAAqB;IASxC,SAAS,IAAI,eAAe;IAQ5B,iBAAiB,CAAC,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM;IAS7E,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC;IAgBtE,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC;IAgBvE,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAYxD,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAYzD,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAY5D,eAAe,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,SAAS,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;YAwBxF,aAAa;IA2E3B,2DAA2D;YAC7C,aAAa;CAwC5B"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/connectors/discord/index.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EACV,SAAS,EACT,qBAAqB,EACrB,eAAe,EACf,iBAAiB,EACjB,sBAAsB,EACtB,eAAe,EACf,MAAM,EACP,MAAM,uBAAuB,CAAC;AAoB/B,MAAM,WAAW,sBAAsB;IACrC,sDAAsD;IACtD,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,+DAA+D;IAC/D,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IAC9B,uBAAuB,CAAC,EAAE,OAAO,CAAC;IAClC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,uFAAuF;IACvF,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,qEAAqE;IACrE,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACxC,oGAAoG;IACpG,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,wFAAwF;IACxF,SAAS,CAAC,EAAE,sBAAsB,CAAC;IACnC,uEAAuE;IACvE,UAAU,CAAC,EAAE,iBAAiB,CAAC;CAChC;AAED,qBAAa,gBAAiB,YAAW,SAAS;IAChD,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,MAAM,CAAyB;IACvC,OAAO,CAAC,OAAO,CAAiD;IAChE,OAAO,CAAC,UAAU,CAAc;IAChC,OAAO,CAAC,cAAc,CAAc;IACpC,OAAO,CAAC,MAAM,CAA4D;IAC1E,OAAO,CAAC,SAAS,CAAuB;IACxC,OAAO,CAAC,eAAe,CAAqD;IAC5E,OAAO,CAAC,cAAc,CAA8B;IACpD,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAoB;IAC/C;;;;;;OAMG;IACH,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAqB;gBAE3C,MAAM,EAAE,sBAAsB;IAoC1C,SAAS,CAAC,OAAO,EAAE,CAAC,GAAG,EAAE,eAAe,KAAK,IAAI,GAAG,IAAI;IAIxD,WAAW,IAAI,MAAM,GAAG,SAAS;IAI3B,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IA0BtB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAM3B,eAAe,IAAI,qBAAqB;IASxC,SAAS,IAAI,eAAe;IAQ5B,iBAAiB,CAAC,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM;IAS7E,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC;IAetE,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC;IAkE7E;;;;;;OAMG;YACW,UAAU;IA0BxB;;;;;;;;;OASG;YACW,uBAAuB;IA0C/B,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAYxD,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAazD,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAY5D,eAAe,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,SAAS,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;YAwBxF,aAAa;IA0I3B;;;;;;;;;OASG;IACH,OAAO,CAAC,qBAAqB;IAW7B;;;;;OAKG;IACH,OAAO,CAAC,cAAc;IAatB;;;;;;;OAOG;IACH,OAAO,CAAC,gBAAgB;IAmBxB;;;;;;;;OAQG;IACH,OAAO,CAAC,kBAAkB;IAW1B;;;;;;;;OAQG;YACW,iBAAiB;IAyB/B,2DAA2D;YAC7C,aAAa;CA0D5B"}

package/dist/src/connectors/discord/index.js

@@ -1,8 +1,10 @@
-import { Client, GatewayIntentBits, Partials, } from "discord.js";
+import { Client, GatewayIntentBits, MessageType, Partials, PermissionFlagsBits, } from "discord.js";
 import { logger } from "../../shared/logger.js";
 import { TMP_DIR } from "../../shared/paths.js";
 import { formatResponse, downloadAttachment } from "./format.js";
-import { deriveSessionKey, buildReplyContext, isOldMessage } from "./threads.js";
+import { deriveSessionKey, buildReplyContext, isOldMessage, threadNameFor, supportsMessageThreads, } from "./threads.js";
+import { evaluateRespondPolicy, resolveRespondMode, wasBotAddressed, addressesOnlyOthers, } from "./respond-policy.js";
+import { EngagedThreadTracker } from "./engaged-threads.js";
 export class DiscordConnector {
     name;
     instanceId;
@@ -14,10 +16,25 @@ export class DiscordConnector {
     status = "starting";
     lastError = null;
     typingIntervals = new Map();
+    engagedThreads = new EngagedThreadTracker();
+    replyStyle;
+    /**
+     * Channels where thread creation failed for a channel-level reason
+     * (missing permission / access). Both the session keying and the reply
+     * destination consult this, so after one failed turn the channel settles
+     * into consistent reply-style behavior instead of splitting every turn
+     * into a fresh thread-keyed session. In-memory; resets with the connector.
+     */
+    threadStyleFailed = new Set();
     constructor(config) {
         this.name = config.id || "discord";
         this.instanceId = config.id || "discord";
         this.config = config;
+        // Hand-edited YAML: an invalid value degrades to the legacy behavior.
+        this.replyStyle =
+            config.replyStyle === "reply" || config.replyStyle === "thread"
+                ? config.replyStyle
+                : "channel";
         // Normalize Discord IDs to strings (YAML may parse large snowflake IDs as numbers)
         if (this.config.guildId)
             this.config.guildId = String(this.config.guildId);
@@ -52,6 +69,9 @@ export class DiscordConnector {
         this.client.on("ready", () => {
             logger.info(`Discord connector ready as ${this.client.user?.tag}`);
             this.status = "running";
+            // Permissions may have changed while disconnected — let thread style
+            // re-attempt channels it had given up on.
+            this.threadStyleFailed.clear();
         });
         this.client.on("messageCreate", async (message) => {
             try {
@@ -101,13 +121,10 @@ export class DiscordConnector {
             const channel = await this.client.channels.fetch(target.channel);
             if (!channel || !channel.isTextBased())
                 return;
-            const chunks = formatResponse(text);
-            let lastId;
-            for (const chunk of chunks) {
-                const sent = await channel.send(chunk);
-                lastId = sent.id;
-            }
-            return lastId;
+            const result = await this.sendChunks({ channel: channel }, text);
+            if (result.error !== undefined)
+                throw result.error;
+            return result.lastId;
         }
         catch (err) {
             logger.error(`Discord sendMessage error: ${err instanceof Error ? err.message : err}`);
@@ -118,18 +135,135 @@ export class DiscordConnector {
             const channel = await this.client.channels.fetch(target.thread ?? target.channel);
             if (!channel || !channel.isTextBased())
                 return;
-            const chunks = formatResponse(text);
-            let lastId;
-            for (const chunk of chunks) {
-                const sent = await channel.send(chunk);
-                lastId = sent.id;
+            const destination = await this.resolveReplyDestination(channel, target);
+            const result = await this.sendChunks(destination, text);
+            // A thread that accepts nothing (locked archive, missing
+            // SEND_MESSAGES_IN_THREADS, private-thread access) must not swallow
+            // the response: if not a single chunk landed in any thread — the one
+            // thread style just opened, or the thread the message arrived in —
+            // retry as a reply in the parent channel. A partial send stays where
+            // it is; resending would duplicate the delivered chunks.
+            if (result.error !== undefined && result.sentCount === 0 && destination.channel.isThread()) {
+                // In the thread-style path `channel` is the flat parent we fetched
+                // to resolve the thread; for a direct thread target the parent
+                // comes from the thread itself.
+                const parent = destination.viaThreadStyle
+                    ? channel
+                    : await this.client.channels
+                        .fetch(destination.channel.parentId ?? "")
+                        .catch(() => null);
+                // A permission-shaped refusal will keep failing — remember it so
+                // thread style stops opening threads nobody can post in. The
+                // pre-flight permission check catches most of these; this covers
+                // API-level denials that slip through.
+                const code = result.error.code;
+                if (code === 50013 || code === 50001) {
+                    const parentId = destination.viaThreadStyle
+                        ? channel.id
+                        : destination.channel.parentId;
+                    if (parentId)
+                        this.threadStyleFailed.add(parentId);
+                }
+                logger.warn(`[discord] sending into thread ${destination.channel.id} failed (${result.error instanceof Error ? result.error.message : result.error}) — falling back to a reply in the parent channel`);
+                if (parent && parent.isTextBased() && !parent.isThread()) {
+                    const retry = await this.sendChunks(
+                    // A reply reference must live in the parent channel — in-thread
+                    // message IDs are invisible there. A message-rooted thread
+                    // shares its starter message's ID, so referencing the thread ID
+                    // attaches the fallback to the conversation's root (and merely
+                    // degrades to a plain post for channel-rooted threads, thanks
+                    // to failIfNotExists: false).
+                    { channel: parent, replyTo: destination.channel.id }, text);
+                    if (retry.error !== undefined)
+                        throw retry.error;
+                    return retry.lastId;
+                }
+                throw result.error;
             }
-            return lastId;
+            if (result.error !== undefined && result.sentCount === 0)
+                throw result.error;
+            if (result.error !== undefined) {
+                logger.error(`Discord replyMessage partial send (${result.sentCount} chunk(s) delivered): ${result.error instanceof Error ? result.error.message : result.error}`);
+            }
+            return result.lastId;
         }
         catch (err) {
             logger.error(`Discord replyMessage error: ${err instanceof Error ? err.message : err}`);
         }
     }
+    /**
+     * Send a response in Discord-sized chunks. Only the first chunk carries
+     * the reply reference — one visual attachment per response, the rest
+     * reads as its continuation. Engagement is recorded per delivered chunk,
+     * so a partial send still counts. Failures are returned, not thrown, so
+     * the caller can see how far the send got.
+     */
+    async sendChunks(destination, text) {
+        const chunks = formatResponse(text);
+        let lastId;
+        let sentCount = 0;
+        for (const [index, chunk] of chunks.entries()) {
+            try {
+                const sent = destination.replyTo !== undefined && index === 0
+                    ? await destination.channel.send({
+                        content: chunk,
+                        reply: { messageReference: destination.replyTo, failIfNotExists: false },
+                    })
+                    : await destination.channel.send(chunk);
+                lastId = sent.id;
+                sentCount += 1;
+                this.recordEngagement(destination.channel, sent.id);
+            }
+            catch (error) {
+                return { lastId, sentCount, error };
+            }
+        }
+        return { lastId, sentCount };
+    }
+    /**
+     * Where a response physically lands. Threads and DMs are already precise
+     * destinations and ignore replyStyle. In flat guild channels: "reply"
+     * attaches the response to the triggering message, "thread" opens (or
+     * reuses) the thread rooted on it, and "channel" keeps the legacy plain
+     * send. The thread path falls back to "reply" when the channel can't host
+     * message threads (voice/stage text chat) or when Discord refuses — a
+     * channel-level refusal (missing permission/access) is remembered so the
+     * session keying in handleMessage stops splitting turns into thread keys.
+     */
+    async resolveReplyDestination(channel, target) {
+        if (channel.isThread() || channel.isDMBased())
+            return { channel };
+        if (!target.messageTs || this.replyStyle === "channel")
+            return { channel };
+        if (this.replyStyle === "reply" ||
+            !supportsMessageThreads(channel) ||
+            this.threadStyleFailed.has(channel.id) ||
+            !this.canOpenThreads(channel)) {
+            return { channel, replyTo: target.messageTs };
+        }
+        try {
+            // A message's thread shares its ID — fetch it directly instead of
+            // trusting the starter's cache (`Message#thread` misses archived
+            // threads, which aren't synced on startup).
+            const existing = await this.client.channels.fetch(target.messageTs).catch(() => null);
+            if (existing?.isThread()) {
+                return { channel: existing, viaThreadStyle: true };
+            }
+            const starter = await channel.messages.fetch(target.messageTs);
+            const thread = await starter.startThread({ name: threadNameFor(starter.content) });
+            return { channel: thread, viaThreadStyle: true };
+        }
+        catch (err) {
+            const code = err.code;
+            // 50013 Missing Permissions / 50001 Missing Access — channel-level,
+            // will keep failing; remember it. Anything else (deleted starter…)
+            // is message-level and the next turn starts clean.
+            if (code === 50013 || code === 50001)
+                this.threadStyleFailed.add(channel.id);
+            logger.warn(`[discord] could not open a thread on message ${target.messageTs} (${err instanceof Error ? err.message : err}) — falling back to a reply`);
+            return { channel, replyTo: target.messageTs };
+        }
+    }
     async editMessage(target, text) {
         try {
             if (!target.messageTs)
@@ -153,6 +287,7 @@ export class DiscordConnector {
                 return;
             const msg = await channel.messages.fetch(target.messageTs);
             await msg.react(emoji);
+            this.recordEngagement(channel, target.messageTs);
         }
         catch {
             // non-fatal
@@ -199,8 +334,9 @@ export class DiscordConnector {
         }
     }
     async handleMessage(message) {
-        // Ignore bots (including self)
-        if (message.author.bot)
+        // Ignore bots (including self), webhooks, and Discord-generated system
+        // messages (joins, pins, thread-created…) — none of these are user turns.
+        if (message.author.bot || message.system || message.webhookId)
             return;
         logger.debug(`Discord message from ${message.author.username} in channel ${message.channel.id}`);
         // Ignore old messages on boot
@@ -210,22 +346,74 @@ export class DiscordConnector {
         // Guild restriction
         if (this.config.guildId && message.guild?.id !== this.config.guildId)
             return;
-        // Channel routing — proxy messages to remote instances
-        const routeTarget = this.config.channelRouting?.[message.channel.id];
+        // Channel routing — proxy messages to remote instances. Addressing and
+        // thread engagement are resolved here and forwarded: only this instance
+        // sees the Discord gateway, and proxied sends run through this
+        // connector, so its tracker is the source of truth for engagement.
+        // Threads inherit their parent channel's route: a thread routes by its
+        // own id when explicitly configured, else by the channel it lives in —
+        // without this, a thread opened in a routed channel (replyStyle=thread
+        // creates one per conversation) would silently fall back to local
+        // handling.
+        const parentChannelId = message.channel.isThread()
+            ? message.channel.parentId ?? undefined
+            : undefined;
+        const routeTarget = this.config.channelRouting?.[message.channel.id] ??
+            (parentChannelId !== undefined ? this.config.channelRouting?.[parentChannelId] : undefined);
         if (routeTarget) {
             logger.debug(`Routing Discord message from channel ${message.channel.id} to ${routeTarget}`);
-            await this.proxyToRemote(routeTarget, message);
+            // References resolve only outside DMs here: the remote's dm policy is
+            // unknown, and a routed-DM reply matters only under its dm=mention —
+            // too rare to spend a REST fetch on every routed DM reply.
+            const addressing = await this.resolveAddressing(message, {
+                allowFetch: !message.channel.isDMBased(),
+            });
+            await this.proxyToRemote(routeTarget, message, addressing);
             return;
         }
-        // Channel restriction — only respond in a specific channel (+ DMs always allowed)
-        if (this.config.channelId && message.channel.id !== this.config.channelId && !message.channel.isDMBased())
+        // Channel restriction — only respond in a specific channel, including
+        // the threads that live in it (+ DMs always allowed)
+        if (this.config.channelId &&
+            message.channel.id !== this.config.channelId &&
+            parentChannelId !== this.config.channelId &&
+            !message.channel.isDMBased())
             return;
         // User allowlist
         if (this.allowedUserIds.size > 0 && !this.allowedUserIds.has(message.author.id))
             return;
+        // Deterministic respondTo gate — the Discord port of the Slack gate.
+        // Addressing resolves after the cheap filters above, so filtered
+        // messages never cost a reference fetch; in DMs the fetch only matters
+        // under dm=mention (the sibling rule below never applies to DMs).
+        // botUserId is set once the client is ready (messageCreate never fires
+        // earlier); if it were somehow missing, mention scopes fail closed.
+        const isDM = message.channel.isDMBased();
+        const addressing = await this.resolveAddressing(message, {
+            allowFetch: !isDM || resolveRespondMode(this.config.respondTo, "dm") === "mention",
+        });
+        const respondDecision = evaluateRespondPolicy({
+            config: this.config.respondTo,
+            isDM,
+            wasMentioned: wasBotAddressed(addressing),
+            isEngagedThread: message.channel.isThread() && this.engagedThreads.has(message.channel.id),
+        });
+        if (!respondDecision.allow) {
+            logger.info(`[discord] respondTo gate → silent (${respondDecision.reason}) for message ${message.id}`);
+            return;
+        }
+        // Cross-user traffic in shared channels: a message that @-mentions or
+        // replies to somebody else (and not us) is addressed to them, not the
+        // bot — stay silent regardless of respondTo mode or thread engagement,
+        // mirroring the Slack connector's sibling-mention rule.
+        if (!isDM && addressesOnlyOthers(addressing)) {
+            logger.info(`[discord] message addresses other user(s) — staying silent for message ${message.id}`);
+            return;
+        }
         if (!this.handler)
             return;
-        const sessionKey = deriveSessionKey(message, this.instanceId);
+        const sessionKey = deriveSessionKey(message, this.instanceId, {
+            threadPerMessage: this.threadSessionEligible(message),
+        });
         const replyContext = buildReplyContext(message);
         // Download attachments
         const attachments = await Promise.all(Array.from(message.attachments.values()).map(async (att) => {
@@ -265,8 +453,108 @@ export class DiscordConnector {
         };
         this.handler(incomingMessage);
     }
+    /**
+     * True when this flat-channel message's session should be keyed to the
+     * thread the reply will open (replyStyle=thread). Mirrors exactly the
+     * conditions under which resolveReplyDestination will actually attempt a
+     * thread, so the session key and the reply destination never diverge:
+     * channels that can't host message threads, channels where the bot lacks
+     * the thread permissions right now (checked per turn against the live
+     * permission cache), and channels where creation already failed at the
+     * channel level all stay channel-keyed from the first turn.
+     */
+    threadSessionEligible(message) {
+        return (this.replyStyle === "thread" &&
+            !message.channel.isDMBased() &&
+            !message.channel.isThread() &&
+            supportsMessageThreads(message.channel) &&
+            !this.threadStyleFailed.has(message.channel.id) &&
+            this.canOpenThreads(message.channel));
+    }
+    /**
+     * Pre-flight permission check for thread style, evaluated against the
+     * cached guild permissions so it costs no request. Optimistic when the
+     * answer is unknowable (no permissionsFor on the channel shape, member
+     * not cached) — the failure path in replyMessage self-heals those.
+     */
+    canOpenThreads(channel) {
+        const me = this.client.user;
+        if (!me || typeof channel.permissionsFor !== "function")
+            return true;
+        const perms = channel.permissionsFor(me);
+        if (!perms)
+            return true;
+        return (perms.has(PermissionFlagsBits.CreatePublicThreads) &&
+            perms.has(PermissionFlagsBits.SendMessagesInThreads));
+    }
+    /**
+     * Track engagement for the `respondTo.engagedThreads` continuation. Only
+     * anchor-eligible IDs whose engagement can actually be consumed are kept:
+     * the thread itself, or — in flat guild channels — the acted-on message,
+     * since a public thread created from a message reuses its ID. DM and
+     * in-thread message IDs can never root a thread and are never recorded,
+     * which keeps the unbounded tracker's real footprint small.
+     */
+    recordEngagement(channel, anchorMessageId) {
+        if (channel.isThread()) {
+            if (this.consumesEngagement(channel.id, channel.parentId ?? undefined)) {
+                this.engagedThreads.record(channel.id);
+            }
+            return;
+        }
+        if (anchorMessageId &&
+            !channel.isDMBased() &&
+            this.consumesEngagement(anchorMessageId, channel.id)) {
+            this.engagedThreads.record(anchorMessageId);
+        }
+    }
+    /**
+     * True when engagement recorded under this id can ever be read back. The
+     * local gate consults the tracker only when the channel scope is
+     * mention-gated with engagedThreads on (DMs have no threads, so dm=mention
+     * alone consumes nothing). The routed path consults it for messages whose
+     * channel id — or, for threads, parent channel id — is a channelRouting
+     * key; for a flat-channel anchor the future thread's parent is the channel
+     * itself, so its route counts too.
+     */
+    consumesEngagement(id, parentChannelId) {
+        if (resolveRespondMode(this.config.respondTo, "channel") === "mention" &&
+            this.config.respondTo?.engagedThreads !== false) {
+            return true;
+        }
+        if (this.config.channelRouting?.[id] !== undefined)
+            return true;
+        return parentChannelId !== undefined && this.config.channelRouting?.[parentChannelId] !== undefined;
+    }
+    /**
+     * Resolve who the message addresses. Reply attribution applies only to
+     * actual replies (`MessageType.Reply`) — a crosspost or forward also
+     * carries a `reference` but addresses nobody. `mentions.repliedUser` comes
+     * from the gateway's resolved reference and works whether or not the reply
+     * pinged; when Discord omitted the resolution and `allowFetch` is set,
+     * fall back to one fetch of the referenced message. A deleted reference
+     * stays undefined — no addressee.
+     */
+    async resolveAddressing(message, opts) {
+        const isReply = message.type === MessageType.Reply;
+        let repliedToUserId = isReply ? message.mentions.repliedUser?.id : undefined;
+        if (isReply && repliedToUserId === undefined && opts.allowFetch && message.reference?.messageId) {
+            try {
+                const referenced = await message.fetchReference();
+                repliedToUserId = referenced.author?.id;
+            }
+            catch {
+                // Referenced message deleted or inaccessible.
+            }
+        }
+        return {
+            botUserId: this.client.user?.id,
+            mentionedUserIds: new Set(message.mentions.users.keys()),
+            repliedToUserId,
+        };
+    }
     /** Forward a message to a remote Jinn instance via HTTP */
-    async proxyToRemote(remoteUrl, message) {
+    async proxyToRemote(remoteUrl, message, addressing) {
         try {
             const attachments = Array.from(message.attachments.values()).map((att) => ({
                 name: att.name,
@@ -274,7 +562,11 @@ export class DiscordConnector {
                 mimeType: att.contentType ?? "application/octet-stream",
             }));
             const payload = {
-                sessionKey: deriveSessionKey(message),
+                // The primary's replyStyle renders every proxied send, so its
+                // thread-per-message session mapping applies to routed channels too.
+                sessionKey: deriveSessionKey(message, undefined, {
+                    threadPerMessage: this.threadSessionEligible(message),
+                }),
                 channel: message.channel.id,
                 thread: message.channel.isThread() ? message.channel.id : undefined,
                 user: message.author.username,
@@ -289,6 +581,15 @@ export class DiscordConnector {
                         : "dm",
                     guildId: message.guild?.id ?? null,
                     isDM: message.channel.isDMBased(),
+                    // Precomputed here (only this instance knows the bot user,
+                    // resolves references, and tracks engagement) so the receiving
+                    // instance can apply its own respondTo gate without another
+                    // Discord round-trip.
+                    ...{
+                        wasBotAddressed: wasBotAddressed(addressing),
+                        addressesOnlyOthers: addressesOnlyOthers(addressing),
+                        isEngagedThread: message.channel.isThread() && this.engagedThreads.has(message.channel.id),
+                    },
                 },
             };
             const res = await fetch(`${remoteUrl.replace(/\/+$/, "")}/api/connectors/discord/incoming`, {