cli-jaw 2.17.43 → 2.17.44

package/dist/src/slack/bot.js

@@ -1,3 +1,6 @@
+import { verifiedSlackWorkspace } from './verified-workspace.js';
+import { slackCredentialKey } from './tool-context.js';
+import { isSlackMention } from './events.js';
 // ─── Slack Bot ───────────────────────────────────────
 // Slack transport implementation for the cli-jaw messaging runtime.
 // Mirrors src/discord/bot.ts structurally: init/shutdown lifecycle, an inbound
@@ -14,10 +17,13 @@ import { isResetIntent } from '../orchestrator/pipeline.js';
 import { isContinueIntent } from '../orchestrator/parser.js';
 import { setLastActiveTarget, setLatestSeenTarget, getLastActiveTarget, revokeMessagingTransport, startMessagingTransport, transportStarted, transportNotStarted, } from '../messaging/runtime.js';
 import { slackTargetFromId, resolveSlackThreadPlacement } from '../messaging/slack-target.js';
+import { isRemoteTarget } from '../messaging/types.js';
+import { sessionLanes } from '../orchestrator/session-lanes.js';
+import { createSlackReplyDeliveryLedger } from './reply-delivery.js';
 import { buildMediaPromptMany } from '../agent/spawn.js';
-import { addSlackReaction, describeSlackError, removeSlackReaction, slackApi, SLACK_CLEANUP_TIMEOUT_MS, } from './api.js';
+import { addSlackReaction, describeSlackError, removeSlackReaction, slackApi, } from './api.js';
 import { createAckHandle, resolveAckConfig, shouldAck, SLACK_ACK_DEFAULTS, } from '../messaging/ack-reaction.js';
-import { createQueueNotice, QueueNoticeRegistry, } from '../messaging/queue-notice.js';
+import { QueueNoticeRegistry } from '../messaging/queue-notice.js';
 import { OutboundSendRegistry } from '../messaging/outbound-lifecycle.js';
 import { recordSlackScopeObservation, getSlackScopeStatus, describeSlackScopeGaps, resetSlackScopeStatus, } from './scope-status.js';
 import { HELLO_DEADLINE_MS, SlackSocketClient } from './socket.js';
@@ -26,16 +32,16 @@ import { runSlackAutoJoin, mergeSlackAutoJoin } from './auto-join.js';
 import { createHash } from 'node:crypto';
 import { admitIngress, getIngressJournal } from '../messaging/durable-ingress.js';
 import { getQueueNoticeStore } from '../messaging/queue-notice-store.js';
-import { restoreQueueNotices } from '../messaging/queue-notice-restore.js';
 import { createSlackNoticeTransport } from './notice-transport.js';
 import { currentGenerationForEnvelope } from '../messaging/ingress-generation.js';
 import { slackInboundEnvelope } from '../messaging/inbound-envelope.js';
 import { readSlackAllowlist, resolveEventText, shouldAttachSlack, shouldProcessSlackEvent } from './events.js';
 import { markThreadParticipated, threadParticipationKind, claimThreadPrefetch, commitThreadPrefetch, releaseThreadPrefetch, resetThreadPrefetchClaims, } from './thread-tracker.js';
 import { sendSlackText, getSlackSendClient } from './send-only-client.js';
-import { startSlackProgress, statusFromToolEvent } from './progress.js';
+import { createSlackProgressLifecycle } from './progress-lifecycle.js';
+import { createSlackProgressRestorer } from './progress-restore.js';
 import { createSlackForwarder, relaySlackImages } from './forwarder.js';
-import { nextDeliverySeq, pendingDeliveryAnchor, wasSelfDelivered } from '../messaging/turn-delivery.js';
+import { nextDeliverySeq, wasSelfDelivered } from '../messaging/turn-delivery.js';
 import { shouldSkipForwarding } from '../messaging/forwarder-origin.js';
 import { handleSlackSlashCommand } from './commands.js';
 import { logErrorText, redactOutboundText } from '../messaging/redact.js';
@@ -72,7 +78,32 @@ const pendingQueueRequestIds = new Set();
  * turn that never answered gets its notice rewritten rather than left claiming
  * the agent is still working on it.
  */
-const slackNoticeRegistry = new QueueNoticeRegistry();
+const slackProgressRegistry = new QueueNoticeRegistry();
+const slackProgressSealers = new Set();
+const liveSlackProgressRequestIds = new Set();
+let slackStopping = false;
+const SLACK_PROGRESS_DRAIN_MS = 1500;
+const SLACK_QUEUE_WAIT_MS = 300000;
+const SLACK_RUN_IDLE_MS = 1200000;
+function registerSlackProgressTeardown(requestId, seal, drain) {
+    slackProgressSealers.add(seal);
+    liveSlackProgressRequestIds.add(requestId);
+    const unregister = slackProgressRegistry.add(drain);
+    return () => {
+        unregister();
+        slackProgressSealers.delete(seal);
+        liveSlackProgressRequestIds.delete(requestId);
+    };
+}
+const slackProgressRestorer = createSlackProgressRestorer({
+    getStore: getQueueNoticeStore,
+    getToken: () => getSlackSendClient().token,
+    getGeneration: () => lifecycleGeneration,
+    isLive: id => pendingQueueRequestIds.has(id) || liveSlackProgressRequestIds.has(id),
+    getLocale: currentLocale,
+    registerDrain: drain => slackProgressRegistry.add(drain),
+    onError: () => log.info('[slack:progress] restore incomplete'),
+});
 /**
  * In-flight ANSWER sends (#417). The notice registry above cancels cleanup;
  * this one cancels the answer body, chunk-retry sleeps, and image uploads —
@@ -85,12 +116,6 @@ const slackOutboundRegistry = new OutboundSendRegistry();
  * the running apply can still be in flight ahead of both.
  */
 const SLACK_ACK_TIMEOUT_MS = 2500;
-/**
- * Long enough for the worst honest chain — running apply, terminal remove,
- * terminal apply, plus one notice call — so a slow-but-working Slack finishes
- * inside the deadline instead of being cut off by it.
- */
-const SLACK_NOTICE_DRAIN_MS = SLACK_CLEANUP_TIMEOUT_MS + SLACK_ACK_TIMEOUT_MS * 2;
 /** Live ack config, re-read per turn so a settings change needs no restart. */
 function slackAckConfig() {
     return resolveAckConfig(settings["slack"]?.ack, SLACK_ACK_DEFAULTS);
@@ -169,42 +194,28 @@ function closeSlackNoticeRecord(requestId) {
  * delete the notice message and drop the record. Best-effort like every other
  * durable-notice touch; the answer is already out.
  */
-async function closeSlackNoticeAsAnsweredByRequestId(requestId) {
+async function closeSlackNoticeAsAnsweredByRequestId(requestId, token, signal, generation) {
+    const current = () => !signal.aborted && generation === lifecycleGeneration && !slackStopping;
     try {
+        if (!current())
+            return;
         const record = getQueueNoticeStore()?.findByRequestId(requestId);
         if (!record)
             return;
-        const token = getSlackSendClient().token;
-        if (record.messageId && token) {
-            await createSlackNoticeTransport(token, record.target.targetId, record.messageId)
-                .delete();
+        if (record.messageId) {
+            await createSlackNoticeTransport(token, record.target.targetId, record.messageId).delete(signal);
         }
-        closeSlackNoticeRecord(requestId);
+        if (current())
+            closeSlackNoticeRecord(requestId);
     }
     catch (e) {
         log.info('[slack:queue-notice] answered-close failed', logErrorText(e));
     }
 }
-/**
- * Rewrite notices left behind by a previous run.
- *
- * Called once the token is known, because the transport needs it — a record whose
- * transport cannot be built yet is kept rather than closed (#418).
- */
+/** Restore only recorded status messages; never infer a finished execution. */
 export async function restoreSlackQueueNotices() {
-    const store = getQueueNoticeStore();
-    if (!store)
-        return;
-    const token = getSlackSendClient().token;
-    await restoreQueueNotices({
-        store,
-        channel: 'slack',
-        expiredText: t('tg.queueExpired', {}, currentLocale()),
-        transport: (record) => (token
-            ? createSlackNoticeTransport(token, record.target.targetId, record.messageId)
-            : null),
-        onError: (e) => log.info('[slack:queue-notice] restore failed', logErrorText(e)),
-    });
+    if (!slackStopping)
+        await slackProgressRestorer.restore();
 }
 /** Stand in for a live queued-reply listener without opening a socket. */
 export function claimSlackQueueRequestForTest(requestId) {
@@ -369,30 +380,344 @@ function requiresNativeBodyDelivery(data) {
     return (data['runtimeFinality'] === 'present' || data['runtimeFinality'] === 'absent')
         && (data['runtimeStatus'] === 'done' || data['runtimeStatus'] === 'error' || data['runtimeStatus'] === 'stopped');
 }
+function bodyProgressOutcome(data, delivered, latched, stopping) {
+    const native = requiresNativeBodyDelivery(data);
+    if ((native && data['runtimeStatus'] === 'stopped') || (!native && data['executionInterrupted'] === true) || latched === 'cancelled')
+        return 'cancelled';
+    if (data['collectionFailure'] === 'timeout')
+        return 'expired';
+    if ((native && data['runtimeStatus'] === 'error') || (!native && data['executionFailed'] === true)
+        || data['collectionFailure'] === 'error' || (!native && data['error'] === true) || latched === 'error')
+        return 'error';
+    if (!delivered)
+        return stopping ? 'expired' : 'error';
+    return 'complete';
+}
+const slackReplyDelivery = createSlackReplyDeliveryLedger();
+const activeSlackReplyTrackers = new Map();
+let slackReplyAdmissionDepth = 0;
+const pendingSteerContexts = new Map();
+const SLACK_PENDING_STEER_MAX = 256;
+const SLACK_PENDING_STEER_TTL_MS = 300_000;
+function matchesSlackReply(options, data) {
+    const target = data['target'];
+    return data['requestId'] === options.requestId
+        && (data['scope'] === undefined || data['scope'] === options.session.scope)
+        && (data['sessionId'] === undefined || data['sessionId'] === options.session.chatSessionId)
+        && (data['origin'] === undefined || data['origin'] === 'slack')
+        && (data['remoteKey'] === undefined || data['remoteKey'] === options.session.remoteKey)
+        && (target === undefined || (isRemoteTarget(target) && target.channel === 'slack'
+            && target.targetId === options.target.targetId && target.threadId === options.target.threadId
+            && target.guildId === options.target.guildId && target.targetKind === options.target.targetKind
+            && target.peerKind === options.target.peerKind && target.parentTargetId === options.target.parentTargetId));
+}
+function rememberPendingSteer(options) {
+    if (options.signal.aborted || slackStopping || options.generation !== lifecycleGeneration)
+        return;
+    pendingSteerContexts.get(options.requestId)?.dispose();
+    while (pendingSteerContexts.size >= SLACK_PENDING_STEER_MAX)
+        pendingSteerContexts.values().next().value.dispose();
+    const dispose = () => {
+        clearTimeout(timer);
+        options.signal.removeEventListener('abort', dispose);
+        slackProgressSealers.delete(dispose);
+        if (pendingSteerContexts.get(options.requestId)?.dispose === dispose)
+            pendingSteerContexts.delete(options.requestId);
+    };
+    const timer = setTimeout(dispose, SLACK_PENDING_STEER_TTL_MS);
+    timer.unref?.();
+    pendingSteerContexts.set(options.requestId, { options, dispose });
+    options.signal.addEventListener('abort', dispose, { once: true });
+    slackProgressSealers.add(dispose);
+}
+function observeSlackReplyControl(type, raw) {
+    if (!['steer_started', 'queue_update', 'queued_run_started', 'request_settled'].includes(type))
+        return;
+    const requestId = raw['requestId'];
+    if (typeof requestId !== 'string' || !requestId || slackStopping)
+        return;
+    // Copy control identity only; an inline producer may precede admission return.
+    const data = {};
+    for (const key of ['requestId', 'origin', 'scope', 'sessionId', 'remoteKey', 'mode', 'outcome'])
+        data[key] = raw[key];
+    if (raw['target'] !== undefined)
+        data['target'] = isRemoteTarget(raw['target']) ? { ...raw['target'] } : null;
+    const actualStart = type === 'queued_run_started' || (type === 'steer_started' && data['mode'] === 'restart');
+    const anchor = actualStart ? nextDeliverySeq() : undefined;
+    const generation = lifecycleGeneration;
+    const active = activeSlackReplyTrackers.get(requestId);
+    if (active && matchesSlackReply(active.options, data) && anchor !== undefined)
+        active.start(anchor);
+    // Boot/orphan queue starts have no admission callback to wait for. Keep their
+    // proof synchronous so an immediate completion cannot claim before the start.
+    if (!active && slackReplyAdmissionDepth === 0 && type === 'queued_run_started'
+        && data['origin'] === 'slack' && isRemoteTarget(data['target']) && data['target'].channel === 'slack'
+        && typeof data['scope'] === 'string') {
+        const pending = pendingSteerContexts.get(requestId);
+        if (!pending || matchesSlackReply(pending.options, data))
+            slackReplyDelivery.started(requestId, data['target'], data['scope'], anchor);
+    }
+    queueMicrotask(() => {
+        if (slackStopping || generation !== lifecycleGeneration)
+            return;
+        const pending = pendingSteerContexts.get(requestId);
+        if (!pending) {
+            const tracker = activeSlackReplyTrackers.get(requestId);
+            if (tracker) {
+                if (anchor !== undefined && matchesSlackReply(tracker.options, data))
+                    tracker.start(anchor);
+            }
+            else if (type === 'queued_run_started' && data['origin'] === 'slack'
+                && isRemoteTarget(data['target']) && data['target'].channel === 'slack' && typeof data['scope'] === 'string') {
+                slackReplyDelivery.started(requestId, data['target'], data['scope'], anchor);
+            }
+            return;
+        }
+        if (!matchesSlackReply(pending.options, data))
+            return;
+        const { options } = pending;
+        if (options.signal.aborted || options.generation !== lifecycleGeneration) {
+            pending.dispose();
+            return;
+        }
+        if (type === 'request_settled') {
+            if (['steered', 'failed', 'cancelled', 'dropped'].includes(String(data['outcome']))) {
+                pending.dispose();
+                if (data['outcome'] !== 'steered')
+                    void options.ack?.settle('failure');
+            }
+            return;
+        }
+        if (type === 'steer_started' && ['native-input', 'cancel-reprompt'].includes(String(data['mode']))) {
+            pending.dispose();
+            return;
+        }
+        if (!actualStart && type !== 'queue_update')
+            return;
+        pending.dispose();
+        if (anchor !== undefined)
+            slackReplyDelivery.started(requestId, options.target, options.session.scope, anchor);
+        trackSlackReply({ ...options, initialPhase: actualStart ? 'running' : 'queued' });
+    });
+}
+function trackSlackReply(options) {
+    const { token, target, requestId, session, locale, generation, signal, ack, recipientUserId, initialPhase } = options;
+    if (signal.aborted || slackStopping || generation !== lifecycleGeneration || activeSlackReplyTrackers.has(requestId))
+        return;
+    // A synchronous terminal may have reached the orphan owner before admission
+    // returned. Its attempted body is not proof this late observer may ACK success.
+    if (slackReplyDelivery.claimed(requestId, target)) {
+        void ack?.settle('failure');
+        return;
+    }
+    slackReplyDelivery.remember(requestId, target, session.scope);
+    let started = initialPhase === 'running';
+    let observedAnchor = slackReplyDelivery.anchor(requestId, target);
+    let disposed = false;
+    let shutdownSealed = false;
+    let executionOutcome;
+    let timer;
+    let terminal = null;
+    let ackSettled = false;
+    let display;
+    const current = () => !shutdownSealed && !slackStopping && !signal.aborted && generation === lifecycleGeneration;
+    const matches = (data) => matchesSlackReply(options, data);
+    async function settleAck(outcome) {
+        if (ackSettled)
+            return;
+        ackSettled = true;
+        await ack?.settle(outcome);
+    }
+    function disposeListener() {
+        if (disposed)
+            return;
+        disposed = true;
+        if (timer)
+            clearTimeout(timer);
+        removeBroadcastListener(queueHandler);
+        activeSlackReplyTrackers.delete(requestId);
+    }
+    function claimTerminal(run, ownsBody = false) {
+        if (!terminal) {
+            disposeListener();
+            // Expired tracking must not swallow a later orphan reply. A live
+            // body claim instead stays present until its send/relay settles.
+            if (!ownsBody)
+                pendingQueueRequestIds.delete(requestId);
+            terminal = run()
+                .catch(error => log.info('[slack:queue]', logErrorText(error)))
+                .finally(() => {
+                signal.removeEventListener('abort', abortInput);
+                pendingQueueRequestIds.delete(requestId);
+            });
+        }
+        return terminal;
+    }
+    function endTracking(outcome, reason) {
+        return claimTerminal(async () => {
+            await Promise.allSettled([
+                display.finish(outcome, reason ? { reason } : {}), settleAck('failure'),
+            ]);
+        });
+    }
+    function resetTimer() {
+        if (disposed)
+            return;
+        if (timer)
+            clearTimeout(timer);
+        timer = setTimeout(() => { void endTracking('expired'); }, started ? SLACK_RUN_IDLE_MS : SLACK_QUEUE_WAIT_MS);
+        timer.unref?.();
+    }
+    function abortInput() {
+        shutdownSealed = true;
+        display.seal();
+        void display.finish(executionOutcome ?? 'expired');
+        void endTracking(executionOutcome ?? 'expired');
+    }
+    function queueHandler(type, data) {
+        if (disposed || !matches(data))
+            return;
+        if (type === 'queued_run_started')
+            return; // Global receipt owner captures the anchor synchronously.
+        if (type === 'request_settled') {
+            if (started)
+                return; // The display owner latches outcomes; preserve salvage delivery.
+            if (data['outcome'] === 'failed')
+                void endTracking('error');
+            if (data['outcome'] === 'cancelled')
+                void endTracking('cancelled');
+            if (data['outcome'] === 'dropped')
+                void endTracking('cancelled', 'removed');
+            if (data['outcome'] === 'merged')
+                void endTracking('cancelled', 'merged');
+            return;
+        }
+        if (type !== 'orchestrate_done' || data['origin'] !== 'slack')
+            return;
+        void claimTerminal(() => {
+            let bodyActionStarted = false;
+            return slackReplyDelivery.deliver(requestId, target, anchor => {
+                bodyActionStarted = true;
+                display.phase('delivering');
+                return sessionLanes.runDetachedTurn(session.scope, async () => {
+                    let delivered = false;
+                    let confirmedDelivery = false;
+                    try {
+                        if (!current()) {
+                            await Promise.allSettled([display.finish(executionOutcome ?? 'expired'), settleAck('failure')]);
+                            return;
+                        }
+                        const requireBodyDelivery = requiresNativeBodyDelivery(data);
+                        const rawText = String(data['text'] ?? '');
+                        const text = data['error'] === true && !requireBodyDelivery ? t('slack.progress.failure', {}, locale)
+                            : requireBodyDelivery && !rawText.trim() ? '' : rawText;
+                        display.phase('delivering');
+                        const outbound = slackOutboundRegistry.start(signal);
+                        try {
+                            const alreadyDelivered = text && (anchor ?? observedAnchor) !== undefined && wasSelfDelivered({ target, text, since: (anchor ?? observedAnchor) });
+                            const sent = text ? (alreadyDelivered ? { ok: true } : await sendSlackText(token, target, text, {
+                                signal: outbound.signal, ...(requireBodyDelivery ? { requireBodyDelivery: true } : {}),
+                                onPosted: async () => {
+                                    // Same early-settle rule as the direct path: every chunk is
+                                    // posted, so the ACK must not wait on readback verification.
+                                    delivered = true;
+                                    const early = bodyProgressOutcome(data, true, executionOutcome, !current());
+                                    await settleAck(early === 'complete' ? 'success' : 'failure');
+                                },
+                            })) : { ok: false };
+                            delivered = sent.ok;
+                            confirmedDelivery = Boolean(alreadyDelivered) || (sent.ok && Boolean(sent.ts));
+                        }
+                        finally {
+                            outbound.done();
+                        }
+                        const outcome = bodyProgressOutcome(data, delivered, executionOutcome, !current());
+                        if (delivered && target.threadId)
+                            markThreadParticipated(target.targetId, target.threadId);
+                        await settleAck(delivered && outcome === 'complete' ? 'success' : 'failure');
+                        await display.finish(outcome, { bodyDelivered: confirmedDelivery });
+                        if (text && current()) {
+                            const relay = slackOutboundRegistry.start(signal);
+                            try {
+                                await relaySlackImages(token, target, text, { signal: relay.signal });
+                            }
+                            catch (error) {
+                                log.error('[slack:queue-relay]', logErrorText(error));
+                            }
+                            finally {
+                                relay.done();
+                            }
+                        }
+                    }
+                    catch (error) {
+                        log.error('[slack:queue-send]', logErrorText(error));
+                        await Promise.allSettled([
+                            settleAck('failure'),
+                            display.finish(bodyProgressOutcome(data, delivered, executionOutcome, !current()), { bodyDelivered: confirmedDelivery }),
+                        ]);
+                    }
+                });
+            }).finally(async () => {
+                if (!bodyActionStarted) {
+                    await Promise.allSettled([display.finish(executionOutcome ?? 'expired'), settleAck('failure')]);
+                }
+            });
+        }, true);
+    }
+    reserveSlackNoticeRecord(requestId, target);
+    display = createSlackProgressLifecycle({
+        token, target, requestId, scope: session.scope, sessionId: session.chatSessionId, locale,
+        ...(options.workingDir ? { workingDir: options.workingDir } : {}),
+        ...(recipientUserId ? { recipientUserId } : {}),
+        registerTeardown: registerSlackProgressTeardown,
+        onPosted: ts => attachSlackNoticeRecord(requestId, ts),
+        onTerminalConfirmed: () => closeSlackNoticeRecord(requestId),
+        onExecutionOutcome: outcome => { executionOutcome = outcome; },
+        onActivity: () => { if (started)
+            resetTimer(); },
+        onSeal: () => { shutdownSealed = true; void settleAck('failure'); void endTracking(executionOutcome ?? 'expired'); },
+    });
+    function observeStart(anchor) {
+        if (disposed || !current())
+            return;
+        observedAnchor = slackReplyDelivery.started(requestId, target, session.scope, anchor);
+        if (!started) {
+            started = true;
+            display.phase('running');
+            resetTimer();
+        }
+    }
+    activeSlackReplyTrackers.set(requestId, { options, start: observeStart });
+    addBroadcastListener(queueHandler);
+    pendingQueueRequestIds.add(requestId);
+    signal.addEventListener('abort', abortInput, { once: true });
+    resetTimer();
+    display.start({ initialPhase });
+    void ack?.to('running', { wasQueued: initialPhase === 'queued' });
+}
 function installSlackTargetReplyForwarder() {
     if (targetReplyForwarderInstalled)
         return;
     targetReplyForwarderInstalled = true;
     addBroadcastListener((type, data) => {
-        if (type !== 'orchestrate_done' || data["origin"] !== 'slack' || !data["text"])
+        observeSlackReplyControl(type, data);
+        if (slackStopping || type !== 'orchestrate_done' || data["origin"] !== 'slack')
             return;
-        // Queued and steered turns only. An ordinary turn is posted by the
-        // dispatch path that is still standing there awaiting it; answering that
-        // here too would post every reply twice.
+        // Only captured queued/restart delivery authority can use this fallback.
+        // Ordinary direct turns retain their awaiting dispatch owner.
         //
         // Errors included: after a restart there is no waiter to show them, so
         // dropping them here means the user's message vanishes without even a
         // failure notice.
-        //
         // A steered turn is the same shape of orphan as a queued one: ingress
-        // returns early unless the disposition is 'new_run', so a mid-run steer
-        // leaves NO waiter for the follow-up answer. Without this the thread went
-        // silent after every steer while the answer completed server-side.
-        if (data["fromQueue"] !== true && data["fromSteer"] !== true)
+        // returns early unless the disposition is new_run, so a mid-run steer leaves
+        // NO waiter for the follow-up answer (#655). Accept all three identities.
+        if (data["fromQueue"] !== true && data["fromSteer"] !== true && data["replyViaTarget"] !== true)
             return;
-        const target = data["target"];
-        if (!target || target.channel !== 'slack' || !target.targetId)
+        const rawTarget = data['target'];
+        if (!isRemoteTarget(rawTarget) || rawTarget.channel !== 'slack')
             return;
+        const target = { ...rawTarget };
         // A live requester is already listening for this exact result; posting
         // here too would double-post it.
         if (data["requestId"] && hasPendingQueueWaiter(String(data["requestId"])))
@@ -400,15 +725,25 @@ function installSlackTargetReplyForwarder() {
         const token = getSlackSendClient().token;
         if (!token)
             return;
-        const text = String(data["text"]);
+        const generation = lifecycleGeneration;
         const requireBodyDelivery = requiresNativeBodyDelivery(data);
-        if (requireBodyDelivery && !text.trim())
-            return;
-        void (async () => {
+        const text = data['error'] === true && !requireBodyDelivery
+            ? t('slack.progress.failure', {}, currentLocale()) : String(data['text'] ?? '');
+        const requestId = typeof data['requestId'] === 'string' ? data['requestId'] : '';
+        const scope = slackReplyDelivery.scope(requestId, target)
+            ?? (typeof data['scope'] === 'string' ? data['scope'] : 'default');
+        void slackReplyDelivery.deliver(requestId, target, anchor => sessionLanes.runDetachedTurn(scope, async () => {
+            if (generation !== lifecycleGeneration || slackStopping)
+                return;
+            if (!text || (requireBodyDelivery && !text.trim()))
+                return;
             const outbound = slackOutboundRegistry.start();
             try {
-                const result = await sendSlackText(token, target, text, { signal: outbound.signal,
+                const alreadyDelivered = anchor !== undefined && wasSelfDelivered({ target, text, since: anchor });
+                const result = alreadyDelivered ? { ok: true } : await sendSlackText(token, target, text, { signal: outbound.signal,
                     ...(requireBodyDelivery ? { requireBodyDelivery: true } : {}) });
+                if (outbound.signal.aborted || generation !== lifecycleGeneration || slackStopping)
+                    return;
                 if (!result.ok) {
                     log.error('[slack:target-reply]', logErrorText(result.error || 'send failed'));
                     return;
@@ -419,7 +754,7 @@ function installSlackTargetReplyForwarder() {
                 // is now noise. The live waiter usually owns this; when the
                 // forwarder delivers instead, it must also keep the promise.
                 if (data["requestId"]) {
-                    await closeSlackNoticeAsAnsweredByRequestId(String(data["requestId"]));
+                    await closeSlackNoticeAsAnsweredByRequestId(String(data["requestId"]), token, outbound.signal, generation);
                 }
                 await relaySlackImages(token, target, text, { signal: outbound.signal });
             }
@@ -429,7 +764,7 @@ function installSlackTargetReplyForwarder() {
             finally {
                 outbound.done();
             }
-        })();
+        })).catch(error => log.error('[slack:target-reply]', logErrorText(error)));
     });
 }
 installSlackTargetReplyForwarder();
@@ -439,8 +774,10 @@ async function slackOrchestrate(target, prompt, displayMsg, signal, dedupe = {})
     if (!client.token)
         return;
     const token = client.token;
+    const workingDir = typeof settings['workingDir'] === 'string' ? settings['workingDir'] : undefined;
+    target = { ...target };
     const chatId = target.targetId;
-    if (signal.aborted)
+    if (signal.aborted || slackStopping)
         return;
     // #321: the reservation was taken before an `await` and several early
     // returns. If a reset landed in that window this delivery belongs to a dead
@@ -460,317 +797,156 @@ async function slackOrchestrate(target, prompt, displayMsg, signal, dedupe = {})
             isMention: dedupe.isMention ?? false,
         })
         : null;
-    const result = admitSlackRun({
-        target, prompt, displayText: displayMsg, chatId,
-        ...(dedupe.preResolvedScope !== undefined
-            ? { preResolvedScope: dedupe.preResolvedScope } : {}),
-        runReply: async (ctx) => {
-            let ackOutcome = 'failure';
-            let ackSettled = false;
-            try {
-                const progress = await startSlackProgress(token, target, t('slack.progress.start', {}, currentLocale())).catch(() => null);
-                const progressHandler = (type, data) => {
-                    if (!progress || type !== 'agent_tool')
-                        return;
-                    // Only this run's events. The old test was `origin !== 'slack'`,
-                    // which every concurrent Slack run passes, so two channels each
-                    // received the other's tool log — and a tool log carries command
-                    // lines and paths, so that crossed a channel boundary people set
-                    // up precisely to separate access (#398).
-                    //
-                    // An event with no requestId cannot prove which run it belongs to.
-                    // Letting it through would restore the old behaviour, so it is
-                    // dropped; emitAgentTool stamps the field from its run context.
-                    if (data['requestId'] !== ctx.requestId)
-                        return;
-                    // Thinking/commentary entries are live-UI-only narration.
-                    // Telegram already drops its 💭 lines; Slack's progress
-                    // placeholder gets real tool activity only, so agent
-                    // reasoning text never lands in the channel even briefly.
-                    // 💬 is the untagged-codex assistant-message badge (spark
-                    // visibility) — also narration from the channel's view.
-                    if (data['toolType'] === 'thinking' || data['icon'] === '💬')
-                        return;
-                    const line = statusFromToolEvent(data, t('slack.progress.working', {}, currentLocale()));
-                    if (line)
-                        progress.update(line);
+    let result;
+    slackReplyAdmissionDepth++;
+    try {
+        result = admitSlackRun({
+            target, prompt, displayText: displayMsg, chatId,
+            ...(dedupe.toolSource ? { toolSource: dedupe.toolSource } : {}),
+            ...(dedupe.preResolvedScope !== undefined
+                ? { preResolvedScope: dedupe.preResolvedScope } : {}),
+            runReply: async (ctx) => {
+                const locale = currentLocale();
+                const generation = lifecycleGeneration;
+                let shutdownSealed = false;
+                let executionOutcome;
+                let ackPromise = null;
+                const settleAck = (outcome) => {
+                    ackPromise ??= ack?.settle(outcome) ?? Promise.resolve();
+                    return ackPromise;
                 };
-                if (progress)
-                    addBroadcastListener(progressHandler);
-                // Anchors the delivery claim below. Taken BEFORE the agent runs,
-                // so only a send made during THIS turn can suppress this turn's
-                // post — an identical answer from an earlier turn must not.
+                let bodyAttempted = false;
+                let bodySucceeded = false;
+                let bodyConfirmed = false;
+                let resultData = {};
+                const current = () => !shutdownSealed && !slackStopping && !signal.aborted && generation === lifecycleGeneration;
+                if (!current())
+                    return;
+                if (ctx.requestId)
+                    reserveSlackNoticeRecord(ctx.requestId, target);
+                const display = createSlackProgressLifecycle({
+                    token, target, requestId: ctx.requestId, scope: ctx.scope, sessionId: ctx.chatSessionId, locale,
+                    ...(workingDir ? { workingDir } : {}),
+                    ...(dedupe.recipientUserId ? { recipientUserId: dedupe.recipientUserId } : {}),
+                    registerTeardown: registerSlackProgressTeardown,
+                    onPosted: ts => attachSlackNoticeRecord(ctx.requestId, ts),
+                    onTerminalConfirmed: () => closeSlackNoticeRecord(ctx.requestId),
+                    onExecutionOutcome: outcome => { executionOutcome = outcome; },
+                    onSeal: () => { shutdownSealed = true; void settleAck('failure'); },
+                });
+                const abortInput = () => {
+                    display.seal();
+                    void display.finish(executionOutcome ?? 'expired');
+                };
+                signal.addEventListener('abort', abortInput, { once: true });
+                display.start({ initialPhase: 'running' });
+                void ack?.to('running');
                 const turnStartedAt = nextDeliverySeq();
-                const collected = await withSessionScope({ scope: ctx.scope, chatSessionId: ctx.chatSessionId }, () => orchestrateAndCollectData(prompt, {
-                    origin: 'slack', target, chatId, requestId: ctx.requestId,
-                    ...(ctx.remoteKey ? { remoteKey: ctx.remoteKey } : {}),
-                    chatSessionId: ctx.chatSessionId, scope: ctx.scope, _skipInsert: true,
-                }).finally(async () => {
-                    if (!progress)
+                try {
+                    const collected = await withSessionScope({ scope: ctx.scope, chatSessionId: ctx.chatSessionId }, () => orchestrateAndCollectData(prompt, {
+                        origin: 'slack', target, chatId, requestId: ctx.requestId,
+                        ...(dedupe.toolSource ? { _strictRequestOwnership: true } : {}),
+                        ...(ctx.remoteKey ? { remoteKey: ctx.remoteKey } : {}),
+                        chatSessionId: ctx.chatSessionId, scope: ctx.scope, _skipInsert: true,
+                    }));
+                    resultData = collected.data;
+                    if (!current())
                         return;
-                    removeBroadcastListener(progressHandler);
-                    await progress.finish().catch(() => { });
-                }));
-                const text = collected.text;
-                // A turn retired by a steer has no answer of its own: the
-                // follow-up run owns it and the standing forwarder delivers it.
-                // Posting anything here — placeholder or empty body — is the
-                // "응답 없음" the user saw immediately after steering.
-                if (collected.data?.['superseded'] === true && !text.trim()) {
-                    log.info(`[slack:out:superseded] ${target.targetId}: retired by steer`);
-                    ackOutcome = 'success';
-                    return;
+                    // A turn retired by a steer has no answer of its own: the follow-up
+                    // run owns it and the reply tracker delivers it. Posting the no-response
+                    // placeholder here is what the user saw right after steering (#655).
+                    if (resultData['superseded'] === true && !String(collected.text ?? '').trim()) {
+                        log.info(`[slack:out:superseded] ${target.targetId}: retired by steer`);
+                        await settleAck('success');
+                        return;
+                    }
+                    const text = collected.data.collectionFailure === 'error' ? t('slack.progress.failure', {}, locale)
+                        : collected.data.collectionFailure === 'timeout' ? t('tg.timeout', {}, locale) : collected.text;
+                    display.phase('delivering');
+                    const outbound = slackOutboundRegistry.start(signal);
+                    try {
+                        bodyAttempted = true;
+                        const alreadyDelivered = wasSelfDelivered({ target, text, since: turnStartedAt });
+                        const sendResult = alreadyDelivered ? { ok: true } : await sendSlackText(token, target, text, {
+                            signal: outbound.signal,
+                            ...(requiresNativeBodyDelivery(collected.data) ? { requireBodyDelivery: true } : {}),
+                            onPosted: async () => {
+                                // Every chunk is posted, so the answer is visible. Settle
+                                // the ACK here: readback verification below can take
+                                // seconds per chunk and must not hold the reaction (#417).
+                                bodySucceeded = true;
+                                const early = bodyProgressOutcome(resultData, true, executionOutcome, !current());
+                                await settleAck(early === 'complete' ? 'success' : 'failure');
+                            },
+                        });
+                        bodySucceeded = sendResult.ok;
+                        bodyConfirmed = alreadyDelivered || (sendResult.ok && Boolean(sendResult.ts));
+                        const outcome = bodyProgressOutcome(resultData, bodySucceeded, executionOutcome, !current());
+                        if (bodySucceeded && target.threadId)
+                            markThreadParticipated(target.targetId, target.threadId);
+                        await settleAck(bodySucceeded && outcome === 'complete' ? 'success' : 'failure');
+                        await display.finish(outcome, { bodyDelivered: bodyConfirmed });
+                        if (current())
+                            await relaySlackImages(token, target, text, { signal: outbound.signal });
+                        log.info(`[slack:out${alreadyDelivered ? ':skipped-self-delivered' : ''}] ${target.targetId}: ${redactOutboundText(text).slice(0, 80)}`);
+                    }
+                    finally {
+                        outbound.done();
+                    }
                 }
-                // Scoped for shutdown cancellation (#417): the body send and the
-                // image relay below share one abortable scope, released when the
-                // turn settles either way.
-                const outbound = slackOutboundRegistry.start();
-                let sendResult;
-                try {
-                    // The agent may already have posted this exact answer itself
-                    // through /api/channel/send while the turn was still running,
-                    // in which case posting it again is the duplicate the user
-                    // sees. Skipping the POST is all this does: the outcome below
-                    // is still success, because the user has the answer — so the
-                    // ACK still settles (#417) and the notice still closes as
-                    // answered (#418), exactly as if we had sent it.
-                    const alreadyDelivered = wasSelfDelivered({ target, text, since: turnStartedAt });
-                    sendResult = alreadyDelivered
-                        ? { ok: true }
-                        : await sendSlackText(token, target, text, { signal: outbound.signal,
-                            ...(requiresNativeBodyDelivery(collected.data) ? { requireBodyDelivery: true } : {}) });
-                    // Recorded here, settled once in the finally below. The image
-                    // relay can still throw after the text is out, and the user did
-                    // get their answer in that case — so the outcome is success and
-                    // settling twice would be a lie about which one happened.
-                    ackOutcome = sendResult.ok ? 'success' : 'failure';
-                    // A successful reply records presence, not ownership (marking
-                    // point b). Replying into a thread we were invited to does not
-                    // make the rest of that conversation ours; the default `joined`
-                    // says so, and an already-`owned` thread keeps its kind (#400).
-                    if (sendResult.ok && target.threadId) {
-                        markThreadParticipated(target.targetId, target.threadId);
+                catch (err) {
+                    log.error('[slack:error]', logErrorText(err));
+                    if (current())
+                        executionOutcome ??= 'error';
+                    // Never append a second diagnostic after an ambiguous body attempt.
+                    if (!bodyAttempted && current()) {
+                        bodyAttempted = true;
+                        const outbound = slackOutboundRegistry.start(signal);
+                        try {
+                            const diagnostic = await sendSlackText(token, target, t('slack.progress.failure', {}, locale), { signal: outbound.signal });
+                            bodySucceeded = diagnostic.ok;
+                            bodyConfirmed = diagnostic.ok && Boolean(diagnostic.ts);
+                        }
+                        catch (error) {
+                            log.error('[slack:diagnostic]', logErrorText(error));
+                        }
+                        finally {
+                            outbound.done();
+                        }
                     }
-                    // Settled BEFORE the relay: the upload is now abortable but
-                    // still slow, and the reaction must not sit on `running`
-                    // while the answer is already visible (#417).
-                    await ack?.settle(ackOutcome);
-                    ackSettled = true;
-                    // Relayed even when the text above was suppressed. Whether
-                    // the agent already uploaded these bytes cannot be proven
-                    // from a path (see turn-delivery.ts), and a skip that cannot
-                    // be proven is a silent drop.
-                    await relaySlackImages(token, target, text, { signal: outbound.signal });
-                    // Logged either way, and labelled, because the previous
-                    // silence here is what made the duplicate hard to see: only
-                    // the dispatch post wrote [slack:out], so the log showed one
-                    // delivery while the user had received two.
-                    log.info(`[slack:out${alreadyDelivered ? ':skipped-self-delivered' : ''}] ${target.targetId}: ${redactOutboundText(text).slice(0, 80)}`);
                 }
                 finally {
-                    outbound.done();
+                    signal.removeEventListener('abort', abortInput);
+                    await settleAck('failure');
+                    await display.finish(bodyProgressOutcome(resultData, bodySucceeded, executionOutcome, !current()), bodyAttempted ? { bodyDelivered: bodyConfirmed } : {});
                 }
-            }
-            catch (err) {
-                log.error('[slack:error]', logErrorText(err));
-                await sendSlackText(token, target, `❌ Error: ${err.message}`).catch(() => { });
-            }
-            finally {
-                // Exactly one settle per turn, whichever way the body exited.
-                // The happy path already settled before the image relay.
-                if (!ackSettled)
-                    await ack?.settle(ackOutcome);
-            }
-        },
-    });
+            },
+        });
+    }
+    finally {
+        slackReplyAdmissionDepth--;
+    }
     // Durable commit AFTER admission, with no await in between: an event that
     // died before this line stays redeliverable, which is the whole point of
     // ordering it here rather than at reservation time.
     if (dedupe.eventKey && result.action !== 'rejected')
         commitSlackEvent(dedupe.eventKey);
     result.laneTail?.catch(error => log.error('[slack:lane]', logErrorText(error)));
-    if (result.action === 'queued') {
-        log.info(`[slack:queue] agent busy, queued (${result.pending} pending)`);
+    if (result.action === 'queued' || (result.action === 'started' && result.disposition === 'steered')) {
         const requestId = result.requestId;
-        // Anchored when this queued run STARTS, not when it was queued: the turn
-        // ahead of it is still running and can record a claim after this point,
-        // which would otherwise sort as "after this turn began" and swallow the
-        // queued answer. Until it latches it reads as Infinity, so nothing is
-        // suppressed. A restart loses claims entirely, which keeps the #407
-        // orphan delivery intact.
-        const queuedAnchor = pendingDeliveryAnchor();
-        const queuedRunStarted = (type, data) => {
-            // Keyed on THIS request. A scope-blind "an agent started" signal can
-            // fire for the turn ahead of this one, latching the anchor while that
-            // turn is still running — and a claim it records afterwards would then
-            // sort as newer than the anchor and swallow this answer.
-            if (type === 'queued_run_started' && data['requestId'] === requestId)
-                queuedAnchor.latch();
-        };
-        addBroadcastListener(queuedRunStarted);
-        let queueTimeout;
-        let disposed = false;
-        const notice = createQueueNotice({
-            expiredText: t('tg.queueExpired', {}, currentLocale()),
-            onError: (e) => log.info('[slack:queue-notice]', logErrorText(e)),
-        });
-        const disposeListener = () => {
-            if (disposed)
-                return;
-            disposed = true;
-            clearTimeout(queueTimeout);
-            removeBroadcastListener(queueHandler);
-            removeBroadcastListener(queuedRunStarted);
-            if (requestId)
-                pendingQueueRequestIds.delete(requestId);
-        };
-        // One terminal outcome per turn, shared by whoever gets there first.
-        //
-        // A boolean flag would pick a winner and let the loser return
-        // immediately — and the loser here is the shutdown drain, which would
-        // then tear the transport down while the winner is still sending. The
-        // broadcast bus never awaits listener promises (core/bus.ts), so nothing
-        // else would hold it. Handing back the winner's promise makes both paths
-        // converge on the same completion.
-        let terminal = null;
-        // Assigned immediately below, but referenced by finishExpired, which is
-        // defined first. Declared here so the terminal claim can unregister.
-        let unregister = () => { };
-        const claimTerminal = (run) => {
-            if (!terminal) {
-                terminal = run().catch(e => log.info('[slack:queue]', logErrorText(e)));
-            }
-            return terminal;
-        };
-        const finishExpired = (signal) => claimTerminal(async () => {
-            disposeListener();
-            try {
-                // Started together, not in sequence: awaiting the notice first can
-                // eat the whole drain deadline before the reaction is even attempted.
-                await Promise.allSettled([
-                    notice.close('expired', signal),
-                    ack?.settle('failure') ?? Promise.resolve(),
-                ]);
-                // The in-process handle just closed this notice, so the durable
-                // record has nothing left to restore. Dropping it here is what
-                // keeps the next boot from rewriting a message this turn already
-                // dealt with.
-                if (requestId)
-                    closeSlackNoticeRecord(requestId);
-            }
-            finally {
-                // Centralized here, as in the Discord path: every terminal route
-                // passes through a claim, so unregistering in one place is what
-                // makes "exactly once" true. The plain timeout used to leave its
-                // registry entry behind, so a later shutdown re-ran a turn that
-                // had already finished.
-                unregister();
-            }
-        });
-        unregister = slackNoticeRegistry.add((signal) => finishExpired(signal));
-        const queueHandler = async (type, data) => {
-            // No !data.text gate: an empty completion must still claim the
-            // terminal, or the notice sits until the 5-minute timeout rewrites
-            // it to "expired" — the reported "안 없어지는" symptom for empty or
-            // error turns. Empty text closes the notice as expired immediately.
-            if (type !== 'orchestrate_done' || data["origin"] !== 'slack'
-                || data["requestId"] !== requestId)
-                return;
-            if (disposed)
-                return;
-            // Dispose FIRST so a duplicate broadcast cannot double-post, but the
-            // notice deliberately outlives it: deleting before the answer is out
-            // would leave a failed send with neither answer nor notice.
-            disposeListener();
-            await claimTerminal(async () => {
-                try {
-                    const requireBodyDelivery = requiresNativeBodyDelivery(data);
-                    const rawText = String(data["text"] ?? '');
-                    const text = requireBodyDelivery && !rawText.trim() ? '' : rawText;
-                    const outbound = slackOutboundRegistry.start();
-                    let queuedSendResult;
-                    try {
-                        // Same rule as the normal dispatch: if the queued agent
-                        // already posted this answer itself, posting it again is
-                        // the duplicate. The notice still closes as answered
-                        // because the user does have the answer.
-                        const alreadyDelivered = text
-                            && wasSelfDelivered({ target, text, since: queuedAnchor.value() });
-                        queuedSendResult = text
-                            ? (alreadyDelivered
-                                ? { ok: true }
-                                : await sendSlackText(token, target, text, { signal: outbound.signal,
-                                    ...(requireBodyDelivery ? { requireBodyDelivery: true } : {}) }))
-                            : { ok: false };
-                    }
-                    finally {
-                        // Released after the body; the relay below opens its own
-                        // scope so a slow upload does not hold this one.
-                        outbound.done();
-                    }
-                    await notice.close(queuedSendResult.ok ? 'answered' : 'expired');
-                    if (queuedSendResult.ok && target.threadId) {
-                        markThreadParticipated(target.targetId, target.threadId);
-                    }
-                    // Settled before the relay for the same reason as the normal
-                    // path: the text is what the user was waiting for, and an
-                    // uncancellable upload must not hold the reaction on running.
-                    await ack?.settle(queuedSendResult.ok ? 'success' : 'failure');
-                    if (text) {
-                        const relayScope = slackOutboundRegistry.start();
-                        await relaySlackImages(token, target, text, {
-                            signal: relayScope.signal
-                        })
-                            .catch(e => log.error('[slack:queue-send]', logErrorText(e)))
-                            .finally(() => relayScope.done());
-                    }
-                    // The notice is closed, so the durable record has nothing
-                    // left to restore on the next boot (#418).
-                    if (requestId)
-                        closeSlackNoticeRecord(requestId);
-                }
-                finally {
-                    // Same "exactly once" reasoning as finishExpired: whichever
-                    // path claims the terminal owns the registry cleanup.
-                    unregister();
-                }
-            });
-        };
-        // Everything below is armed SYNCHRONOUSLY, before any await. A reaction
-        // call that takes a moment must not be able to outlive the completion it
-        // is acknowledging: without the listener and the request-id claim in
-        // place, a fast queued job would either be missed here or answered by the
-        // standing fallback forwarder instead (#407).
-        addBroadcastListener(queueHandler);
-        if (requestId)
-            pendingQueueRequestIds.add(requestId);
-        queueTimeout = setTimeout(() => { void finishExpired(); }, 300000);
-        // Only now, with the lifecycle armed. Not awaited: the notice below is
-        // what the user needs to see, and the reaction is decoration on top.
-        void ack?.to('running', { wasQueued: true });
-        // Reserved BEFORE the post, so the crash window falls the harmless way: a
-        // record without an id restores to nothing, while a posted message without
-        // a record is unreachable forever (#418).
-        if (requestId)
-            reserveSlackNoticeRecord(requestId, target);
-        const posted = await sendSlackText(token, target, t('tg.queued', { count: result.pending }, currentLocale()));
-        if (posted.ok && posted.ts) {
-            const ts = posted.ts;
-            // The exported factory, not an inline object: the restart path builds
-            // the same transport, and a second copy is how the two drift.
-            notice.bind(createSlackNoticeTransport(token, target.targetId, ts));
-            if (requestId)
-                attachSlackNoticeRecord(requestId, ts);
-        }
-        else {
-            // No ts will ever arrive, so a deferred close would wait for a bind
-            // that cannot happen and the drain would burn its whole deadline.
-            notice.abandon();
-            // Nothing was posted, so the reservation describes a message that does
-            // not exist. Leaving it would make every later boot look for it.
-            if (requestId)
-                closeSlackNoticeRecord(requestId);
+        if (!requestId) {
+            await ack?.settle('failure');
+            return;
         }
+        const options = {
+            token, target, requestId, session: { ...result.sessionContext }, locale: currentLocale(),
+            generation: lifecycleGeneration, signal, ack, ...(workingDir ? { workingDir } : {}), initialPhase: 'queued',
+            ...(dedupe.recipientUserId ? { recipientUserId: dedupe.recipientUserId } : {}),
+        };
+        if (result.action === 'queued')
+            trackSlackReply(options);
+        else
+            rememberPendingSteer(options);
         return;
     }
     if (result.action === 'rejected') {
@@ -862,7 +1038,15 @@ async function runSlackMessageEvent(event, target, text, signal, opts, commitPre
         // the message, and the conversation is already obvious in Slack's own UI.
         displayText = buildSenderDisplay(identity, displayText);
     }
+    const sourceToken = getSlackSendClient().token;
+    const workspace = sourceToken && opts.socketTeamId ? await verifiedSlackWorkspace(sourceToken).catch(() => null) : null;
+    if (signal.aborted)
+        return;
+    const toolSource = workspace && workspace.teamId === opts.socketTeamId && event.user && sourceToken
+        ? { teamId: workspace.teamId, actorId: event.user, destination: target, credentialKey: slackCredentialKey(sourceToken),
+            ...(typeof event.action_token === 'string' ? { actionToken: event.action_token } : {}) } : undefined;
     await slackOrchestrate(target, prompt, displayText, signal, {
+        ...(toolSource ? { toolSource } : {}),
         ...(opts.eventKey ? { eventKey: opts.eventKey } : {}),
         ...(opts.reservationGeneration !== undefined
             ? { reservationGeneration: opts.reservationGeneration } : {}),
@@ -870,8 +1054,9 @@ async function runSlackMessageEvent(event, target, text, signal, opts, commitPre
         // The ACK anchor is the user's own message. Only this caller has the raw
         // event, so the scope inputs are resolved here rather than re-derived.
         ...(event.ts ? { ackTs: event.ts } : {}),
+        ...(event.user ? { recipientUserId: event.user } : {}),
         isDirect: event.channel_type === 'im',
-        isMention: event.type === 'app_mention',
+        isMention: isSlackMention(event, selfUserId),
     });
 }
 /**
@@ -909,7 +1094,7 @@ async function buildInboundContextBlock(event, identity, signal, opts = {}, comm
         // A top-level channel message has no thread to read; the channel's own
         // recent history (ending before this event) is its context (#518 r2).
         const isTopLevelChannel = !threadTs
-            && (event.channel_type === 'channel' || event.channel_type === 'group');
+            && (event.channel_type === 'channel' || event.channel_type === 'group' || event.channel_type === 'mpim');
         // Independent lookups: serial would double the round trips inside a
         // deadline that exists to stay small.
         const [conversation, thread, channelHistory] = await Promise.all([
@@ -942,7 +1127,7 @@ async function buildInboundContextBlock(event, identity, signal, opts = {}, comm
         if (!prior.length)
             return block;
         const authorIds = prior.map(message => message.user || message.botId || '').filter(Boolean);
-        const preamble = buildThreadPreamble(formatHistoryForAgent(prior, selfUserId, cachedNameMap(teamId, authorIds)), thread?.replyCount ?? prior.length);
+        const preamble = buildThreadPreamble(formatHistoryForAgent(prior, selfUserId, cachedNameMap(teamId, authorIds)), thread?.replyCount ?? prior.length, thread);
         if (!preamble)
             return block;
         // History is actually going into the prompt: the claim is spent.
@@ -1057,6 +1242,11 @@ export async function handleSlackEnvelope(envelope, approvalTransport = slackApp
             : '';
         const parsed = parseApprovalCallbackData(actionId);
         if (!parsed) {
+            const token = getSlackSendClient().token;
+            if (token) {
+                const { consumeSlackInteractionCallback } = await import('./actions-interactions.js');
+                await consumeSlackInteractionCallback(payload, token);
+            }
             log.info('[slack:interactive] received (not an approval action)');
             return;
         }
@@ -1114,7 +1304,7 @@ export async function handleSlackEnvelope(envelope, approvalTransport = slackApp
     const prefetchOwner = preResolvedScope
         ? getSessionOwnershipGeneration(preResolvedScope)
         : undefined;
-    if (event.type === 'app_mention' && event.channel) {
+    if (isSlackMention(event, selfUserId) && event.channel) {
         // A top-level mention starts a thread the bot will parent, so the whole
         // thread belongs to it. A mention INSIDE an existing thread is an
         // invitation into someone else's conversation, and only that (#400).
@@ -1137,7 +1327,7 @@ export async function handleSlackEnvelope(envelope, approvalTransport = slackApp
     // between this function's entry and this line, so the test-and-set is atomic
     // against a second envelope in the same tick.
     const prefetchSubject = event.thread_ts
-        ?? ((event.channel_type === 'channel' || event.channel_type === 'group') ? '' : undefined);
+        ?? ((event.channel_type === 'channel' || event.channel_type === 'group' || event.channel_type === 'mpim') ? '' : undefined);
     const prefetchToken = prefetchSubject !== undefined && prefetchOwner
         ? claimThreadPrefetch(event.channel || '', prefetchSubject, prefetchOwner)
         : 0;
@@ -1150,7 +1340,10 @@ export async function handleSlackEnvelope(envelope, approvalTransport = slackApp
         // app_mention 봉투에는 files 가 없고, 첨부를 가진 message 사본은 위
         // shouldProcessSlackEvent 에서 mention_via_app_mention 으로 드롭된다.
         // 그래서 멘션과 함께 올린 파일은 여기서 되찾지 않으면 영영 사라진다.
-        if (!hasFiles && event.type === 'app_mention' && event.channel && event.ts) {
+        // app_mention envelopes drop files, so they need the history recovery.
+        // A message.mpim mention already carries its files inline; when it has
+        // none there is no twin envelope to recover from, only a wasted call.
+        if (!hasFiles && event.type === 'app_mention' && isSlackMention(event, selfUserId) && event.channel && event.ts) {
             const recoverToken = getSlackSendClient().token;
             if (recoverToken) {
                 const recovered = await recoverSlackAttachments(recoverToken, event.channel, event.ts, event.thread_ts ? { threadTs: event.thread_ts } : {});
@@ -1176,6 +1369,7 @@ export async function handleSlackEnvelope(envelope, approvalTransport = slackApp
             return;
         }
         prefetchHandedOff = enqueueSlackIngress(slackIngressLaneKey(target), signal => processSlackMessageEvent(event, target, text, signal, {
+            ...(typeof envelope.payload?.['team_id'] === 'string' ? { socketTeamId: envelope.payload['team_id'] } : {}),
             prefetchToken,
             ...(prefetchOwner ? { prefetchOwner } : {}),
             preResolvedScope,
@@ -1237,11 +1431,14 @@ async function runSlackInit(ctx) {
     // init it belongs to.
     const generation = ++lifecycleGeneration;
     await disposeSlackRuntime();
+    if (generation !== lifecycleGeneration)
+        return transportNotStarted('superseded');
     const sc = settings["slack"];
     if (!sc?.enabled || !sc?.botToken) {
         log.info('[slack] ⏭️  Slack pending (disabled or no bot token)');
         return transportNotStarted('not_configured');
     }
+    slackStopping = false;
     if (!sc.appToken) {
         // Outbound still works via the send transport; only inbound needs
         // the app-level token. Say so precisely instead of "failed".
@@ -1515,6 +1712,13 @@ function startSlackAutoJoin(sc, generation) {
  * `shutdownSlack` invalidates in-flight initializations.
  */
 async function disposeSlackRuntime() {
+    slackStopping = true;
+    slackProgressRestorer.abort();
+    for (const seal of [...slackProgressSealers])
+        seal();
+    // Begin both cancellation paths before ingress drain can consume the server deadline.
+    const outboundDrain = slackOutboundRegistry.drain();
+    const progressDrain = slackProgressRegistry.drain(SLACK_PROGRESS_DRAIN_MS);
     await resetSlackIngress();
     // Wakes the pacing sleeps immediately instead of letting a teardown wait
     // out a 3-second gap between conversations.list pages.
@@ -1537,27 +1741,7 @@ async function disposeSlackRuntime() {
         removeBroadcastListener(forwarderHandler);
         forwarderHandler = null;
     }
-    // Close out queued turns rather than leaving them armed for their 5-minute
-    // timeout against a transport that no longer exists. Awaited and bounded:
-    // dropping the callbacks (as this did) leaves the notice claiming the agent
-    // is still working, while an unbounded await would hold shutdown open on a
-    // stuck vendor call. The deadline covers the worst honest chain and the
-    // signal cancels whatever is left.
-    //
-    // The registry is the single shutdown route, as on Discord. A parallel
-    // waiter set used to hold one closure per queued turn and was cleared only
-    // here, so a long-lived instance retained every historical turn's token,
-    // target, notice and ACK closure. It also stripped the drain's abort signal:
-    // a QueueNotice pins the signal from its FIRST close, so a waiter closing
-    // without one made the later shutdown signal unreachable.
-    // Abort in-flight answer sends FIRST (#417 review): a queued waiter that
-    // already claimed its terminal is mid-send, and the notice drain below
-    // awaits that same promise — un-aborted, a hung vendor POST would eat the
-    // whole notice budget and blow past the server's 5s force-exit. Aborting
-    // first makes the hung send settle immediately (as slack_send_aborted,
-    // never a vendor failure), so the notice drain only pays for cleanup.
-    await slackOutboundRegistry.drain();
-    await slackNoticeRegistry.drain(SLACK_NOTICE_DRAIN_MS);
+    await Promise.allSettled([outboundDrain, progressDrain]);
     pendingQueueRequestIds.clear();
     socketClient?.stop();
     socketClient = null;