cli-jaw 2.17.46 → 2.17.47

package/dist/src/slack/bot.js

@@ -1,12 +1,13 @@
 import { verifiedSlackWorkspace } from './verified-workspace.js';
 import { slackCredentialKey } from './tool-context.js';
 import { isSlackMention, matchesTrustedBotTrigger, readTrustedBotTriggers } from './events.js';
+import { captureSlackWorkflow, prepareSlackWorkflow, renderSlackWorkflow, isWorkflowReplyUnconfirmed, workflowDiagnosticText } from './workflow.js';
 // ─── Slack Bot ───────────────────────────────────────
 // Slack transport implementation for the cli-jaw messaging runtime.
 // Mirrors src/discord/bot.ts structurally: init/shutdown lifecycle, an inbound
 // handler that gates then dispatches into submitMessage/orchestrateAndCollect,
 // and a forwarder for non-Slack-origin agent output.
-import { JAW_HOME, isSettingsPersistenceBlocked, readPersistedSlackAttachPort, saveSettings, settings } from '../core/config.js';
+import { JAW_HOME, SKILLS_DIR, isSettingsPersistenceBlocked, readPersistedSlackAttachPort, saveSettings, settings } from '../core/config.js';
 import { withSessionScope } from '../core/session-context.js';
 import { log } from '../core/logger.js';
 import { t, normalizeLocale } from '../core/i18n.js';
@@ -43,6 +44,9 @@ import { createSlackProgressRestorer } from './progress-restore.js';
 import { createSlackForwarder, relaySlackImages } from './forwarder.js';
 import { nextDeliverySeq, wasSelfDelivered } from '../messaging/turn-delivery.js';
 import { shouldSkipForwarding } from '../messaging/forwarder-origin.js';
+import { requiresNativeBodyDelivery } from '../messaging/native-body.js';
+import { createQueueNoticeRecorder } from '../messaging/queue-notice-record.js';
+import { admitTargetReply } from '../messaging/target-reply-guard.js';
 import { handleSlackSlashCommand } from './commands.js';
 import { logErrorText, redactOutboundText } from '../messaging/redact.js';
 import { downloadAndSaveSlackFiles } from './inbound-file.js';
@@ -155,34 +159,11 @@ function hasPendingQueueWaiter(requestId) {
     return pendingQueueRequestIds.has(requestId);
 }
 // ─── Durable notice records (#418) ──────────────────
-// The handles above are process-local; these three wrap the store that outlives
-// the process. Every one of them is best-effort by contract: a durable write is a
-// convenience for the NEXT boot, and letting it throw here would fail the turn the
-// user is actually waiting on.
-function reserveSlackNoticeRecord(requestId, target) {
-    try {
-        getQueueNoticeStore()?.reserve({ requestId, channel: 'slack', target });
-    }
-    catch (e) {
-        log.info('[slack:queue-notice] reserve failed', logErrorText(e));
-    }
-}
-function attachSlackNoticeRecord(requestId, ts) {
-    try {
-        getQueueNoticeStore()?.attachMessageId(requestId, ts);
-    }
-    catch (e) {
-        log.info('[slack:queue-notice] attach failed', logErrorText(e));
-    }
-}
-function closeSlackNoticeRecord(requestId) {
-    try {
-        getQueueNoticeStore()?.close(requestId);
-    }
-    catch (e) {
-        log.info('[slack:queue-notice] close failed', logErrorText(e));
-    }
-}
+// The handles above are process-local; this wraps the store that outlives the
+// process. Best-effort by contract: a durable write is a convenience for the
+// NEXT boot, and letting it throw here would fail the turn the user is actually
+// waiting on. The contract is shared with the other two bots (#699).
+const slackNoticeRecord = createQueueNoticeRecorder('slack', '[slack:queue-notice]');
 /**
  * Close a queue notice as ANSWERED from a path that never held the live handle.
  *
@@ -206,7 +187,7 @@ async function closeSlackNoticeAsAnsweredByRequestId(requestId, token, signal, g
             await createSlackNoticeTransport(token, record.target.targetId, record.messageId).delete(signal);
         }
         if (current())
-            closeSlackNoticeRecord(requestId);
+            slackNoticeRecord.close(requestId);
     }
     catch (e) {
         log.info('[slack:queue-notice] answered-close failed', logErrorText(e));
@@ -378,16 +359,14 @@ function buildSlackTarget(event) {
  * carried through the queue rather than on whoever spoke most recently.
  */
 let targetReplyForwarderInstalled = false;
-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 (data['workflowUnconfirmed'] === true)
+        return 'error';
     if ((native && data['runtimeStatus'] === 'error') || (!native && data['executionFailed'] === true)
         || data['collectionFailure'] === 'error' || (!native && data['error'] === true) || latched === 'error')
         return 'error';
@@ -604,6 +583,7 @@ function trackSlackReply(options) {
                 return sessionLanes.runDetachedTurn(session.scope, async () => {
                     let delivered = false;
                     let confirmedDelivery = false;
+                    let outcomeData = data;
                     try {
                         if (!current()) {
                             await Promise.allSettled([display.finish(executionOutcome ?? 'expired'), settleAck('failure')]);
@@ -611,51 +591,33 @@ function trackSlackReply(options) {
                         }
                         const requireBodyDelivery = requiresNativeBodyDelivery(data);
                         const rawText = String(data['text'] ?? '');
-                        const text = data['error'] === true && !requireBodyDelivery ? t('slack.progress.failure', {}, locale)
-                            : requireBodyDelivery && !rawText.trim() ? '' : rawText;
+                        const unconfirmed = data['workflowUnconfirmed'] === true || Boolean(options.workflow && isWorkflowReplyUnconfirmed(rawText, data));
+                        if (unconfirmed)
+                            outcomeData = { ...data, workflowUnconfirmed: true };
+                        const text = unconfirmed ? workflowDiagnosticText(rawText, t('slack.workflow.unconfirmed', {}, locale))
+                            : 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();
-                            }
-                        }
+                        // Same rule as the direct path, and now literally the same code:
+                        // the queued/steer turn differs only in where its text and anchor
+                        // come from, and in keeping the image relay off the body's
+                        // cancellation domain (#686).
+                        await deliverSlackTurnBody({
+                            token, target, text, data: outcomeData, signal, display, settleAck, current,
+                            executionOutcome: () => executionOutcome,
+                            since: anchor ?? observedAnchor,
+                            skipSendIfEmpty: true,
+                            relayMode: 'isolated',
+                            relayWhenTextEmpty: false,
+                            report: (sentOk, confirmed) => { delivered = sentOk; confirmedDelivery = confirmed; },
+                            onRelayError: error => log.error('[slack:queue-relay]', logErrorText(error)),
+                        });
                     }
                     catch (error) {
                         log.error('[slack:queue-send]', logErrorText(error));
                         await Promise.allSettled([
                             settleAck('failure'),
-                            display.finish(bodyProgressOutcome(data, delivered, executionOutcome, !current()), { bodyDelivered: confirmedDelivery }),
+                            display.finish(bodyProgressOutcome(outcomeData, delivered, executionOutcome, !current()), { bodyDelivered: confirmedDelivery }),
                         ]);
                     }
                 });
@@ -666,14 +628,15 @@ function trackSlackReply(options) {
             });
         }, true);
     }
-    reserveSlackNoticeRecord(requestId, target);
+    slackNoticeRecord.reserve(requestId, target);
     display = createSlackProgressLifecycle({
         token, target, requestId, scope: session.scope, sessionId: session.chatSessionId, locale,
+        workflowResponse: Boolean(options.workflow),
         ...(options.workingDir ? { workingDir: options.workingDir } : {}),
         ...(recipientUserId ? { recipientUserId } : {}),
         registerTeardown: registerSlackProgressTeardown,
-        onPosted: ts => attachSlackNoticeRecord(requestId, ts),
-        onTerminalConfirmed: () => closeSlackNoticeRecord(requestId),
+        onPosted: ts => slackNoticeRecord.attach(requestId, ts),
+        onTerminalConfirmed: () => slackNoticeRecord.close(requestId),
         onExecutionOutcome: outcome => { executionOutcome = outcome; },
         onActivity: () => { if (started)
             resetTimer(); },
@@ -703,8 +666,6 @@ function installSlackTargetReplyForwarder() {
     targetReplyForwarderInstalled = true;
     addBroadcastListener((type, data) => {
         observeSlackReplyControl(type, data);
-        if (slackStopping || type !== 'orchestrate_done' || data["origin"] !== 'slack')
-            return;
         // Only captured queued/restart delivery authority can use this fallback.
         // Ordinary direct turns retain their awaiting dispatch owner.
         //
@@ -714,24 +675,30 @@ function installSlackTargetReplyForwarder() {
         // 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 (#655). Accept all three identities.
-        if (data["fromQueue"] !== true && data["fromSteer"] !== true && data["replyViaTarget"] !== true)
-            return;
-        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"])))
+        //
+        // `observeSlackReplyControl` above stays OUTSIDE this admission: it acts on
+        // steer/queue control events, not on `orchestrate_done`, and folding it in
+        // would silence boot/orphan start proof and steer tracking.
+        const admitted = admitTargetReply(type, data, {
+            channel: 'slack',
+            event: 'orchestrate_done',
+            accept: ['fromQueue', 'fromSteer', 'replyViaTarget'],
+            hasPendingWaiter: hasPendingQueueWaiter,
+            stopping: () => slackStopping,
+        });
+        if (!admitted)
             return;
+        const { target } = admitted;
         const token = getSlackSendClient().token;
         if (!token)
             return;
         const generation = lifecycleGeneration;
-        const requireBodyDelivery = requiresNativeBodyDelivery(data);
-        const text = data['error'] === true && !requireBodyDelivery
-            ? t('slack.progress.failure', {}, currentLocale()) : String(data['text'] ?? '');
-        const requestId = typeof data['requestId'] === 'string' ? data['requestId'] : '';
+        const requireBodyDelivery = admitted.requireBodyDelivery;
+        const text = data['workflowUnconfirmed'] === true
+            ? workflowDiagnosticText(String(data['text'] ?? ''), t('slack.workflow.unconfirmed', {}, currentLocale()))
+            : data['error'] === true && !requireBodyDelivery
+                ? t('slack.progress.failure', {}, currentLocale()) : String(data['text'] ?? '');
+        const requestId = admitted.requestId;
         const scope = slackReplyDelivery.scope(requestId, target)
             ?? (typeof data['scope'] === 'string' ? data['scope'] : 'default');
         void slackReplyDelivery.deliver(requestId, target, anchor => sessionLanes.runDetachedTurn(scope, async () => {
@@ -804,6 +771,7 @@ async function slackOrchestrate(target, prompt, displayMsg, signal, dedupe = {})
     try {
         result = admitSlackRun({
             target, prompt, displayText: displayMsg, chatId,
+            ...(dedupe.workflow ? { workflow: dedupe.workflow } : {}),
             ...(dedupe.toolSource ? { toolSource: dedupe.toolSource } : {}),
             ...(dedupe.preResolvedScope !== undefined
                 ? { preResolvedScope: dedupe.preResolvedScope } : {}),
@@ -825,14 +793,15 @@ async function slackOrchestrate(target, prompt, displayMsg, signal, dedupe = {})
                 if (!current())
                     return;
                 if (ctx.requestId)
-                    reserveSlackNoticeRecord(ctx.requestId, target);
+                    slackNoticeRecord.reserve(ctx.requestId, target);
                 const display = createSlackProgressLifecycle({
                     token, target, requestId: ctx.requestId, scope: ctx.scope, sessionId: ctx.chatSessionId, locale,
+                    workflowResponse: Boolean(dedupe.workflow),
                     ...(workingDir ? { workingDir } : {}),
                     ...(dedupe.recipientUserId ? { recipientUserId: dedupe.recipientUserId } : {}),
                     registerTeardown: registerSlackProgressTeardown,
-                    onPosted: ts => attachSlackNoticeRecord(ctx.requestId, ts),
-                    onTerminalConfirmed: () => closeSlackNoticeRecord(ctx.requestId),
+                    onPosted: ts => slackNoticeRecord.attach(ctx.requestId, ts),
+                    onTerminalConfirmed: () => slackNoticeRecord.close(ctx.requestId),
                     onExecutionOutcome: outcome => { executionOutcome = outcome; },
                     onSeal: () => { shutdownSealed = true; void settleAck('failure'); },
                 });
@@ -847,6 +816,7 @@ async function slackOrchestrate(target, prompt, displayMsg, signal, dedupe = {})
                 try {
                     const collected = await withSessionScope({ scope: ctx.scope, chatSessionId: ctx.chatSessionId }, () => orchestrateAndCollectData(prompt, {
                         origin: 'slack', target, chatId, requestId: ctx.requestId,
+                        ...(dedupe.workflow ? { slackWorkflow: dedupe.workflow } : {}),
                         ...(dedupe.toolSource ? { _strictRequestOwnership: true } : {}),
                         ...(ctx.remoteKey ? { remoteKey: ctx.remoteKey } : {}),
                         chatSessionId: ctx.chatSessionId, scope: ctx.scope, _skipInsert: true,
@@ -862,39 +832,27 @@ async function slackOrchestrate(target, prompt, displayMsg, signal, dedupe = {})
                         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;
+                    const unconfirmed = resultData['workflowUnconfirmed'] === true || Boolean(dedupe.workflow && isWorkflowReplyUnconfirmed(collected.text, resultData));
+                    if (unconfirmed)
+                        resultData = { ...resultData, workflowUnconfirmed: true };
+                    const text = unconfirmed ? workflowDiagnosticText(collected.text, t('slack.workflow.unconfirmed', {}, locale))
+                        : 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();
-                    }
+                    await deliverSlackTurnBody({
+                        token, target, text, data: resultData, signal, display, settleAck, current,
+                        executionOutcome: () => executionOutcome,
+                        since: turnStartedAt,
+                        // The direct path posts even an empty body: sendSlackText owns
+                        // the empty_message rule, and the collector already replaced a
+                        // truly empty answer with its no-response placeholder.
+                        skipSendIfEmpty: false,
+                        relayMode: 'same-outbound',
+                        relayWhenTextEmpty: true,
+                        onAttempt: () => { bodyAttempted = true; },
+                        report: (delivered, confirmed) => { bodySucceeded = delivered; bodyConfirmed = confirmed; },
+                        onSent: alreadyDelivered => log.info(`[slack:out${alreadyDelivered ? ':skipped-self-delivered' : ''}] ${target.targetId}: ${redactOutboundText(text).slice(0, 80)}`),
+                    });
                 }
                 catch (err) {
                     log.error('[slack:error]', logErrorText(err));
@@ -941,6 +899,7 @@ async function slackOrchestrate(target, prompt, displayMsg, signal, dedupe = {})
             return;
         }
         const options = {
+            ...(dedupe.workflow ? { workflow: dedupe.workflow } : {}),
             token, target, requestId, session: { ...result.sessionContext }, locale: currentLocale(),
             generation: lifecycleGeneration, signal, ack, ...(workingDir ? { workingDir } : {}), initialPhase: 'queued',
             ...(dedupe.recipientUserId ? { recipientUserId: dedupe.recipientUserId } : {}),
@@ -963,6 +922,93 @@ async function slackOrchestrate(target, prompt, displayMsg, signal, dedupe = {})
         return;
     }
 }
+/**
+ * The one place a Slack turn's answer reaches the wire (#686).
+ *
+ * The direct dispatch path and the queued/steer tracker each carried their own
+ * copy of send -> early ACK -> progress finish -> image relay. Every delivery
+ * fix therefore had to land twice, and the ones that did not became bugs only
+ * the queued path kept (#655, #673).
+ *
+ * The two paths do genuinely disagree, so each disagreement is a PARAMETER
+ * rather than a branch inside the spine: the caller derives its own text from
+ * its own payload, brings its own delivery-ledger anchor, decides whether an
+ * empty body is posted at all, and chooses whether the image relay shares the
+ * body's cancellation domain. Collapsing those would silently change live
+ * behaviour, which is why this is an extraction and not a merge.
+ *
+ * Deliberately NOT folded in: the orphan forwarder. It has no ACK handle and no
+ * progress card, because it exists precisely for turns whose waiter is gone.
+ */
+async function deliverSlackTurnBody(options) {
+    const { token, target, text, data, signal, display, settleAck, current, executionOutcome } = options;
+    const requireBodyDelivery = requiresNativeBodyDelivery(data);
+    let bodySucceeded = false;
+    let bodyConfirmed = false;
+    const report = () => options.report?.(bodySucceeded, bodyConfirmed);
+    const outbound = slackOutboundRegistry.start(signal);
+    let outboundClosed = false;
+    const closeOutbound = () => { if (!outboundClosed) {
+        outboundClosed = true;
+        outbound.done();
+    } };
+    options.onAttempt?.();
+    try {
+        const skipped = options.skipSendIfEmpty && !text;
+        const since = options.since;
+        const alreadyDelivered = !skipped && since !== undefined
+            && wasSelfDelivered({ target, text, since });
+        const sent = skipped ? { ok: false }
+            : alreadyDelivered ? { ok: true }
+                : await sendSlackText(token, target, text, {
+                    signal: outbound.signal, ...(requireBodyDelivery ? { requireBodyDelivery: true } : {}),
+                    onPosted: async () => {
+                        // Every chunk is posted, so the answer is visible. Settle the
+                        // ACK here: readback verification can take seconds per chunk
+                        // and must not hold the reaction on running (#417).
+                        bodySucceeded = true;
+                        report();
+                        const early = bodyProgressOutcome(data, true, executionOutcome(), !current());
+                        await settleAck(early === 'complete' ? 'success' : 'failure');
+                    },
+                });
+        bodySucceeded = sent.ok;
+        bodyConfirmed = alreadyDelivered || (sent.ok && Boolean(sent.ts));
+        report();
+        // The queued path closes the body registration before settling, so a late
+        // image upload cannot keep the turn's outbound slot open.
+        if (options.relayMode === 'isolated')
+            closeOutbound();
+        const outcome = bodyProgressOutcome(data, 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() && (options.relayWhenTextEmpty || Boolean(text))) {
+            if (options.relayMode === 'isolated') {
+                const relay = slackOutboundRegistry.start(signal);
+                try {
+                    await relaySlackImages(token, target, text, { signal: relay.signal });
+                }
+                catch (error) {
+                    options.onRelayError?.(error);
+                }
+                finally {
+                    relay.done();
+                }
+            }
+            else {
+                await relaySlackImages(token, target, text, { signal: outbound.signal });
+            }
+        }
+        if (!skipped)
+            options.onSent?.(alreadyDelivered);
+        return { delivered: bodySucceeded, confirmed: bodyConfirmed, outcome };
+    }
+    finally {
+        closeOutbound();
+    }
+}
 function buildSlackFileFailureWarning(failed, allFailed = false) {
     if (!failed.length)
         return null;
@@ -993,6 +1039,19 @@ async function runSlackMessageEvent(event, target, text, signal, opts, commitPre
     const files = event.files || [];
     let prompt = text;
     let displayText = text;
+    const workflow = await prepareSlackWorkflow(event, gateConfig(), SKILLS_DIR, opts.workflowSelection);
+    if (signal.aborted)
+        return;
+    if (workflow.kind === 'blocked') {
+        log.warn('[slack:workflow] blocked', { code: workflow.code, channelId: target.targetId });
+        const token = getSlackSendClient().token;
+        if (token) {
+            const sent = await sendSlackText(token, target, t('slack.workflow.unavailable', {}, currentLocale()));
+            if (sent.ok && opts.eventKey)
+                commitSlackEvent(opts.eventKey);
+        }
+        return;
+    }
     // Start identity resolution alongside the downloads. Running them in series
     // would add a round trip to every attachment message.
     const identityPromise = resolveSenderIdentity(event, { signal });
@@ -1028,7 +1087,7 @@ async function runSlackMessageEvent(event, target, text, signal, opts, commitPre
     // (gateway.ts:234). A sender line in front of "계속" stops it being a
     // continuation, so control text travels undecorated. Reset is already
     // intercepted upstream and never reaches here.
-    if (!isContinueIntent(prompt)) {
+    if (workflow.kind === 'ready' || !isContinueIntent(prompt)) {
         const block = await buildInboundContextBlock(event, identity, signal, opts, commitPrefetch);
         // An empty block lands EXACTLY on the previous behavior: config off and
         // total lookup failure must be indistinguishable from before this
@@ -1040,6 +1099,10 @@ 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);
     }
+    if (workflow.kind === 'ready') {
+        prompt = renderSlackWorkflow(workflow, prompt);
+        log.info('[slack:workflow] routed', workflow.metadata);
+    }
     const sourceToken = getSlackSendClient().token;
     const workspace = sourceToken && opts.socketTeamId ? await verifiedSlackWorkspace(sourceToken).catch(() => null) : null;
     if (signal.aborted)
@@ -1048,6 +1111,7 @@ async function runSlackMessageEvent(event, target, text, signal, opts, commitPre
         ? { 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, {
+        ...(workflow.kind === 'ready' ? { workflow: workflow.metadata } : {}),
         ...(toolSource ? { toolSource } : {}),
         ...(opts.eventKey ? { eventKey: opts.eventKey } : {}),
         ...(opts.reservationGeneration !== undefined
@@ -1272,14 +1336,16 @@ export async function handleSlackEnvelope(envelope, approvalTransport = slackApp
     const event = payload?.event;
     if (!event)
         return;
-    const approval = handleApprovalCommand(approvalTransport, {
+    const receiveGate = gateConfig();
+    const workflowSelection = captureSlackWorkflow(event, receiveGate);
+    const approval = workflowSelection.kind === 'none' ? handleApprovalCommand(approvalTransport, {
         ...event,
         __jawSelf: Boolean(event.user && event.user === getSlackSelfUserId()),
-    }, String(event.text || ''));
+    }, String(event.text || '')) : { handled: false };
     if (approval.handled)
         return;
     const target = buildSlackTarget(event);
-    const decision = shouldProcessSlackEvent(event, gateConfig(), envelope.type);
+    const decision = shouldProcessSlackEvent(event, receiveGate, envelope.type);
     if (!decision.process) {
         log.info(`[slack:in] skipped (${decision.reason})`);
         return;
@@ -1362,7 +1428,7 @@ export async function handleSlackEnvelope(envelope, approvalTransport = slackApp
             return;
         if (text)
             log.info(`[slack:in] ${event.channel}: ${redactOutboundText(text).slice(0, 80)}`);
-        if (!hasFiles && isResetIntent(text)) {
+        if (!hasFiles && workflowSelection.kind === 'none' && isResetIntent(text)) {
             const client = getSlackSendClient();
             const result = submitMessage(text, { origin: 'slack', target });
             if (client.token) {
@@ -1373,6 +1439,7 @@ export async function handleSlackEnvelope(envelope, approvalTransport = slackApp
             return;
         }
         prefetchHandedOff = enqueueSlackIngress(slackIngressLaneKey(target), signal => processSlackMessageEvent(event, target, text, signal, {
+            workflowSelection,
             ...(typeof envelope.payload?.['team_id'] === 'string' ? { socketTeamId: envelope.payload['team_id'] } : {}),
             prefetchToken,
             ...(prefetchOwner ? { prefetchOwner } : {}),
@@ -1496,7 +1563,7 @@ async function runSlackInit(ctx) {
     if (declaredTriggers > 0) {
         const usable = readTrustedBotTriggers(sc.trustedBotTriggers).length;
         if (usable === 0) {
-            log.warn(`[slack:triggers] ${declaredTriggers} trusted bot trigger(s) configured but the list is invalid, so none of them can start a turn — every rule needs exactly channelId (C/G), botId (B), userId (U/W) and an uppercase textMarker`);
+            log.warn(`[slack:triggers] ${declaredTriggers} trusted bot trigger(s) configured but the list is invalid, so none of them can start a turn — every rule needs channelId (C/G), botId (B), userId (U/W), an uppercase textMarker and, optionally, a valid workflowSkill ID`);
         }
         else {
             log.info(`[slack:triggers] ${usable} trusted bot trigger(s) active`);