crewly 1.20.363 → 1.20.365

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

@@ -86,6 +86,23 @@ export function slackChannelNameFor(teamName, prefix = '') {
     const joined = p ? `${p}-${body}` : body;
     return joined.slice(0, SLACK_TEAM_CHANNEL_CONSTANTS.MAX_CHANNEL_NAME_LENGTH).replace(/-+$/g, '') || 'team';
 }
+/**
+ * Whether a Slack thread's owner's machine provably received a room message:
+ * Cloud's delivery facts name it among the machines it pushed to, and Cloud
+ * has not marked that machine as unproven in the room. Without delivery
+ * facts (older Cloud builds) nothing is proven: the caller keeps the room's
+ * rules, so a message is never left with nobody (crewly#1376).
+ *
+ * @param room - Cloud's room presence for the message
+ * @param owner - The thread owner's roster entry
+ * @returns True when the owner's machine has the message
+ */
+export function threadOwnerMachineHasIt(room, owner) {
+    const targets = room.delivery?.targets;
+    if (!Array.isArray(targets) || targets.length === 0 || !owner.instanceId)
+        return false;
+    return owner.verified !== false && targets.includes(owner.instanceId);
+}
 /**
  * The machine that owns an un-@'d message in a shared room, from Cloud's
  * presence snapshot alone — every machine computes the same answer from
@@ -2168,7 +2185,8 @@ export class SlackTeamChannelService {
             // stale or retired machine never answers. Every machine judges by the
             // same snapshot (its own agents included). A card's asker is the
             // exception: its machine's decision path takes the reply.
-            const live = !room || room.members.some((m) => localAgentSession(m.agentSession) === localAgentSession(agent.session) && m.awake);
+            const ownerMember = room?.members.find((m) => localAgentSession(m.agentSession) === localAgentSession(agent.session)) ?? null;
+            const live = !room || !!ownerMember?.awake;
             if (live || via === 'card') {
                 if (agent.local)
                     return { ...base, pinned: { session: agent.session, answeredBy: agent.session, name: agent.name, reason: 'thread-owner' } };
@@ -2179,6 +2197,22 @@ export class SlackTeamChannelService {
                 const watch = !(via === 'card' && live);
                 return { ...base, pinned: { session: null, answeredBy: agent.session, name: agent.name, reason: 'thread-owner', ...(watch ? watchFlags() : {}) } };
             }
+            // The thread owner is asleep, but its machine provably has the message
+            // (Cloud pushed it there): that machine wakes it, and no agent of
+            // another machine answers by its own room rules (crewly#1376: the Air's
+            // Rex, not on the team, answered an un-@'d owner message in a thread
+            // Atlas on the Mac owned).
+            if (room && ownerMember && threadOwnerMachineHasIt(room, ownerMember)) {
+                if (agent.local && !isSessionPaused(agent.session)) {
+                    return { ...base, pinned: { session: agent.session, answeredBy: agent.session, name: agent.name, reason: 'thread-owner' } };
+                }
+                if (!agent.local) {
+                    // Waking takes a minute or two: the watcher here only tells the
+                    // owner if nothing came, and never hands the message to our agents.
+                    const watch = isWatcher || noteOnlyHere ? { watchHere: true, watchNoteOnly: true } : {};
+                    return { ...base, pinned: { session: null, answeredBy: agent.session, name: agent.name, reason: 'thread-owner', ...watch } };
+                }
+            }
             return ownsRoom ? base : deferToRoomOwner;
         }
         catch (err) {