crewly 1.20.208 → 1.20.209

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

@@ -87,16 +87,34 @@ export function slackChannelNameFor(teamName, prefix = '') {
  * there is awake; otherwise the lowest instance id among machines with an
  * awake room member. Null when nobody is awake (Cloud's fallback decides).
  *
+ * Cloud's delivery facts come first (specs/2026-10-04-room-delivery-audit.md):
+ * the responder Cloud names (`delivery.owner`) is the owner — Cloud pushes it
+ * first and names another if it cannot be reached. Without one, the owner is
+ * computed among the machines Cloud delivered to (`delivery.targets`) only,
+ * a machine with an awake team leader first: exactly one machine takes the
+ * message, and never one that does not have it (2026-10-03, #content-team:
+ * nobody; review of crewly-services#32: "uncertain" must not mean everyone).
+ *
  * @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))];
+    const delivery = room.delivery;
+    if (delivery?.owner)
+        return delivery.owner;
+    const targets = delivery && Array.isArray(delivery.targets) && delivery.targets.length > 0 ? delivery.targets : null;
+    const awakeMembers = room.members.filter((m) => m.awake && (!targets || targets.includes(m.instanceId)));
+    const awake = [...new Set(awakeMembers.map((m) => m.instanceId))].sort();
     if (awake.length === 0)
         return null;
     if (room.home && awake.includes(room.home.instanceId))
         return room.home.instanceId;
-    return awake.sort()[0];
+    if (delivery) {
+        const withLeader = [...new Set(awakeMembers.filter((m) => m.leader).map((m) => m.instanceId))].sort();
+        if (withLeader.length > 0)
+            return withLeader[0];
+    }
+    return awake[0];
 }
 /**
  * The one machine that watches a shared-room message nobody on it answers:
@@ -116,8 +134,12 @@ export function roomWatcherInstance(room) {
     if (owner)
         return owner;
     const live = (m) => m.live;
-    const pool = room.members.some((m) => live(m) === true) ? room.members.filter((m) => live(m) === true) : room.members.filter((m) => live(m) !== false);
-    return [...new Set(pool.map((m) => m.instanceId))].sort()[0] ?? null;
+    // Only a machine Cloud delivered this message to can watch it.
+    const targets = room.delivery?.targets;
+    const members = Array.isArray(targets) && targets.length > 0 ? room.members.filter((m) => targets.includes(m.instanceId)) : room.members;
+    const pool = members.some((m) => live(m) === true) ? members.filter((m) => live(m) === true) : members.filter((m) => live(m) !== false);
+    const fromMembers = [...new Set(pool.map((m) => m.instanceId))].sort()[0];
+    return fromMembers ?? (Array.isArray(targets) ? [...targets].sort()[0] ?? null : null);
 }
 /**
  * Whether a mapping is an ad-hoc channel (no Crewly team behind it).
@@ -2444,6 +2466,21 @@ export class SlackTeamChannelService {
         this.logger.info('Room message handed to an agent on another machine', { agentSession: hit.session, slackChannel: mapping.slackChannelName });
         return { ok: true, agentSession: hit.session, displayName: hit.name, via: 'cloud' };
     }
+    /**
+     * Every Slack channel this machine maps — team channels and ad-hoc rooms —
+     * with the local agents in it. What the delivery audit reads Slack for.
+     *
+     * @returns Channel id, name and local member sessions
+     */
+    async listMappedRooms() {
+        await this.load();
+        const teams = await this.deps.storage.getTeams();
+        return (this.store?.mappings ?? []).map((m) => {
+            const team = isAdhocMapping(m) ? undefined : teams.find((t) => t.id === m.teamId);
+            const members = team ? teamChannelMembers(team).map((x) => x.sessionName) : [...(m.members ?? [])];
+            return { slackChannelId: m.slackChannelId, slackChannelName: m.slackChannelName, members };
+        });
+    }
     /**
      * The ad-hoc rooms this machine's agents are in, for the Cloud heartbeat —
      * Cloud builds each room's cross-machine roster from these.