crewly 1.20.197 → 1.20.199

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

@@ -77,6 +77,25 @@ 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';
 }
+/**
+ * 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
+ * the same snapshot (its own agents included, judged by the snapshot, not
+ * by local state). The room's home machine when Cloud names it and an agent
+ * there is awake; otherwise the lowest instance id among machines with an
+ * awake room member. Null when nobody is awake (Cloud's fallback decides).
+ *
+ * @param room - Cloud's room presence
+ * @returns Owning instance id, or null
+ */
+export function roomOwnerInstance(room) {
+    const awake = [...new Set(room.members.filter((m) => m.awake).map((m) => m.instanceId))];
+    if (awake.length === 0)
+        return null;
+    if (room.home && awake.includes(room.home.instanceId))
+        return room.home.instanceId;
+    return awake.sort()[0];
+}
 /**
  * Whether a mapping is an ad-hoc channel (no Crewly team behind it).
  *
@@ -519,6 +538,11 @@ export class SlackTeamChannelService {
                 };
                 this.store = store;
                 return store;
+            }).catch((err) => {
+                // Don't cache a failed read (EMFILE, a corrupt file that could not
+                // be copied aside): the next call tries again.
+                this.loading = null;
+                throw err;
             });
         }
         return this.loading;
@@ -1479,6 +1503,12 @@ export class SlackTeamChannelService {
             // Someone here holds it — including a follow-up in a thread we were
             // still waiting on.
             this.settleUnanswered(`${message.channelId}:${slackThreadTs}`);
+            // The owner machine of a shared room (others deferred to it) runs the
+            // one 90 s fallback: if nobody here answers, its lead is woken.
+            const allOptional = (dispatch.huddleOutcomes ?? []).every((o) => o.responseMode !== 'required');
+            if (presence?.ownsSharedMessage && allOptional && !handoffTo && isOwnerAuthored(message, this.deps.getOwnerUserId?.())) {
+                this.watchUnanswered(message, mapping, persisted, dispatchOptions.threadId, recipients);
+            }
         }
         else if (!remoteAgent) {
             // Never a silent no-op: say why nobody got it.
@@ -1494,8 +1524,10 @@ export class SlackTeamChannelService {
                 handoffTo,
                 recipients,
             });
-            if (!handoffTo && isOwnerAuthored(message, this.deps.getOwnerUserId?.())) {
-                this.watchUnanswered(message, mapping, persisted, dispatchOptions.threadId);
+            // A message deferred to another machine is watched there, by its
+            // owner, only — two machines running the fallback would answer twice.
+            if (!handoffTo && !presence?.deferredElsewhere && !presence?.fallbackElsewhere && isOwnerAuthored(message, this.deps.getOwnerUserId?.())) {
+                this.watchUnanswered(message, mapping, persisted, dispatchOptions.threadId, recipients);
             }
         }
         return { mapping, message: persisted, mentions: resolved.mentions, dispatch };
@@ -1509,7 +1541,7 @@ export class SlackTeamChannelService {
      * @param persisted - The huddle row it was recorded as
      * @param threadId - Huddle thread the replies land in
      */
-    watchUnanswered(message, mapping, persisted, threadId) {
+    watchUnanswered(message, mapping, persisted, threadId, recipients = []) {
         const threadTs = message.threadTs || message.ts;
         const key = `${message.channelId}:${threadTs}`;
         this.settleUnanswered(key);
@@ -1524,6 +1556,7 @@ export class SlackTeamChannelService {
             threadTs,
             threadId,
             messageId: persisted.id,
+            recipients,
             timer,
         });
     }
@@ -1568,6 +1601,16 @@ export class SlackTeamChannelService {
         try {
             const mapping = this.findBySlackChannelId(pending.slackChannelId);
             const lead = mapping ? await this.localRoomLead(mapping) : null;
+            if (mapping && lead && pending.recipients.includes(lead)) {
+                // The lead already holds it (delivered as optional): handing it over
+                // again would deliver it twice. The owner-message watchdog nudges.
+                this.logger.info('Unanswered room message: the room lead already holds it — no hand-off', {
+                    slackChannel: `#${mapping.slackChannelName}`,
+                    ts: pending.message.ts,
+                    lead,
+                });
+                return;
+            }
             if (mapping && lead) {
                 this.logger.warn('Nobody took an owner room message — waking the room lead here', {
                     slackChannel: `#${mapping.slackChannelName}`,
@@ -1734,6 +1777,9 @@ export class SlackTeamChannelService {
         const isHere = (m) => me ? m.instanceId === me : (this.deps.isLocalAgent?.(localAgentSession(m.agentSession)) ?? false);
         const awakeElsewhere = room.members.some((m) => !isHere(m) && m.awake);
         let wakeWhenAllAsleep = null;
+        // Cloud named the one machine that wakes someone: no other machine runs
+        // its own 90 s fallback for this message.
+        const fallbackElsewhere = !!room.fallback && !(me ? room.fallback.instanceId === me : (this.deps.isLocalAgent?.(localAgentSession(room.fallback.agentSession)) ?? false));
         if (room.fallback) {
             const here = me ? room.fallback.instanceId === me : (this.deps.isLocalAgent?.(localAgentSession(room.fallback.agentSession)) ?? false);
             if (here)
@@ -1752,7 +1798,44 @@ export class SlackTeamChannelService {
             return `${m.displayName}（${awake ? '醒着' : '在睡'}，${here ? '本机' : m.deviceName}）`;
         })
             .join(' · ');
-        return { state: { awakeHere, awakeElsewhere, wakeWhenAllAsleep }, line };
+        // One machine owns an un-@'d message (2026-10-03: the Mac's and the
+        // Air's "Ella" both acted on one owner message in the Mac's room). Every
+        // machine computes the owner from the same Cloud snapshot.
+        const owner = me ? roomOwnerInstance(room) : null;
+        if (owner && owner !== me) {
+            this.logger.info('Shared room: an un-@\'d message belongs to another machine — recorded, not dispatched here', {
+                slackChannel: `#${mapping.slackChannelName}`,
+                ts: message.ts,
+                owner,
+            });
+            return { state: { awakeHere: [], awakeElsewhere: true, wakeWhenAllAsleep: null }, line, deferredElsewhere: true, ...(fallbackElsewhere ? { fallbackElsewhere } : {}) };
+        }
+        const shared = owner === me && new Set(room.members.filter((m) => m.awake).map((m) => m.instanceId)).size > 1;
+        return {
+            state: { awakeHere, awakeElsewhere, wakeWhenAllAsleep },
+            line,
+            ...(shared ? { ownsSharedMessage: true } : {}),
+            ...(fallbackElsewhere ? { fallbackElsewhere } : {}),
+        };
+    }
+    /**
+     * Whether a channel message that has no room mapping on this machine (it
+     * would fall through to the orchestrator) belongs to another machine's
+     * room. The orchestrator must not pick it up and forward it to a local
+     * agent (2026-10-03: the Air's orc routed the Mac's room message to the
+     * Air's Ella).
+     *
+     * @param message - Inbound message
+     * @returns True when another machine owns it
+     */
+    async sharedRoomOwnedElsewhere(message) {
+        const room = message.room;
+        if (!room || message.handoffTo)
+            return false;
+        const me = this.deps.resolveInstanceId ? await this.deps.resolveInstanceId().catch(() => null) : null;
+        const isHere = (m) => me ? m.instanceId === me : (this.deps.isLocalAgent?.(localAgentSession(m.agentSession)) ?? false);
+        const owner = me ? roomOwnerInstance(room) : null;
+        return !!owner && owner !== me && room.members.some((m) => !isHere(m) && m.awake);
     }
     /**
      * Hand a room message to one agent, wherever it runs.