crewly 1.20.191 → 1.20.193

package/dist/cli/backend/src/services/slack/slack-team-channel.service.js

@@ -24,6 +24,8 @@
  *
  * @module services/slack/slack-team-channel.service
  */
+import { notePerson } from '../people/people-directory.service.js';
+import { dedicatedDecisionFor } from '../people/dedicated-agent.js';
 import { getTicketIntakeService } from '../v3/ticket-intake.service.js';
 import { intakeWithin, slackIntakeMessage, ticketOfOutcome, markAndLinkTicket } from '../v3/ticket-channel-hooks.js';
 import { CREWLY_CONSTANTS, RUNTIME_FALLBACK_CONSTANTS } from '../../constants.js';
@@ -42,7 +44,7 @@ import { getSlackDirectoryService } from './slack-directory.service.js';
 import { SLACK_TEAM_CHANNEL_CONSTANTS, OWNER_EVIDENCE_METADATA, SLACK_THREAD_KEY_CONSTANTS } from '../../constants.js';
 import { parseSlackThreadKey } from './slack-thread-key.js';
 import { withTopicLine } from '../orc/work-item-destination.js';
-import { resolveSlackMentions, extractNativeMentionIds } from './slack-mention-resolver.js';
+import { resolveSlackMentions, extractNativeMentionIds, leadingNameMention } from './slack-mention-resolver.js';
 import { toSlackMrkdwn } from './slack-mrkdwn.js';
 import { renderSlackThreadContext } from './slack-thread-context.service.js';
 const EMPTY_STORE = {
@@ -128,6 +130,12 @@ export function orchestratorSyncTeamId(instanceId) {
 }
 /** Separates the orchestrator's session from the instance it runs on. */
 const ORCHESTRATOR_INSTANCE_SEPARATOR = '@';
+/**
+ * `@here` / `@channel` / `@everyone`, as Slack delivers them (`<!here>`) or
+ * typed literally: a message to the whole room, so it has an addressee of its
+ * own and never inherits a person-to-person exchange.
+ */
+const SLACK_BROADCAST_MENTION_RE = /<!(?:here|channel|everyone)(?:\|[^>]*)?>|(?<![\w<@])@(?:here|channel|everyone)\b/i;
 /**
  * The session the orchestrator is registered with Cloud under.
  *
@@ -947,6 +955,38 @@ export class SlackTeamChannelService {
     // -------------------------------------------------------------------------
     // Inbound (Slack → huddle)
     // -------------------------------------------------------------------------
+    /**
+     * Post the polite decline for every @'d agent that is dedicated to someone
+     * other than the sender (issue #968).
+     *
+     * @param message - Inbound channel message (from a human)
+     * @param mentions - Sessions it addressed
+     * @returns The sessions that declined
+     */
+    async declineDedicatedMentions(message, mentions) {
+        const declined = [];
+        for (const sessionName of mentions) {
+            const decision = await dedicatedDecisionFor(this.deps.storage, sessionName, {
+                slackUserId: message.userId,
+                authorAgentSession: message.authorAgentSession,
+            });
+            if (!decision.decline)
+                continue;
+            declined.push(sessionName);
+            const botToken = this.deps.identities?.getInstalled(sessionName)?.botToken;
+            await this.deps.slack
+                .sendMessage({
+                channelId: message.channelId,
+                text: decision.text,
+                threadTs: message.threadTs || message.ts,
+                ...(botToken ? { botToken } : {}),
+                skipChatV2Mirror: true,
+            })
+                .catch((err) => this.logger.warn('Could not post the dedicated-agent decline', { sessionName, error: err instanceof Error ? err.message : String(err) }));
+            this.logger.info('Dedicated agent declined a channel message from someone else', { sessionName, slackUserId: message.userId });
+        }
+        return declined;
+    }
     /**
      * Route an inbound Slack message that arrived in a mapped channel.
      *
@@ -970,6 +1010,7 @@ export class SlackTeamChannelService {
         await this.load();
         if (message.userId && !message.authorAgentSession) {
             this.rememberHuman(message.userId, [message.user?.realName, message.user?.name]);
+            notePerson(message.userId, message.user?.realName || message.user?.name);
         }
         let mapping = this.findBySlackChannelId(message.channelId);
         if (!mapping)
@@ -1041,7 +1082,36 @@ export class SlackTeamChannelService {
         // lists every agent the message @'s; one addressed only elsewhere is
         // that machine's to handle.
         const isLocal = (sess) => this.deps.isLocalAgent?.(sess) ?? members.some((m) => m.sessionName === sess);
-        const mentionedElsewhere = (message.mentionedAgentSessions ?? []).filter((sess) => !isLocal(sess));
+        // An agent named at the start of the message, with no @ ("Aria，帮我…",
+        // "Aria, can you…"), is addressed — owner's rule, 2026-10-02. Only agents
+        // in this room count: its local members, and the ones Cloud lists on
+        // other machines.
+        const namedElsewhere = [];
+        if (!handoffTo) {
+            const roomLocal = isAdhocMapping(mapping)
+                ? candidates.filter((c) => (mapping.members ?? []).includes(c.sessionName))
+                : candidates;
+            const roomRemote = (message.room?.members ?? [])
+                .filter((m) => !isLocal(localAgentSession(m.agentSession)) && !roomLocal.some((c) => c.sessionName === m.agentSession))
+                .map((m) => ({ name: m.displayName, sessionName: m.agentSession }));
+            const named = leadingNameMention(message.text ?? '', [...roomLocal, ...roomRemote]);
+            if (named && roomLocal.includes(named)) {
+                if (!resolved.mentions.includes(named.sessionName))
+                    resolved.mentions.push(named.sessionName);
+            }
+            else if (named) {
+                namedElsewhere.push(named.sessionName);
+            }
+        }
+        // Dedicated agents (issue #968) @'d by anyone but their person: each
+        // posts a polite decline from its own bot and is taken off the list —
+        // nothing is dispatched to it and it is not woken.
+        const declinedDedicated = !message.authorAgentSession && message.userId && resolved.mentions.length > 0 ? await this.declineDedicatedMentions(message, resolved.mentions) : [];
+        const declinedOnly = declinedDedicated.length > 0 && resolved.mentions.every((sess) => declinedDedicated.includes(sess));
+        for (const sess of declinedDedicated)
+            resolved.mentions.splice(resolved.mentions.indexOf(sess), 1);
+        const agentsMentionedViaCloud = [...new Set([...(message.mentionedAgentSessions ?? []), ...namedElsewhere])];
+        const mentionedElsewhere = agentsMentionedViaCloud.filter((sess) => !isLocal(sess));
         const addressedElsewhereOnly = !handoffTo && resolved.mentions.length === 0 && mentionedElsewhere.length > 0;
         // @-mentions of people: the owner asking a
         // colleague is not a question for the agents (2026-10-01,
@@ -1050,10 +1120,7 @@ export class SlackTeamChannelService {
         const peopleMentions = message.authorAgentSession || handoffTo
             ? { userIds: [], names: [] }
             : await this.peopleMentions(message, resolved, teams);
-        const addressedPeopleOnly = !addressedElsewhereOnly &&
-            resolved.mentions.length === 0 &&
-            (message.mentionedAgentSessions ?? []).length === 0 &&
-            peopleMentions.userIds.length + peopleMentions.names.length > 0;
+        const namedPeople = [...peopleMentions.userIds, ...peopleMentions.names];
         // Thread correlation.
         const slackThreadTs = message.threadTs || message.ts;
         let threadId;
@@ -1061,6 +1128,28 @@ export class SlackTeamChannelService {
             const root = this.deps.chat.findSlackThreadRoot(mapping.chatChannelId, message.threadTs);
             threadId = root?.id;
         }
+        // A message with no @ of its own may still be one person talking to
+        // another: the owner answered a colleague in two messages 35 s apart,
+        // only the first carried the @, and the second woke Aria (2026-10-02,
+        // #personal-assistant-team). It inherits the people the conversation was
+        // addressed to (specs/slack-room-presence.md "Follow-ups of a
+        // person-to-person exchange").
+        const hasOwnAddressee = !!message.authorAgentSession ||
+            !!handoffTo ||
+            resolved.mentions.length > 0 ||
+            resolved.unknown.length > 0 ||
+            agentsMentionedViaCloud.length > 0 ||
+            namedPeople.length > 0 ||
+            SLACK_BROADCAST_MENTION_RE.test(message.text ?? '');
+        const exchange = hasOwnAddressee
+            ? { inherit: null, recent: [] }
+            : this.personExchangeOf(message, mapping.chatChannelId, threadId);
+        const inherited = exchange.inherit;
+        const addresseePeople = inherited ? inherited.people : namedPeople;
+        const addressedPeopleOnly = !addressedElsewhereOnly &&
+            resolved.mentions.length === 0 &&
+            agentsMentionedViaCloud.length === 0 &&
+            addresseePeople.length > 0;
         // A colleague agent on another machine is recorded under its display
         // name, as a user turn: the dispatcher delivers user turns and skips
         // agent turns (self-loop guard), and to this team it IS an outside voice.
@@ -1091,13 +1180,12 @@ export class SlackTeamChannelService {
                 slackTs: message.ts,
                 slackUserId: message.userId,
                 ...(message.teamId ? { slackTeamId: message.teamId } : {}),
-                ...(peopleMentions.userIds.length + peopleMentions.names.length > 0
-                    ? {
-                        [SLACK_TEAM_CHANNEL_CONSTANTS.PEOPLE_MENTIONS_METADATA_KEY]: [
-                            ...peopleMentions.userIds,
-                            ...peopleMentions.names,
-                        ],
-                    }
+                ...(addresseePeople.length > 0
+                    ? { [SLACK_TEAM_CHANNEL_CONSTANTS.PEOPLE_MENTIONS_METADATA_KEY]: addresseePeople }
+                    : {}),
+                ...(inherited ? { [SLACK_TEAM_CHANNEL_CONSTANTS.ADDRESSEE_INHERITED_METADATA_KEY]: inherited.reason } : {}),
+                ...(agentsMentionedViaCloud.length > 0
+                    ? { [SLACK_TEAM_CHANNEL_CONSTANTS.AGENT_MENTIONS_METADATA_KEY]: agentsMentionedViaCloud }
                     : {}),
                 // Marks the row as agent-authored: the commitment-approval gate must
                 // never read a colleague agent's post as owner approval (#730).
@@ -1152,6 +1240,10 @@ export class SlackTeamChannelService {
             ...(remoteAgent ? { excludeSessions: [remoteAgent] } : {}),
             ...(presence ? { room: presence.state, ...(presence.line ? { roomPresence: presence.line } : {}) } : {}),
         };
+        if (declinedOnly) {
+            // Every agent it addressed is dedicated to someone else and declined.
+            return { mapping, message: persisted, mentions: [], dispatch: null };
+        }
         if (addressedElsewhereOnly) {
             // Kept for context (the next question in the thread may be ours), but
             // no eyes, no placeholder, and nobody here is told.
@@ -1165,13 +1257,24 @@ export class SlackTeamChannelService {
         if (addressedPeopleOnly) {
             // Context for the agents' next turn in this thread, nothing more. No
             // suggestion hint either: the names were people, not typos.
-            this.logger.info('Slack team message addressed to people, not agents — recorded, not dispatched', {
-                teamId: mapping.teamId,
-                slackChannel: `#${mapping.slackChannelName}`,
-                mentionedUsers: peopleMentions.userIds,
-                mentionedNames: peopleMentions.names,
-                threaded: !!threadId,
-            });
+            if (inherited) {
+                this.logger.info('Slack team message continues a person-to-person exchange — recorded, not dispatched', {
+                    teamId: mapping.teamId,
+                    slackChannel: `#${mapping.slackChannelName}`,
+                    addressedTo: inherited.people,
+                    reason: inherited.reason,
+                    threaded: !!threadId,
+                });
+            }
+            else {
+                this.logger.info('Slack team message addressed to people, not agents — recorded, not dispatched', {
+                    teamId: mapping.teamId,
+                    slackChannel: `#${mapping.slackChannelName}`,
+                    mentionedUsers: peopleMentions.userIds,
+                    mentionedNames: peopleMentions.names,
+                    threaded: !!threadId,
+                });
+            }
             return { mapping, message: persisted, mentions: [], dispatch: null };
         }
         const planned = dispatcherForPlan?.planHuddleTargets
@@ -1265,9 +1368,17 @@ export class SlackTeamChannelService {
             // The thread as Slack has it — posts by agents on other machines
             // included — rendered per recipient so its own lines are marked.
             const slackContext = await message.threadContext;
+            // Prompt backstop: who the message (or the exchange it may continue)
+            // was meant for, when people are in the picture.
+            const peopleAddressing = namedPeople.length > 0
+                ? { kind: 'named-in-message', people: await this.personLabels(namedPeople, message.channelId) }
+                : exchange.recent.length > 0
+                    ? { kind: 'recent-exchange', people: await this.personLabels(exchange.recent, message.channelId) }
+                    : null;
             dispatch = await dispatcher.dispatchMessage(channel, markAndLinkTicket(persisted, ticket), {
                 ...dispatchOptions,
                 ...(roster ? { channelRoster: roster } : {}),
+                ...(peopleAddressing ? { peopleAddressing } : {}),
                 ...(slackContext
                     ? {
                         slackContextFor: (session) => renderSlackThreadContext(slackContext, {
@@ -2120,6 +2231,135 @@ export class SlackTeamChannelService {
         }
         return { userIds: pending, names };
     }
+    /**
+     * Whether a message with no addressee of its own continues a
+     * person-to-person exchange (specs/slack-room-presence.md "Follow-ups of a
+     * person-to-person exchange"). Reads the huddle rows already recorded, so it
+     * holds across restarts.
+     *
+     * - In a thread: walking back from the newest row, agents' posts and human
+     *   rows with no addressee (or an inherited one) are skipped; the first
+     *   human row with an addressee decides. People only → inherit them, while
+     *   that @ is within the person-exchange window (or is the same sender's
+     *   own message within the follow-up window); older → `recent` only. An agent (here or on
+     *   another machine) or `@here` → no inheritance; the most recent
+     *   people-only row older than that is returned as `recent`, for the
+     *   prompt backstop.
+     * - At the top level: the channel's previous top-level row, when it came
+     *   within the follow-up window and was addressed to people only — inherited
+     *   when the same person wrote it, `recent` otherwise.
+     *
+     * @param message - The inbound message (no addressee of its own)
+     * @param chatChannelId - Its huddle
+     * @param threadId - Its huddle thread root, when the Slack thread is known here
+     * @returns Inherited people (with why), and people of a recent exchange
+     */
+    personExchangeOf(message, chatChannelId, threadId) {
+        const none = { inherit: null, recent: [] };
+        const peopleOf = (m) => {
+            const v = m.metadata?.[SLACK_TEAM_CHANNEL_CONSTANTS.PEOPLE_MENTIONS_METADATA_KEY];
+            return Array.isArray(v) ? v.filter((x) => typeof x === 'string' && x.length > 0) : [];
+        };
+        const isHuman = (m) => m.senderType === 'user' && !m.metadata?.[OWNER_EVIDENCE_METADATA.REMOTE_AGENT_SESSION];
+        const addressesAgent = (m) => {
+            const elsewhere = m.metadata?.[SLACK_TEAM_CHANNEL_CONSTANTS.AGENT_MENTIONS_METADATA_KEY];
+            return ((m.mentions?.length ?? 0) > 0 ||
+                (Array.isArray(elsewhere) && elsewhere.length > 0) ||
+                SLACK_BROADCAST_MENTION_RE.test(m.content ?? ''));
+        };
+        const seconds = (ts) => (typeof ts === 'string' ? Number.parseFloat(ts) : Number.NaN);
+        const within = (m, windowMs) => {
+            const gapMs = (seconds(message.ts) - seconds(m.metadata?.slackTs)) * 1000;
+            return Number.isFinite(gapMs) && gapMs >= 0 && gapMs <= windowMs;
+        };
+        const withinWindow = (m) => within(m, this.windowMs(SLACK_TEAM_CHANNEL_CONSTANTS.PEOPLE_FOLLOWUP_WINDOW_ENV, SLACK_TEAM_CHANNEL_CONSTANTS.PEOPLE_FOLLOWUP_WINDOW_MS));
+        const withinExchange = (m) => within(m, this.windowMs(SLACK_TEAM_CHANNEL_CONSTANTS.PERSON_EXCHANGE_WINDOW_ENV, SLACK_TEAM_CHANNEL_CONSTANTS.PERSON_EXCHANGE_WINDOW_MS));
+        const sameSender = (m) => !!message.userId && m.metadata?.slackUserId === message.userId;
+        if (message.threadTs) {
+            if (!threadId || !this.deps.chat.listThreadForBridge)
+                return none;
+            const rows = this.deps.chat.listThreadForBridge(chatChannelId, threadId);
+            let agentAddressed = false;
+            for (let i = rows.length - 1; i >= 0; i--) {
+                const row = rows[i];
+                if (!isHuman(row) || row.metadata?.slackTs === message.ts)
+                    continue;
+                // An inherited addressee is not an @: the exchange is timed from
+                // the last explicit human-to-human @.
+                if (row.metadata?.[SLACK_TEAM_CHANNEL_CONSTANTS.ADDRESSEE_INHERITED_METADATA_KEY])
+                    continue;
+                const people = peopleOf(row);
+                if (addressesAgent(row)) {
+                    agentAddressed = true;
+                    continue;
+                }
+                if (people.length === 0)
+                    continue;
+                if (agentAddressed)
+                    return { inherit: null, recent: people };
+                if (sameSender(row) && withinWindow(row))
+                    return { inherit: { people, reason: 'same-sender-followup' }, recent: [] };
+                // An exchange that went quiet is over: the normal rules apply again.
+                if (!withinExchange(row))
+                    return { inherit: null, recent: people };
+                return { inherit: { people, reason: 'person-exchange' }, recent: [] };
+            }
+            return none;
+        }
+        const previous = this.deps.chat.findLatestSlackRoot(chatChannelId);
+        if (!previous || !isHuman(previous) || addressesAgent(previous) || !withinWindow(previous))
+            return none;
+        const people = peopleOf(previous);
+        if (people.length === 0)
+            return none;
+        return sameSender(previous)
+            ? { inherit: { people, reason: 'same-sender-followup' }, recent: [] }
+            : { inherit: null, recent: people };
+    }
+    /**
+     * A time window, from its env override when that is a non-negative number,
+     * else the default.
+     *
+     * @param envVar - Env var holding milliseconds
+     * @param fallbackMs - Default
+     * @returns Milliseconds
+     */
+    windowMs(envVar, fallbackMs) {
+        const raw = process.env[envVar];
+        const parsed = raw !== undefined && raw.trim() !== '' ? Number(raw) : Number.NaN;
+        return Number.isFinite(parsed) && parsed >= 0 ? parsed : fallbackMs;
+    }
+    /**
+     * How to name people in an agent's prompt: `Name (<@U…>)` when a name is
+     * known (someone who spoke in a mapped channel, the owner, or a channel
+     * member the cached directory lists), else the bare mention. Plain typed
+     * names are kept as `@Name`.
+     *
+     * @param people - Slack user ids and/or typed names
+     * @param slackChannelId - Channel, for the directory lookup
+     * @returns One label per person
+     */
+    async personLabels(people, slackChannelId) {
+        const names = new Map();
+        if (people.some((p) => /^[UW][A-Z0-9]+$/.test(p))) {
+            const directory = await getSlackDirectoryService()?.list(slackChannelId).catch(() => null);
+            for (const e of directory ?? []) {
+                const id = /^<@([UW][A-Z0-9]+)>$/.exec(e.mention ?? '')?.[1];
+                if (id && e.kind === 'human' && e.name && !names.has(id))
+                    names.set(id, e.name);
+            }
+        }
+        // Names people were seen under (lower-cased), for anyone the directory missed.
+        for (const [name, id] of this.humanNames)
+            if (!names.has(id))
+                names.set(id, name);
+        return people.map((p) => {
+            if (!/^[UW][A-Z0-9]+$/.test(p))
+                return `@${p}`;
+            const name = names.get(p);
+            return name ? `${name} (<@${p}>)` : `<@${p}>`;
+        });
+    }
     /**
      * Remember a person's names so an agent writing `@Their Name` reaches them.
      *