fix: kill stuck ACP child processes on startup and harden sessions in discord threads (#33699)

* Gateway: resolve agent.wait for chat.send runs

* Discord: harden ACP thread binding + listener timeout

* ACPX: handle already-exited child wait

* Gateway/Discord: address PR review findings

* Discord: keep ACP error-state thread bindings on startup

* gateway: make agent.wait dedupe bridge event-driven

* discord: harden ACP probe classification and cap startup fan-out

* discord: add cooperative timeout cancellation

* discord: fix startup probe concurrency helper typing

* plugin-sdk: avoid Windows root-alias shard timeout

* plugin-sdk: keep root alias reflection path non-blocking

* discord+gateway: resolve remaining PR review findings

* gateway+discord: fix codex review regressions

* Discord/Gateway: address Codex review findings

* Gateway: keep agent.wait lifecycle active with shared run IDs

* Discord: clean up status reactions on aborted runs

* fix: add changelog note for ACP/Discord startup hardening (#33699) (thanks @dutifulbob)

---------

Co-authored-by: Onur <2453968+osolmaz@users.noreply.github.com>

src/discord/monitor/message-handler.process.ts

@@ -60,6 +60,10 @@ function sleep(ms: number): Promise<void> {
 
 const DISCORD_TYPING_MAX_DURATION_MS = 20 * 60_000;
 
+function isProcessAborted(abortSignal?: AbortSignal): boolean {
+  return Boolean(abortSignal?.aborted);
+}
+
 export async function processDiscordMessage(ctx: DiscordMessagePreflightContext) {
   const {
     cfg,
@@ -105,16 +109,26 @@ export async function processDiscordMessage(ctx: DiscordMessagePreflightContext)
     route,
     commandAuthorized,
     discordRestFetch,
+    abortSignal,
   } = ctx;
+  if (isProcessAborted(abortSignal)) {
+    return;
+  }
 
   const ssrfPolicy = cfg.browser?.ssrfPolicy;
   const mediaList = await resolveMediaList(message, mediaMaxBytes, discordRestFetch, ssrfPolicy);
+  if (isProcessAborted(abortSignal)) {
+    return;
+  }
   const forwardedMediaList = await resolveForwardedMediaList(
     message,
     mediaMaxBytes,
     discordRestFetch,
     ssrfPolicy,
   );
+  if (isProcessAborted(abortSignal)) {
+    return;
+  }
   mediaList.push(...forwardedMediaList);
   const text = messageText;
   if (!text) {
@@ -585,6 +599,9 @@ export async function processDiscordMessage(ctx: DiscordMessagePreflightContext)
       humanDelay: resolveHumanDelayConfig(cfg, route.agentId),
       typingCallbacks,
       deliver: async (payload: ReplyPayload, info) => {
+        if (isProcessAborted(abortSignal)) {
+          return;
+        }
         const isFinal = info.kind === "final";
         if (payload.isReasoning) {
           // Reasoning/thinking payloads should not be delivered to Discord.
@@ -607,6 +624,9 @@ export async function processDiscordMessage(ctx: DiscordMessagePreflightContext)
 
           if (canFinalizeViaPreviewEdit) {
             await draftStream.stop();
+            if (isProcessAborted(abortSignal)) {
+              return;
+            }
             try {
               await editMessageDiscord(
                 deliverChannelId,
@@ -627,6 +647,9 @@ export async function processDiscordMessage(ctx: DiscordMessagePreflightContext)
           // Check if stop() flushed a message we can edit
           if (!finalizedViaPreviewMessage) {
             await draftStream.stop();
+            if (isProcessAborted(abortSignal)) {
+              return;
+            }
             const messageIdAfterStop = draftStream.messageId();
             if (
               typeof messageIdAfterStop === "string" &&
@@ -657,6 +680,9 @@ export async function processDiscordMessage(ctx: DiscordMessagePreflightContext)
             await draftStream.clear();
           }
         }
+        if (isProcessAborted(abortSignal)) {
+          return;
+        }
 
         const replyToId = replyReference.use();
         await deliverDiscordReply({
@@ -682,6 +708,9 @@ export async function processDiscordMessage(ctx: DiscordMessagePreflightContext)
         runtime.error?.(danger(`discord ${info.kind} reply failed: ${String(err)}`));
       },
       onReplyStart: async () => {
+        if (isProcessAborted(abortSignal)) {
+          return;
+        }
         await typingCallbacks.onReplyStart();
         await statusReactions.setThinking();
       },
@@ -689,13 +718,19 @@ export async function processDiscordMessage(ctx: DiscordMessagePreflightContext)
 
   let dispatchResult: Awaited<ReturnType<typeof dispatchInboundMessage>> | null = null;
   let dispatchError = false;
+  let dispatchAborted = false;
   try {
+    if (isProcessAborted(abortSignal)) {
+      dispatchAborted = true;
+      return;
+    }
     dispatchResult = await dispatchInboundMessage({
       ctx: ctxPayload,
       cfg,
       dispatcher,
       replyOptions: {
         ...replyOptions,
+        abortSignal,
         skillFilter: channelConfig?.skills,
         disableBlockStreaming:
           disableBlockStreamingForDraft ??
@@ -730,11 +765,22 @@ export async function processDiscordMessage(ctx: DiscordMessagePreflightContext)
           await statusReactions.setThinking();
         },
         onToolStart: async (payload) => {
+          if (isProcessAborted(abortSignal)) {
+            return;
+          }
           await statusReactions.setTool(payload.name);
         },
       },
     });
+    if (isProcessAborted(abortSignal)) {
+      dispatchAborted = true;
+      return;
+    }
   } catch (err) {
+    if (isProcessAborted(abortSignal)) {
+      dispatchAborted = true;
+      return;
+    }
     dispatchError = true;
     throw err;
   } finally {
@@ -752,21 +798,32 @@ export async function processDiscordMessage(ctx: DiscordMessagePreflightContext)
       markDispatchIdle();
     }
     if (statusReactionsEnabled) {
-      if (dispatchError) {
-        await statusReactions.setError();
+      if (dispatchAborted) {
+        if (removeAckAfterReply) {
+          void statusReactions.clear();
+        } else {
+          void statusReactions.restoreInitial();
+        }
       } else {
-        await statusReactions.setDone();
-      }
-      if (removeAckAfterReply) {
-        void (async () => {
-          await sleep(dispatchError ? DEFAULT_TIMING.errorHoldMs : DEFAULT_TIMING.doneHoldMs);
-          await statusReactions.clear();
-        })();
-      } else {
-        void statusReactions.restoreInitial();
+        if (dispatchError) {
+          await statusReactions.setError();
+        } else {
+          await statusReactions.setDone();
+        }
+        if (removeAckAfterReply) {
+          void (async () => {
+            await sleep(dispatchError ? DEFAULT_TIMING.errorHoldMs : DEFAULT_TIMING.doneHoldMs);
+            await statusReactions.clear();
+          })();
+        } else {
+          void statusReactions.restoreInitial();
+        }
       }
     }
   }
+  if (dispatchAborted) {
+    return;
+  }
 
   if (!dispatchResult?.queuedFinal) {
     if (isGuildMessage) {