crewly 1.6.4 → 1.7.0

package/dist/backend/backend/src/services/slack/slack-orchestrator-bridge.js

@@ -14,7 +14,8 @@ import { Readable } from 'stream';
 import { pipeline } from 'stream/promises';
 import { PDFParse } from 'pdf-parse';
 import { getSlackService } from './slack.service.js';
-import { getChatService } from '../chat/chat.service.js';
+import { getChatV2Service } from '../chat-v2/chat-v2.singleton.js';
+import { synthesizeSlackConversationId } from '../chat-v2/legacy-dto.utils.js';
 import { isOrchestratorActive, isAgentActive, getOrchestratorOfflineMessage, triggerOrchestratorSetup, } from '../orchestrator/index.js';
 import { parseCommandIntent, } from '../../types/slack.types.js';
 import { ContentApprovalService } from '../onboarding/content-approval.service.js';
@@ -23,6 +24,7 @@ import { ORCHESTRATOR_SESSION_NAME, MESSAGE_QUEUE_CONSTANTS, SLACK_IMAGE_CONSTAN
 import { LoggerService } from '../core/logger.service.js';
 import { CROSS_MACHINE_PREFIX } from '../../types/cross-machine.types.js';
 import { getCrossMachineMessageService } from './cross-machine-message.service.js';
+import { TERMINAL_REQUEST_STATUSES } from '../../types/v2/request.types.js';
 /**
  * Default bridge configuration
  */
@@ -40,6 +42,51 @@ const DEFAULT_CONFIG = {
  * blocking the message ingress thread when setup is wedged.
  */
 const AUTO_RECOVERY_TIMEOUT_MS = 5_000;
+// ---------------------------------------------------------------------------
+// Auto-Request suppression gates (Pipeline-#4 fix, Patch D)
+//
+// Spec: 2026-05-05-request-decompose-pipeline-gap.md §4 Patch D.
+// Live data measured ~80% of auto-Requests in D0AC7NF5N7L matched one of
+// these gates and were never actionable.
+// ---------------------------------------------------------------------------
+/**
+ * Minimum trimmed text length required to create an auto-Request. Anything
+ * shorter is treated as "trivial" (length-gate). Set deliberately tight so a
+ * one-sentence command like "fix the build" (15 chars) still passes.
+ */
+const MIN_AUTO_REQUEST_TEXT_LENGTH = 12;
+/**
+ * Trimmed-text regex for trivial acknowledgement messages — anchored,
+ * case-insensitive, allows trailing punctuation/emoji whitespace. Matches
+ * "ok", "好的", "thx", "👍", etc. Add new locale tokens here as needed.
+ */
+const TRIVIAL_ACK_PATTERN = /^(ok|好的|收到|thx|thanks|谢谢|👍|✅|got it|sure|yes|是|对|对的)\W*$/i;
+/**
+ * Trimmed-text regex matching the synthetic `[Slack File: …]` titles
+ * generated by the file-handling path when a user uploads a file with no
+ * narrative. Caught before the thread-continuation gate to avoid the lookup.
+ */
+const FILE_ONLY_TITLE_PATTERN = /^\[Slack File:[^\]]*\]\.?\s*$/;
+/**
+ * Pure pre-fetch gates for auto-Request suppression (Patch D). Exported for
+ * focused unit testing — the full thread-continuation gate also lives in
+ * {@link SlackOrchestratorBridge.shouldSuppressAutoRequest} but requires a
+ * RequestService lookup so cannot be a pure function.
+ *
+ * Each function returns the suppression reason string (matches the values
+ * logged at debug level) or `null` when the gate does not match.
+ */
+export function suppressTrivialOrShort(rawText) {
+    const trimmed = rawText.trim();
+    if (trimmed.length < MIN_AUTO_REQUEST_TEXT_LENGTH || TRIVIAL_ACK_PATTERN.test(trimmed)) {
+        return 'trivial_or_short';
+    }
+    return null;
+}
+export function suppressFileOnly(rawText) {
+    const trimmed = rawText.trim();
+    return FILE_ONLY_TITLE_PATTERN.test(trimmed) ? 'file_only' : null;
+}
 /**
  * Slack-Orchestrator Bridge singleton
  */
@@ -62,7 +109,7 @@ let bridgeInstance = null;
 export class SlackOrchestratorBridge extends EventEmitter {
     logger = LoggerService.getInstance().createComponentLogger('SlackBridge');
     slackService;
-    chatService;
+    chatV2;
     messageQueueService = null;
     threadStatusQueue = null;
     threadStore = null;
@@ -89,7 +136,7 @@ export class SlackOrchestratorBridge extends EventEmitter {
     constructor(config = {}) {
         super();
         this.slackService = getSlackService();
-        this.chatService = getChatService();
+        this.chatV2 = getChatV2Service();
         this.config = { ...DEFAULT_CONFIG, ...config };
     }
     /**
@@ -259,8 +306,14 @@ export class SlackOrchestratorBridge extends EventEmitter {
                     }
                     // Strip the @mention prefix and send to the target agent
                     const cleanMessage = enrichedText.replace(new RegExp(`^@${mentionTarget.name}\\s*`, 'i'), '').trim();
-                    const response = await this.sendToAgent(mentionTarget.sessionName, cleanMessage || enrichedText, context);
-                    await this.sendSlackResponse(message, response);
+                    const agentResponse = await this.sendToAgent(mentionTarget.sessionName, cleanMessage || enrichedText, context);
+                    // Issue #394: `fromOrcReply` comes from the envelope — only
+                    // `true` when slackResolve fired with a non-empty body. The
+                    // pre-fix `response.length > 0` proxy false-positived on the
+                    // 3 placeholder strings (timeout, direct-delivery, error),
+                    // any of which would have auto-resolved the SLA tracker on a
+                    // non-reply.
+                    await this.sendSlackResponse(message, agentResponse.response, agentResponse.fromOrcReply);
                     if (this.config.showTypingIndicator) {
                         await this.markComplete(message);
                     }
@@ -317,24 +370,67 @@ export class SlackOrchestratorBridge extends EventEmitter {
                         try {
                             const { RequestService } = await import('../v3/request.service.js');
                             const svc = RequestService.getInstance();
-                            const msgId = `slack-${message.channelId}-${message.ts}`;
+                            // 2026-05-13 dogfood fix: encode BOTH thread root AND message
+                            // ts in sourceConversationItemId. The previous form was
+                            // `slack-{channel}-{message.ts}`, which made
+                            // `extractSlackThreadTs(sourceConv)` return the per-message
+                            // ts — never the actual Slack thread root. The SLA
+                            // threadIndex therefore mapped per-message ts → requestId,
+                            // but when orc replied via reply-slack → POST /api/slack/send
+                            // → markResolvedByThread(realThreadRoot), the lookup missed
+                            // and the Request never auto-closed (PR #538 hook was a
+                            // no-op for thread-reply messages).
+                            //
+                            // New form:
+                            //   Top-level message (msg.ts == thread root):
+                            //     `slack-{channelId}-{ts}`              (unchanged)
+                            //   Reply within an existing thread:
+                            //     `slack-{channelId}-{threadRoot}-msg-{messageTs}`
+                            //
+                            // The `-msg-{...}` suffix preserves per-message uniqueness
+                            // so `findBySourceConversationItemId` still works. The
+                            // updated `parseSlackThreadContext` strips the suffix
+                            // before extracting the threadTs, so the SLA's threadIndex
+                            // now keys on the actual thread root for both shapes.
+                            const threadRoot = message.threadTs || message.ts;
+                            const msgId = message.threadTs && message.threadTs !== message.ts
+                                ? `slack-${message.channelId}-${threadRoot}-msg-${message.ts}`
+                                : `slack-${message.channelId}-${message.ts}`;
                             const existing = await svc.findBySourceConversationItemId(msgId);
-                            if (!existing) {
-                                const { generateRequestTitle } = await import('../v3/v3-data.service.js');
-                                const rawText = message.text || '';
-                                const request = await svc.create({
-                                    title: generateRequestTitle(rawText, 'other'),
-                                    description: rawText,
-                                    sourceConversationItemId: msgId,
-                                    priority: 'normal',
-                                    tags: ['slack'],
-                                });
-                                // P2-2: RequestTracker.setActiveRequest write removed. The
-                                // companion read in v3-data.service.ts no longer falls back
-                                // to time-window correlation; downstream delegate-task
-                                // skills must now pass requestId explicitly.
-                                this.logger.debug('V3 Request created from Slack message', { msgId, requestId: request.id });
+                            if (existing)
+                                return;
+                            const rawText = message.text || '';
+                            // Pipeline-#4 fix (spec 2026-05-05-request-decompose-pipeline-gap.md,
+                            // Patch D): suppress trivial / continuation / file-only Slack messages
+                            // that pollute the Request stream without ever becoming actionable
+                            // work. ~80% of historical auto-Requests in D0AC7NF5N7L matched one
+                            // of these gates (dogfood data 2026-05-05).
+                            const suppressionReason = await this.shouldSuppressAutoRequest(message, rawText, svc);
+                            if (suppressionReason) {
+                                this.logger.debug('V3 Request creation suppressed', { msgId, reason: suppressionReason });
+                                return;
                             }
+                            const { generateRequestTitle, classifyIntent } = await import('../v3/v3-data.service.js');
+                            // Auto-classify so request-decompose.subscriber sees correct
+                            // intentLevel/intentCategory. Without this, every Slack-auto
+                            // Request defaulted to L1+other and was never decomposed
+                            // into delegation WorkItems — the entire Slack→WorkItem
+                            // pipeline was silently no-op.
+                            const { intentLevel, intentCategory } = classifyIntent(rawText);
+                            const request = await svc.create({
+                                title: generateRequestTitle(rawText, intentCategory),
+                                description: rawText,
+                                sourceConversationItemId: msgId,
+                                priority: 'normal',
+                                tags: ['slack'],
+                                intentLevel,
+                                intentCategory,
+                            });
+                            // P2-2: RequestTracker.setActiveRequest write removed. The
+                            // companion read in v3-data.service.ts no longer falls back
+                            // to time-window correlation; downstream delegate-task
+                            // skills must now pass requestId explicitly.
+                            this.logger.debug('V3 Request created from Slack message', { msgId, requestId: request.id });
                         }
                         catch (err) {
                             this.logger.warn('V3 Request creation from Slack failed (non-critical)', {
@@ -490,6 +586,70 @@ export class SlackOrchestratorBridge extends EventEmitter {
 :speech_balloon: *Chat*
 Just type naturally to chat with the orchestrator!`;
     }
+    /**
+     * Determine whether an inbound Slack message should be suppressed from
+     * auto-Request creation. Returns a reason string when the message should
+     * be skipped, or `null` when a Request should be created normally.
+     *
+     * Three gates (Pipeline-#4 fix, spec
+     * 2026-05-05-request-decompose-pipeline-gap.md, Patch D):
+     *
+     *   1. **Length / acknowledgement gate.** Trimmed text is shorter than
+     *      {@link MIN_AUTO_REQUEST_TEXT_LENGTH} OR matches the trivial
+     *      acknowledgement allowlist ({@link TRIVIAL_ACK_PATTERN}). Catches
+     *      "好的", "ok", "👍", "thx" — class noise that is never actionable.
+     *
+     *   2. **Thread continuation gate.** When the inbound message is a reply
+     *      inside an existing thread (`message.threadTs` ≠ `message.ts`) AND a
+     *      Request already exists for the **parent** message, suppress to
+     *      prevent every "are we still in this thread?" follow-up from creating
+     *      a new sibling Request. Existing Request continues to receive
+     *      orchestrator routing.
+     *
+     *   3. **File-only / synthetic-title gate.** Messages whose text is a
+     *      synthetic `[Slack File: …]` placeholder with no narrative are
+     *      artefacts of slack-bridge file-handling, not user requests.
+     *
+     * Each gate returns a stable reason string for log auditability. The
+     * caller logs at `debug` so suppression decisions are observable without
+     * noise.
+     *
+     * @param message - The incoming Slack message (already validated)
+     * @param rawText - The raw text body, trimmed by caller if needed
+     * @param svc - The RequestService instance for the thread-continuation lookup
+     * @returns A reason string when suppressed; `null` when allowed
+     */
+    async shouldSuppressAutoRequest(message, rawText, svc) {
+        const trimmed = rawText.trim();
+        // Gate 1 — length + ack allowlist
+        if (trimmed.length < MIN_AUTO_REQUEST_TEXT_LENGTH || TRIVIAL_ACK_PATTERN.test(trimmed)) {
+            return 'trivial_or_short';
+        }
+        // Gate 3 — file-only synthetic title (run before gate 2 to skip the I/O)
+        if (FILE_ONLY_TITLE_PATTERN.test(trimmed)) {
+            return 'file_only';
+        }
+        // Gate 2 — thread continuation: this message is a reply, and the parent
+        // message already has a NON-TERMINAL Request. Cheaper than threading
+        // detection at the SLA layer.
+        //
+        // ARCH 2026-05-05 PR #453 review (NC-1): the gate MUST check
+        // `parentRequest.status` is non-terminal — otherwise a thread that
+        // completed (parent → done via orc_reply / orc_reply_recheck) and then
+        // received a NEW actionable user message would silently suppress the new
+        // Request, re-opening the user-visible reliability gap that INBOUND-1
+        // was built to close. Terminal-parent threads release suppression so the
+        // child message creates a fresh Request.
+        const threadTs = message.threadTs;
+        if (threadTs && threadTs !== message.ts) {
+            const parentMsgId = `slack-${message.channelId}-${threadTs}`;
+            const parentRequest = await svc.findBySourceConversationItemId(parentMsgId);
+            if (parentRequest && !TERMINAL_REQUEST_STATUSES.has(parentRequest.status)) {
+                return 'thread_continuation';
+            }
+        }
+        return null;
+    }
     /**
      * Handle status command
      *
@@ -635,16 +795,19 @@ Just type naturally to chat with the orchestrator!`;
                         const threadFilePath = this.threadStore.getThreadFilePath(context.channelId, context.threadTs);
                         enrichedMessage = `${message}\n\n[Thread context file: ${threadFilePath}]`;
                     }
-                    // Store in chat service for persistence
-                    const result = await this.chatService.sendMessage({
-                        content: enrichedMessage,
-                        conversationId: context?.conversationId,
-                        metadata: {
-                            source: 'slack',
-                            userId: context?.userId,
-                            channelId: context?.channelId,
+                    // Store in canonical chat-v2 for persistence
+                    const result = {
+                        conversation: {
+                            id: this.persistSlackInbound({
+                                content: enrichedMessage,
+                                conversationId: context?.conversationId,
+                                agentSession: 'crewly-orc',
+                                channelId: context?.channelId,
+                                threadTs: context?.threadTs,
+                                userId: context?.userId,
+                            }).conversationId,
                         },
-                    });
+                    };
                     try {
                         this.messageQueueService.enqueue({
                             content: enrichedMessage,
@@ -708,16 +871,19 @@ Just type naturally to chat with the orchestrator!`;
                 const threadFilePath = this.threadStore.getThreadFilePath(context.channelId, context.threadTs);
                 enrichedMessage = `${message}\n\n[Thread context file: ${threadFilePath}]`;
             }
-            // Send message via chat service to store it
-            const result = await this.chatService.sendMessage({
-                content: enrichedMessage,
-                conversationId: context?.conversationId,
-                metadata: {
-                    source: 'slack',
-                    userId: context?.userId,
-                    channelId: context?.channelId,
+            // Persist user message in canonical chat-v2 store
+            const result = {
+                conversation: {
+                    id: this.persistSlackInbound({
+                        content: enrichedMessage,
+                        conversationId: context?.conversationId,
+                        agentSession: 'crewly-orc',
+                        channelId: context?.channelId,
+                        threadTs: context?.threadTs,
+                        userId: context?.userId,
+                    }).conversationId,
                 },
-            });
+            };
             // Enqueue the message with a resolve callback for response routing.
             // The QueueProcessorService will call slackResolve() when the
             // orchestrator responds, unblocking this promise.
@@ -748,8 +914,35 @@ Just type naturally to chat with the orchestrator!`;
                                 if (!resolved) {
                                     resolved = true;
                                     clearTimeout(timeoutId);
-                                    // Real orc reply path — safe to auto-resolve the SLA tracker.
-                                    resolve({ response: resp, fromOrcReply: true });
+                                    // 2026-05-12 dogfood bug: the QueueProcessor fires
+                                    // `routeResponse(message, '')` immediately after PTY
+                                    // delivery to unblock this promise (see
+                                    // queue-processor.service.ts:692 "fire-and-forget"
+                                    // comment). That call carries an EMPTY response — orc
+                                    // has only RECEIVED the message, not REPLIED. The
+                                    // previous shape of this callback always returned
+                                    // `fromOrcReply: true`, so every Slack delivery
+                                    // triggered `markResolvedByThread('orc_reply')` →
+                                    // `maybeCloseRequest` → Request cascaded to `done`
+                                    // with `result: "Auto-closed by SLA: orc_reply"`
+                                    // before the user ever saw a reply.
+                                    //
+                                    // Real orc replies (via the reply-slack skill) come
+                                    // through a different route — the orc invokes
+                                    // `POST /slack/send`, which posts to Slack directly;
+                                    // the SLA tracker is resolved when the
+                                    // `respond_to_user` WI transitions to `verified` and
+                                    // the cascade subscriber picks it up. That path
+                                    // produces a non-empty response payload only when
+                                    // a worker explicitly drives reply text back through
+                                    // the queue (rare; most orc replies are direct API).
+                                    //
+                                    // Gate: treat empty resp as a delivery ack ONLY
+                                    // (fromOrcReply=false). Non-empty resp keeps the
+                                    // legacy `true` semantics for any worker path that
+                                    // does echo a reply through the queue.
+                                    const fromOrcReply = resp.length > 0;
+                                    resolve({ response: resp, fromOrcReply });
                                 }
                             },
                             userId: context?.userId,
@@ -836,16 +1029,18 @@ Just type naturally to chat with the orchestrator!`;
         // Try to enqueue via the message queue (same path as orchestrator delivery)
         if (this.messageQueueService) {
             try {
-                // Store in chat history
-                const result = await this.chatService.sendMessage({
-                    content: enrichedMessage,
-                    conversationId: context?.conversationId,
-                    metadata: {
-                        source: 'slack',
-                        userId: context?.userId,
-                        channelId: context?.channelId,
+                const result = {
+                    conversation: {
+                        id: this.persistSlackInbound({
+                            content: enrichedMessage,
+                            conversationId: context?.conversationId,
+                            agentSession: auditorSession,
+                            channelId: context?.channelId,
+                            threadTs: context?.threadTs,
+                            userId: context?.userId,
+                        }).conversationId,
                     },
-                });
+                };
                 this.messageQueueService.enqueue({
                     content: enrichedMessage,
                     conversationId: result.conversation.id,
@@ -1568,7 +1763,11 @@ Just type naturally to chat with the orchestrator!`;
      * @param sessionName - Target agent session
      * @param message - Message to send
      * @param context - Slack context for response routing
-     * @returns Agent response text
+     * @returns OrcResponse envelope — `fromOrcReply` is `true` ONLY when the
+     *   reply came from the agent's `slackResolve` callback (a real reply
+     *   via the reply-slack skill). Timeout / direct-delivery / error
+     *   placeholders return `fromOrcReply: false` so callers can gate the
+     *   SLA cascade. Issue #394.
      */
     async sendToAgent(sessionName, message, context) {
         try {
@@ -1579,17 +1778,28 @@ Just type naturally to chat with the orchestrator!`;
             }
             // Use message queue for agents that support it, or deliver directly
             if (this.messageQueueService) {
-                const chatResult = await this.chatService.sendMessage({
-                    content: enrichedMessage,
-                    conversationId: context?.conversationId,
-                    metadata: { source: 'slack', channelId: context?.channelId },
-                });
+                const chatResult = {
+                    conversation: {
+                        id: this.persistSlackInbound({
+                            content: enrichedMessage,
+                            conversationId: context?.conversationId,
+                            agentSession: sessionName,
+                            channelId: context?.channelId,
+                            threadTs: context?.threadTs,
+                            userId: context?.userId,
+                        }).conversationId,
+                    },
+                };
                 return new Promise((resolve) => {
                     let resolved = false;
                     const timeoutId = setTimeout(() => {
                         if (!resolved) {
                             resolved = true;
-                            resolve('Agent is processing your message. Check back shortly.');
+                            // Timeout placeholder — explicitly NOT a real reply.
+                            resolve({
+                                response: 'Agent is processing your message. Check back shortly.',
+                                fromOrcReply: false,
+                            });
                         }
                     }, this.config.responseTimeoutMs);
                     this.messageQueueService.enqueue({
@@ -1602,7 +1812,11 @@ Just type naturally to chat with the orchestrator!`;
                                 if (!resolved) {
                                     resolved = true;
                                     clearTimeout(timeoutId);
-                                    resolve(resp);
+                                    // Real agent reply path. Empty `resp` is the
+                                    // QueueProcessor fire-and-forget delivery ack — treat
+                                    // it as a non-reply too (mirrors the orchestrator
+                                    // path's empty-string gate in sendToOrchestrator).
+                                    resolve({ response: resp, fromOrcReply: resp.length > 0 });
                                 }
                             },
                             channelId: context?.channelId,
@@ -1611,7 +1825,10 @@ Just type naturally to chat with the orchestrator!`;
                     });
                 });
             }
-            // Fallback: direct terminal delivery
+            // Fallback: direct terminal delivery — the agent acknowledges the
+            // write, but the actual reply hasn't been generated yet. Return a
+            // placeholder with fromOrcReply=false so the SLA cascade does NOT
+            // close on this.
             const { default: fetch } = await import('node-fetch').catch(() => ({ default: globalThis.fetch }));
             const apiUrl = process.env.CREWLY_API_URL || 'http://localhost:8787';
             await fetch(`${apiUrl}/api/terminal/${sessionName}/deliver`, {
@@ -1619,16 +1836,56 @@ Just type naturally to chat with the orchestrator!`;
                 headers: { 'Content-Type': 'application/json' },
                 body: JSON.stringify({ message: enrichedMessage, force: true }),
             });
-            return 'Message delivered to agent. Response will arrive shortly.';
+            return {
+                response: 'Message delivered to agent. Response will arrive shortly.',
+                fromOrcReply: false,
+            };
         }
         catch (err) {
             this.logger.error('Failed to send to agent', {
                 session: sessionName,
                 error: err instanceof Error ? err.message : String(err),
             });
-            return `Failed to reach agent. Error: ${err instanceof Error ? err.message : String(err)}`;
+            return {
+                response: `Failed to reach agent. Error: ${err instanceof Error ? err.message : String(err)}`,
+                fromOrcReply: false,
+            };
         }
     }
+    /**
+     * Persist a Slack inbound user message to chat-v2 and return the
+     * `(conversationId, messageId)` pair callers thread downstream
+     * into `MessageQueueService.enqueue` and `ThreadStatusQueueService.trackInbound`.
+     *
+     * Phase 6c of unified-chat-message-store spec: replaces the
+     * legacy `chatService.sendMessage` call sites on this bridge.
+     * Synthesizes a stable conversationId from Slack channel + thread
+     * ts when the caller didn't supply one, so re-enqueue paths
+     * (offline replay, recovery) reuse the same channel.
+     *
+     * @param args - Persistence inputs (content + slack context + recipient agent)
+     * @returns The chat-v2 channelId and the freshly persisted messageId
+     */
+    persistSlackInbound(args) {
+        const cid = args.conversationId ??
+            synthesizeSlackConversationId(args.channelId ?? 'unknown', args.threadTs ?? String(Date.now()));
+        const channel = this.chatV2.ensureChannelForLegacyConversation({
+            conversationId: cid,
+            agentSession: args.agentSession,
+        });
+        const { message } = this.chatV2.recordTurn({
+            channelId: channel.id,
+            senderType: 'user',
+            senderId: args.userId ?? 'slack-user',
+            content: args.content,
+            metadata: {
+                source: 'slack',
+                slackChannelId: args.channelId,
+                slackThreadTs: args.threadTs,
+            },
+        });
+        return { conversationId: channel.id, messageId: message.id };
+    }
 }
 /**
  * Get bridge singleton