@agent-native/core 0.149.1 → 0.149.3

package/dist/client/use-chat-models.js

@@ -6,6 +6,22 @@ import { fetchBuilderStatus, fetchEnvironmentStatus, } from "./client-status-req
 import { callAction } from "./use-action.js";
 const DEFAULT_STORAGE_KEY = "agent-native:chat-models:selection";
 export const CHAT_MODEL_SELECTION_CHANGED_EVENT = "agent-native:chat-model-selection-changed";
+const MODEL_DISCOVERY_RETRY_DELAYS_MS = [250, 1_000];
+async function fetchEngineCatalog() {
+    try {
+        const result = (await callAction("manage-agent-engine", { action: "list" }));
+        if (!result ||
+            typeof result !== "object" ||
+            !("engines" in result) ||
+            !Array.isArray(result.engines)) {
+            return { state: "unavailable" };
+        }
+        return { state: "available", value: result };
+    }
+    catch {
+        return { state: "unavailable" };
+    }
+}
 function readPersisted(key) {
     if (!key || typeof window === "undefined")
         return {};
@@ -50,6 +66,9 @@ export function useChatModels({ storageKey = DEFAULT_STORAGE_KEY, enabled = true
         selectedEngine,
         selectedEffort,
     });
+    const mountedRef = useRef(true);
+    const refreshGenerationRef = useRef(0);
+    const retryTimerRef = useRef(null);
     useEffect(() => {
         selectionRef.current = {
             selectedModel,
@@ -109,98 +128,155 @@ export function useChatModels({ storageKey = DEFAULT_STORAGE_KEY, enabled = true
     const refreshEngines = useCallback(() => {
         if (!enabled)
             return;
+        refreshGenerationRef.current += 1;
+        const refreshGeneration = refreshGenerationRef.current;
+        if (retryTimerRef.current !== null) {
+            clearTimeout(retryTimerRef.current);
+            retryTimerRef.current = null;
+        }
         setIsLoading(true);
-        Promise.all([
-            callAction("manage-agent-engine", { action: "list" }).catch(() => null),
-            fetchEnvironmentStatus(),
-            fetchBuilderStatus(),
-        ])
-            .then(([enginesData, envResult, builderResult]) => {
-            if (!enginesData?.engines) {
-                // Without a catalog the picker keeps an unvalidated DEFAULT_MODEL,
-                // which is indistinguishable from a real selection unless we say so.
-                console.warn("[agent-chat] no engine list; model picker is showing an unvalidated default");
-                return;
-            }
-            if (envResult.state !== "available" ||
-                builderResult.state !== "available") {
+        const isCurrentRefresh = () => mountedRef.current && refreshGenerationRef.current === refreshGeneration;
+        const finish = () => {
+            if (isCurrentRefresh())
+                setIsLoading(false);
+        };
+        function scheduleRetry(attempt) {
+            const delay = MODEL_DISCOVERY_RETRY_DELAYS_MS[attempt];
+            if (delay === undefined || !isCurrentRefresh())
+                return false;
+            retryTimerRef.current = setTimeout(() => {
+                retryTimerRef.current = null;
+                load(attempt + 1);
+            }, delay);
+            return true;
+        }
+        function load(attempt) {
+            if (!isCurrentRefresh())
                 return;
-            }
-            const envKeys = envResult.value;
-            const builderStatus = builderResult.value;
-            const configuredKeys = new Set(envKeys.filter((k) => k.configured).map((k) => k.key));
-            const builderConnected = builderStatus?.configured === true;
-            const currentEngineName = enginesData.current?.engine;
-            const currentModel = enginesData.current?.model;
-            const groups = buildChatModelGroups({
-                engines: enginesData.engines,
-                configuredKeys,
-                builderConnected,
-                currentEngineName,
-                currentModel,
-            });
-            const nextDefaultModel = currentModel ?? DEFAULT_MODEL;
-            setAvailableModels(groups);
-            setDefaultModel(nextDefaultModel);
-            const selection = selectionRef.current;
-            // Default only to a CONFIGURED group, and to nothing when there is
-            // none. `DEFAULT_MODEL` is a builder-gateway id that no group carries
-            // unless Builder is connected, and unconfigured groups are kept in the
-            // list for their connect affordance — so both `?? DEFAULT_MODEL` and
-            // `?? groups[0]` yield a selection the app cannot route, which the
-            // server silently replaces with its own default. An empty selection
-            // hides the picker instead of showing a model that will not be used.
-            const configuredGroups = groups.filter((g) => g.configured);
-            const resolveRoutableSelection = () => {
-                const group = configuredGroups.find((g) => g.models.includes(nextDefaultModel)) ??
-                    configuredGroups[0];
-                if (!group)
-                    return null;
-                const model = group.models.find((m) => m === nextDefaultModel) ?? group.models[0];
-                if (!model)
-                    return null;
-                return {
-                    model,
-                    engine: group.engine,
-                    effort: resolveReasoningEffortSelection(model, selection.selectedEffort),
+            Promise.all([
+                fetchEngineCatalog(),
+                fetchEnvironmentStatus(),
+                fetchBuilderStatus(),
+            ])
+                .then(([engineResult, envResult, builderResult]) => {
+                if (!isCurrentRefresh())
+                    return;
+                if (engineResult.state !== "available" ||
+                    envResult.state !== "available" ||
+                    builderResult.state !== "available") {
+                    if (scheduleRetry(attempt))
+                        return;
+                    if (engineResult.state !== "available") {
+                        // Without a catalog the picker keeps an unvalidated DEFAULT_MODEL,
+                        // which is indistinguishable from a real selection unless we say so.
+                        console.warn("[agent-chat] engine list unavailable; model picker is showing an unvalidated default");
+                    }
+                    finish();
+                    return;
+                }
+                const enginesData = engineResult.value;
+                const envKeys = envResult.value;
+                const builderStatus = builderResult.value;
+                const configuredKeys = new Set(envKeys.filter((k) => k.configured).map((k) => k.key));
+                const builderConnected = builderStatus?.configured === true;
+                const currentEngineName = enginesData.current?.engine;
+                const currentModel = enginesData.current?.model;
+                const groups = buildChatModelGroups({
+                    engines: enginesData.engines,
+                    configuredKeys,
+                    builderConnected,
+                    currentEngineName,
+                    currentModel,
+                });
+                const nextDefaultModel = currentModel ?? DEFAULT_MODEL;
+                setAvailableModels(groups);
+                setDefaultModel(nextDefaultModel);
+                const selection = selectionRef.current;
+                // Default only to a CONFIGURED group, and to nothing when there is
+                // none. `DEFAULT_MODEL` is a builder-gateway id that no group carries
+                // unless Builder is connected, and unconfigured groups are kept in the
+                // list for their connect affordance — so both `?? DEFAULT_MODEL` and
+                // `?? groups[0]` yield a selection the app cannot route, which the
+                // server silently replaces with its own default. An empty selection
+                // hides the picker instead of showing a model that will not be used.
+                const configuredGroups = groups.filter((g) => g.configured);
+                const resolveRoutableSelection = () => {
+                    const group = configuredGroups.find((g) => g.models.includes(nextDefaultModel)) ?? configuredGroups[0];
+                    if (!group)
+                        return null;
+                    const model = group.models.find((m) => m === nextDefaultModel) ??
+                        group.models[0];
+                    if (!model)
+                        return null;
+                    return {
+                        model,
+                        engine: group.engine,
+                        effort: resolveReasoningEffortSelection(model, selection.selectedEffort),
+                    };
+                };
+                const applyFallback = (persist) => {
+                    const next = resolveRoutableSelection();
+                    setSelectedModel(next?.model ?? "");
+                    setSelectedEngine(next?.engine ?? "");
+                    if (next) {
+                        setSelectedEffort(next.effort);
+                        if (persist)
+                            writePersisted(storageKey, next);
+                    }
                 };
-            };
-            const applyFallback = (persist) => {
-                const next = resolveRoutableSelection();
-                setSelectedModel(next?.model ?? "");
-                setSelectedEngine(next?.engine ?? "");
-                if (next) {
-                    setSelectedEffort(next.effort);
-                    if (persist)
-                        writePersisted(storageKey, next);
+                if (!hasExplicitSelectionRef.current) {
+                    applyFallback(false);
+                    finish();
+                    return;
                 }
-            };
-            if (!hasExplicitSelectionRef.current) {
-                applyFallback(false);
-                return;
-            }
-            const selectedGroup = groups.find((group) => group.models.includes(selection.selectedModel) &&
-                (!selection.selectedEngine ||
-                    group.engine === selection.selectedEngine));
-            if (selectedGroup) {
-                // Heal a selection stored without an engine (or with a stale one) so
-                // later submits carry the pair the catalog resolved.
-                if (selection.selectedEngine !== selectedGroup.engine) {
-                    setSelectedEngine(selectedGroup.engine);
+                const selectedGroup = groups.find((group) => group.models.includes(selection.selectedModel) &&
+                    (!selection.selectedEngine ||
+                        group.engine === selection.selectedEngine));
+                if (selectedGroup) {
+                    // Heal a selection stored without an engine (or with a stale one) so
+                    // later submits carry the pair the catalog resolved.
+                    if (selection.selectedEngine !== selectedGroup.engine) {
+                        setSelectedEngine(selectedGroup.engine);
+                    }
+                    finish();
+                    return;
                 }
-                return;
-            }
-            applyFallback(true);
-        })
-            .catch(() => { })
-            .finally(() => setIsLoading(false));
+                applyFallback(true);
+                finish();
+            })
+                .catch(() => {
+                if (!isCurrentRefresh())
+                    return;
+                if (!scheduleRetry(attempt))
+                    finish();
+            });
+        }
+        load(0);
     }, [enabled, storageKey]);
+    useEffect(() => {
+        mountedRef.current = true;
+        return () => {
+            mountedRef.current = false;
+            refreshGenerationRef.current += 1;
+            if (retryTimerRef.current !== null) {
+                clearTimeout(retryTimerRef.current);
+                retryTimerRef.current = null;
+            }
+        };
+    }, []);
     useEffect(() => {
         if (!enabled) {
+            refreshGenerationRef.current += 1;
+            if (retryTimerRef.current !== null) {
+                clearTimeout(retryTimerRef.current);
+                retryTimerRef.current = null;
+            }
             setIsLoading(false);
             return;
         }
         refreshEngines();
+        window.addEventListener("agent-engine:configured-changed", refreshEngines);
+        return () => window.removeEventListener("agent-engine:configured-changed", refreshEngines);
     }, [enabled, refreshEngines]);
     return {
         availableModels,

package/dist/client/use-run-stuck-detection.d.ts

@@ -18,6 +18,8 @@ export interface RunStuckState {
     lastProgressAt: number | null;
     /** Milliseconds since `lastProgressAt`, or null. */
     stuckSinceMs: number | null;
+    /** Last browser SSE sequence classified as real work progress, or null. */
+    lastProgressSeq: number | null;
     /** Server timestamp (ms) of the last process-alive heartbeat. */
     heartbeatAt: number | null;
     /** Milliseconds since `heartbeatAt`, computed against the server clock. */

package/dist/client/use-run-stuck-detection.js

@@ -1,5 +1,6 @@
 import { useEffect, useState, useCallback } from "react";
 import { createPollEngine } from "../shared/poll-engine.js";
+import { ACTIVE_RUN_STATE_EVENT, getActiveRun, } from "./active-run-state.js";
 import { agentNativePath } from "./api-path.js";
 const DEFAULT_STUCK_THRESHOLD_MS = 90_000;
 export const DEFAULT_BACKGROUND_STUCK_THRESHOLD_MS = 180_000;
@@ -20,6 +21,7 @@ const EMPTY_STATE = {
     status: null,
     lastProgressAt: null,
     stuckSinceMs: null,
+    lastProgressSeq: null,
     heartbeatAt: null,
     heartbeatSinceMs: null,
     dispatchMode: null,
@@ -37,6 +39,8 @@ export function useRunStuckDetection({ threadId, enabled = true, stuckThresholdM
         let cancelled = false;
         let snapshotTransitionTimer = null;
         let snapshotVersion = 0;
+        let lastObservedLocalProgressAt = null;
+        let lastObservedLocalProgressSeq = null;
         let consecutivePollFailures = 0;
         // The engine's own cadence varies per tick (idle backoff, error backoff),
         // which is why intervalMs below reads from this ref instead of a fixed
@@ -86,8 +90,14 @@ export function useRunStuckDetection({ threadId, enabled = true, stuckThresholdM
             const currentStuckSinceMs = snapshot.stuckSinceMs == null
                 ? null
                 : snapshot.stuckSinceMs + currentElapsedMs;
+            const currentLocalProgressSinceMs = snapshot.localProgressObservedAt == null
+                ? null
+                : Math.max(0, Date.now() - snapshot.localProgressObservedAt);
             const effectiveThresholdMs = effectiveThresholdFor(snapshot.dispatchMode, currentHeartbeatSinceMs);
-            const currentlyStuck = Boolean(currentStuckSinceMs != null &&
+            const localProgressFresh = Boolean(currentLocalProgressSinceMs != null &&
+                currentLocalProgressSinceMs <= effectiveThresholdMs);
+            const currentlyStuck = Boolean(!localProgressFresh &&
+                currentStuckSinceMs != null &&
                 currentStuckSinceMs > effectiveThresholdMs);
             const transitionDelaysMs = [];
             if (currentHeartbeatSinceMs != null &&
@@ -95,9 +105,14 @@ export function useRunStuckDetection({ threadId, enabled = true, stuckThresholdM
                 currentHeartbeatSinceMs < FRESH_BACKGROUND_HEARTBEAT_MS) {
                 transitionDelaysMs.push(FRESH_BACKGROUND_HEARTBEAT_MS - currentHeartbeatSinceMs + 1);
             }
-            if (currentStuckSinceMs != null && !currentlyStuck) {
+            if (!localProgressFresh &&
+                currentStuckSinceMs != null &&
+                !currentlyStuck) {
                 transitionDelaysMs.push(Math.max(1, effectiveThresholdMs - currentStuckSinceMs + 1));
             }
+            if (localProgressFresh && currentLocalProgressSinceMs != null) {
+                transitionDelaysMs.push(Math.max(1, effectiveThresholdMs - currentLocalProgressSinceMs + 1));
+            }
             if (transitionDelaysMs.length === 0)
                 return;
             // Both ages originate from the server clock. Advance those snapshots by
@@ -116,26 +131,66 @@ export function useRunStuckDetection({ threadId, enabled = true, stuckThresholdM
                 const nextStuckSinceMs = snapshot.stuckSinceMs == null
                     ? null
                     : snapshot.stuckSinceMs + elapsedSinceObservationMs;
+                const nextLocalProgressSinceMs = snapshot.localProgressObservedAt == null
+                    ? null
+                    : Math.max(0, Date.now() - snapshot.localProgressObservedAt);
                 const nextEffectiveThresholdMs = effectiveThresholdFor(snapshot.dispatchMode, nextHeartbeatSinceMs);
-                const nextIsStuck = Boolean(nextStuckSinceMs != null &&
+                const nextLocalProgressFresh = Boolean(nextLocalProgressSinceMs != null &&
+                    nextLocalProgressSinceMs <= nextEffectiveThresholdMs);
+                const nextIsStuck = Boolean(!nextLocalProgressFresh &&
+                    nextStuckSinceMs != null &&
                     nextStuckSinceMs > nextEffectiveThresholdMs);
                 setState((current) => {
                     if (version !== snapshotVersion ||
                         current.runId !== snapshot.runId ||
                         current.lastProgressAt !== snapshot.lastProgressAt ||
-                        current.heartbeatAt !== snapshot.heartbeatAt) {
+                        current.heartbeatAt !== snapshot.heartbeatAt ||
+                        current.lastProgressSeq !== snapshot.lastProgressSeq) {
                         return current;
                     }
                     return {
                         ...current,
                         isStuck: nextIsStuck,
-                        stuckSinceMs: nextStuckSinceMs,
+                        stuckSinceMs: nextLocalProgressFresh ? null : nextStuckSinceMs,
                         heartbeatSinceMs: nextHeartbeatSinceMs,
                     };
                 });
                 scheduleSnapshotTransition(snapshot, observedAtMs, version);
             }, delayMs);
         };
+        // A healthy SSE stream is a stronger local proof of progress than a
+        // delayed SQL timestamp. Listen only to the real-progress cursor - raw
+        // keepalives still advance the reconnect cursor but must not suppress the
+        // stuck detector forever.
+        const onActiveRunStateChange = (event) => {
+            const activeRun = (event.detail?.state ?? getActiveRun());
+            const progressSeq = activeRun?.lastProgressSeq ?? null;
+            const hasNewerProgress = typeof activeRun?.lastProgressObservedAt === "number" &&
+                (activeRun.lastProgressObservedAt >
+                    (lastObservedLocalProgressAt ?? -1) ||
+                    (activeRun.lastProgressObservedAt === lastObservedLocalProgressAt &&
+                        progressSeq != null &&
+                        progressSeq > (lastObservedLocalProgressSeq ?? -1)));
+            if (!activeRun ||
+                activeRun.threadId !== threadId ||
+                typeof activeRun.lastProgressObservedAt !== "number" ||
+                !hasNewerProgress) {
+                return;
+            }
+            lastObservedLocalProgressAt = activeRun.lastProgressObservedAt;
+            lastObservedLocalProgressSeq = progressSeq;
+            snapshotVersion += 1;
+            if (snapshotTransitionTimer)
+                clearTimeout(snapshotTransitionTimer);
+            snapshotTransitionTimer = null;
+            setState((current) => {
+                if (current.runId !== activeRun.runId || !current.isStuck) {
+                    return current;
+                }
+                return { ...current, isStuck: false, stuckSinceMs: null };
+            });
+        };
+        window.addEventListener(ACTIVE_RUN_STATE_EVENT, onActiveRunStateChange);
         const attempt = async (signal) => {
             let nextDelay = pollIntervalMs;
             try {
@@ -156,6 +211,14 @@ export function useRunStuckDetection({ threadId, enabled = true, stuckThresholdM
                     const heartbeatAt = data.heartbeatAt ?? null;
                     const heartbeatSinceMs = heartbeatAt != null ? nowMs - heartbeatAt : null;
                     const dispatchMode = typeof data.dispatchMode === "string" ? data.dispatchMode : null;
+                    const runId = data.runId ?? null;
+                    const activeRun = getActiveRun();
+                    const localProgressObservedAt = activeRun?.threadId === threadId && activeRun.runId === runId
+                        ? (activeRun.lastProgressObservedAt ?? null)
+                        : null;
+                    const localProgressSinceMs = localProgressObservedAt == null
+                        ? null
+                        : Math.max(0, Date.now() - localProgressObservedAt);
                     // A claimed durable worker with a fresh heartbeat can legitimately
                     // be waiting on a bounded long-running tool/sub-agent call. Still
                     // surface informational status at the normal background threshold;
@@ -166,25 +229,37 @@ export function useRunStuckDetection({ threadId, enabled = true, stuckThresholdM
                     const isStuck = Boolean(data.active &&
                         data.status === "running" &&
                         stuckSinceMs != null &&
-                        stuckSinceMs > effectiveThresholdMs);
+                        stuckSinceMs > effectiveThresholdMs &&
+                        (localProgressSinceMs == null ||
+                            localProgressSinceMs > effectiveThresholdMs));
                     const observedAtMs = Date.now();
                     const version = ++snapshotVersion;
                     scheduleSnapshotTransition({
                         active: data.active,
-                        runId: data.runId ?? null,
+                        runId,
                         status: data.status ?? null,
                         lastProgressAt,
                         stuckSinceMs,
+                        localProgressObservedAt,
+                        lastProgressSeq: activeRun?.threadId === threadId && activeRun.runId === runId
+                            ? (activeRun.lastProgressSeq ?? null)
+                            : null,
                         heartbeatAt,
                         heartbeatSinceMs,
                         dispatchMode,
                     }, observedAtMs, version);
                     setState({
                         isStuck,
-                        runId: data.runId ?? null,
+                        runId,
                         status: data.status ?? null,
                         lastProgressAt,
-                        stuckSinceMs,
+                        stuckSinceMs: localProgressSinceMs != null &&
+                            localProgressSinceMs <= effectiveThresholdMs
+                            ? null
+                            : stuckSinceMs,
+                        lastProgressSeq: activeRun?.threadId === threadId && activeRun.runId === runId
+                            ? (activeRun.lastProgressSeq ?? null)
+                            : null,
                         heartbeatAt,
                         heartbeatSinceMs,
                         dispatchMode,
@@ -245,6 +320,7 @@ export function useRunStuckDetection({ threadId, enabled = true, stuckThresholdM
             engine.stop();
             if (snapshotTransitionTimer)
                 clearTimeout(snapshotTransitionTimer);
+            window.removeEventListener(ACTIVE_RUN_STATE_EVENT, onActiveRunStateChange);
             document.removeEventListener("visibilitychange", onVisibilityChange);
         };
     }, [

package/dist/collab/awareness.d.ts

@@ -62,11 +62,11 @@ export declare const postAwareness: import("h3").EventHandlerWithFetch<import("h
     error: string;
     states?: undefined;
 } | {
+    error?: undefined;
     states: {
         clientId: number;
         state: string;
     }[];
-    error?: undefined;
 }>>;
 /**
  * GET /_agent-native/collab/:docId/users
@@ -77,9 +77,9 @@ export declare const getActiveUsers: import("h3").EventHandlerWithFetch<import("
     error: string;
     users?: undefined;
 } | {
+    error?: undefined;
     users: {
         clientId: number;
         lastSeen: number;
     }[];
-    error?: undefined;
 }>>;

package/dist/collab/routes.d.ts

@@ -26,8 +26,8 @@ export declare const getCollabState: import("h3").EventHandlerWithFetch<import("
  * Body: { update: string (base64), requestSource?: string }
  */
 export declare const postCollabUpdate: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
-    ok?: undefined;
     error: string;
+    ok?: undefined;
 } | {
     error?: undefined;
     ok: boolean;

package/dist/collab/struct-routes.d.ts

@@ -13,8 +13,8 @@
  * Body: { json: any, fieldName?: string, type?: "map"|"array", requestSource?: string }
  */
 export declare const postCollabJson: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
-    ok?: undefined;
     error: string;
+    ok?: undefined;
 } | {
     error?: undefined;
     ok: boolean;

package/dist/integrations/adapters/slack.d.ts

@@ -2,10 +2,6 @@ import type { PlatformAdapter, IncomingMessage } from "../types.js";
 export interface SlackAdapterOptions {
     /** Resolve the bot token for the exact Slack installation. */
     resolveBotToken?: (incoming: IncomingMessage) => Promise<string | undefined>;
-    /** Override active-thread detection for hosted adapters/tests. */
-    isThreadActive?: (incoming: IncomingMessage) => Promise<boolean>;
-    /** Override one-shot clarification-window consumption for tests. */
-    consumeAwaitingInput?: (incoming: IncomingMessage) => Promise<boolean>;
 }
 /**
  * Create a Slack platform adapter.

package/dist/integrations/adapters/slack.js

@@ -3,10 +3,8 @@ import { createError, getHeader, readRawBody } from "h3";
 import { resolveSecret } from "../../server/credential-provider.js";
 import { getRequestContext } from "../../server/request-context.js";
 import { getIntegrationRequestContext } from "../../server/request-context.js";
-import { consumeIntegrationAwaitingInput } from "../awaiting-input-store.js";
 import { createIntegrationControl } from "../controls-store.js";
 import { getActiveIntegrationInstallationByKey, listActiveIntegrationInstallationsForTenant, listIntegrationInstallations, resolveIntegrationTokenBundle, } from "../installations-store.js";
-import { hasActivePendingTask } from "../pending-tasks-store.js";
 import { slackInstallationKey } from "../slack-oauth.js";
 /** Slack's max message length */
 const SLACK_MAX_LENGTH = 4000;
@@ -195,10 +193,10 @@ export function slackAdapter(options = {}) {
                 // Ignore message edits and deletes
                 if (e.subtype === "message_changed" || e.subtype === "message_deleted")
                     return null;
-                // Handle DMs and explicit mentions. Ordinary channel replies are only
-                // accepted while this exact workspace-qualified thread has queued or
-                // executing work; broad message subscriptions must never invoke the
-                // agent for general channel chatter.
+                // Handle DMs and explicit mentions only. A channel thread can contain
+                // many human replies after an agent mention; each new agent turn must
+                // opt in with another explicit mention instead of inheriting the
+                // parent message's invocation.
                 const text = e.text?.trim();
                 if (!text)
                     return null;
@@ -211,8 +209,7 @@ export function slackAdapter(options = {}) {
                     ? e.channel_type === "im"
                     : typeof e.channel === "string" && e.channel.startsWith("D");
                 const isMention = e.type === "app_mention";
-                const isThreadReply = !isDm && !isMention && !!e.thread_ts;
-                if (!isDm && !isMention && !isThreadReply)
+                if (!isDm && !isMention)
                     return null;
                 // Remove bot mention from text (e.g., "<@U123> do something" → "do something")
                 const cleanText = text.replace(/<@[A-Z0-9]+>/g, "").trim();
@@ -227,7 +224,7 @@ export function slackAdapter(options = {}) {
                     text: cleanText,
                     senderName: e.user,
                     senderId: e.user,
-                    triggerKind: isDm ? "dm" : isMention ? "mention" : "thread_reply",
+                    triggerKind: isDm ? "dm" : "mention",
                     conversationType: isDm ? "dm" : "unknown",
                     tenantId: teamId,
                     // The signed Slack envelope authenticates the workspace, not the
@@ -256,27 +253,6 @@ export function slackAdapter(options = {}) {
                     replyRef: e.ts,
                     timestamp: Math.floor(parseFloat(e.ts) * 1000),
                 };
-                if (isThreadReply) {
-                    // An ordinary thread reply is narrowly admitted when either work is
-                    // still queued or the same Slack user is answering a fresh
-                    // integration-originated clarification. Consuming the latter is a
-                    // conditional SQL delete, so concurrent replies cannot both reopen
-                    // the agent and unrelated channel messages remain ignored.
-                    const answeredClarification = options.consumeAwaitingInput
-                        ? await options.consumeAwaitingInput(partialIncoming)
-                        : options.isThreadActive
-                            ? false
-                            : await consumeIntegrationAwaitingInput({
-                                platform: "slack",
-                                externalThreadId,
-                                requesterId: e.user,
-                            });
-                    const active = options.isThreadActive
-                        ? await options.isThreadActive(partialIncoming)
-                        : await hasActivePendingTask("slack", externalThreadId);
-                    if (!active && !answeredClarification)
-                        return null;
-                }
                 const token = await resolveBotToken(partialIncoming);
                 const threadPermalink = await resolveSlackThreadPermalink(e.channel, threadTs, token);
                 return {

package/dist/integrations/catalog.js

@@ -36,7 +36,7 @@ const BUILT_IN_CHANNEL_CATALOG = [
                 "Apply the Agent Native Slack manifest to enable Agent View and writable direct messages.",
                 "Configure the OAuth client id, client secret, and signing secret.",
                 "Enable Event Subscriptions and Interactivity with the documented URLs.",
-                "Subscribe to app_home_opened, app_context_changed, app_mention, and message.im/channels/groups, then use Add to Slack.",
+                "Subscribe to app_home_opened, app_context_changed, app_mention, and message.im, then use Add to Slack.",
             ],
         },
         credentialRequirements: [

package/dist/integrations/pending-tasks-store.d.ts

@@ -20,14 +20,6 @@ export interface PendingTask {
     updatedAt: number;
     completedAt: number | null;
 }
-/**
- * Whether a provider thread currently has queued or executing work.
- *
- * Messaging adapters use this to accept unmentioned replies only while an
- * agent task is active. This prevents broad message subscriptions from turning
- * every channel message into an agent invocation.
- */
-export declare function hasActivePendingTask(platform: string, externalThreadId: string): Promise<boolean>;
 /**
  * Insert a new pending task. Returns the generated task id.
  *