crewly 1.20.203 → 1.20.204

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

@@ -27,7 +27,7 @@
 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 { intakeWithin, slackIntakeMessage, ticketOfOutcome, markAndLinkTicket, linkLateTicket } from '../v3/ticket-channel-hooks.js';
 import { CREWLY_CONSTANTS, RUNTIME_FALLBACK_CONSTANTS } from '../../constants.js';
 import { isInterim } from './slack-typing-placeholder.service.js';
 import { isOwnerAuthored, deliveredSessions } from './slack-auto-working.service.js';
@@ -38,6 +38,8 @@ import * as path from 'path';
 import { promises as fs } from 'fs';
 import { describeSlackError } from './slack.service.js';
 import { isSilentByDefault, } from '../chat-v2/chat-v2.dispatcher.service.js';
+import { ROOM_RESPONDER_CONSTANTS } from '../../constants.js';
+import { buildRoomAgentDirectory, findPriorRoomAnswer, threadOwnerFromSlack, } from './room-responder.js';
 import { getCrewlyHomePath } from '../core/crewly-home.utils.js';
 import { atomicWriteJson, safeReadJson } from '../../utils/file-io.utils.js';
 import { LoggerService } from '../core/logger.service.js';
@@ -96,6 +98,27 @@ export function roomOwnerInstance(room) {
         return room.home.instanceId;
     return awake.sort()[0];
 }
+/**
+ * The one machine that watches a shared-room message nobody on it answers:
+ * the room owner (#1019), else Cloud's fallback machine, else — nobody awake
+ * and no fallback named — the lowest instance id among the machines in the
+ * room that Cloud reports live (`live`, when Cloud sends it; a member it
+ * marks `live: false` never counts). Every machine computes the same answer
+ * from the same snapshot. Because the last resort may still name a machine
+ * that is gone, every other machine that received the message keeps a
+ * note-only watch (see `NOTE_ONLY_WATCH_MS`).
+ *
+ * @param room - Cloud's room presence
+ * @returns Instance id, or null for an empty roster
+ */
+export function roomWatcherInstance(room) {
+    const owner = roomOwnerInstance(room) ?? room.fallback?.instanceId;
+    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;
+}
 /**
  * Whether a mapping is an ad-hoc channel (no Crewly team behind it).
  *
@@ -1357,8 +1380,16 @@ export class SlackTeamChannelService {
                 }
                 return { mapping, message: persisted, mentions: [], dispatch: null };
             }
+            // One responder per message a person wrote; everyone else listens
+            // (specs/2026-10-03-one-responder-per-message.md). Agent-authored posts
+            // keep the older fan-out. A step that does not finish still yields a
+            // responder: without a pin the dispatcher's rules pick one.
+            const oneResponder = remoteAgent
+                ? null
+                : await this.bounded(this.oneResponderFor(message, mapping, members, team ?? null, resolved.mentions, handoffTo, threadId, persisted.id), {}, 'responder', message);
+            const routedOptions = oneResponder ? { ...dispatchOptions, oneResponder } : dispatchOptions;
             const planned = dispatcherForPlan?.planHuddleTargets
-                ? await this.bounded(dispatcherForPlan.planHuddleTargets(channel, persisted, dispatchOptions).catch(() => null), null, 'dispatch plan', message)
+                ? await this.bounded(dispatcherForPlan.planHuddleTargets(channel, persisted, routedOptions).catch(() => null), null, 'dispatch plan', message)
                 : null;
             // Prompt backstop: who the message (or the exchange it may continue)
             // was meant for, when people are in the picture. A direct request inside
@@ -1380,7 +1411,7 @@ export class SlackTeamChannelService {
             // the single intake. Started now, awaited just before dispatch, so the
             // receipt and the agent's `[TICKET:…]` marker do not hold up the eyes /
             // placeholders below.
-            const ticketPromise = this.intakeTicket(message, mapping, resolved.mentions, planned, handoffTo, remoteAgent);
+            const ticketPromise = this.intakeTicket(message, mapping, resolved.mentions, planned, handoffTo, remoteAgent, persisted);
             await this.bounded(this.acknowledgeSeen(message, mapping, resolved.mentions, planned), undefined, 'seen reaction', message);
             // Agents that must reply get a placeholder straight away — "waking up…"
             // for an idle agent (a cold start is 1–2 minutes), "is working on it…"
@@ -1416,6 +1447,9 @@ export class SlackTeamChannelService {
             const typingTargets = [];
             if (this.deps.typing) {
                 for (const session of owing) {
+                    // Rescued meanwhile: the hand-off posts its own placeholder.
+                    if (routeGuard?.rescued())
+                        break;
                     const member = members.find((m) => m.sessionName === session);
                     const installed = this.deps.identities?.getInstalled(session);
                     // Own bot when installed; otherwise the master bot wearing the agent's
@@ -1425,6 +1459,7 @@ export class SlackTeamChannelService {
                         : { displayName: member?.name ?? session, ...slackIdentityFor(member, session) };
                     const key = { agentSession: session, slackChannelId: message.channelId, threadTs: slackThreadTs };
                     const awake = this.deps.isAgentAwake ? this.deps.isAgentAwake(session) : true;
+                    routeGuard?.notePlaceholder(key);
                     await this.bounded(this.deps.typing.begin(key, identity, awake ? 'typing' : 'waking', message.ts), null, 'placeholder', message);
                     typingTargets.push({ session, key });
                 }
@@ -1479,7 +1514,7 @@ export class SlackTeamChannelService {
                     return { mapping, message: persisted, mentions: resolved.mentions, dispatch: null };
                 }
                 dispatch = await dispatcher.dispatchMessage(channel, markAndLinkTicket(persisted, ticket), {
-                    ...dispatchOptions,
+                    ...routedOptions,
                     ...(roster ? { channelRoster: roster } : {}),
                     ...(peopleAddressing ? { peopleAddressing } : {}),
                     ...(slackContext
@@ -1521,8 +1556,19 @@ export class SlackTeamChannelService {
                 unknown: resolved.unknown.map((u) => u.token),
                 strategy: dispatch?.strategy ?? 'none',
                 threaded: !!threadId,
+                ...(oneResponder
+                    ? {
+                        responder: oneResponder.pinned
+                            ? { session: oneResponder.pinned.session, name: oneResponder.pinned.name ?? null, reason: oneResponder.pinned.reason }
+                            : (dispatch?.huddleOutcomes ?? []).map((o) => o.sessionName),
+                        contextOnly: dispatch?.contextOnly ?? [],
+                    }
+                    : {}),
             });
             const recipients = deliveredSessions(dispatch);
+            const heldBy = (dispatch?.huddleOutcomes ?? []).filter((o) => o.dispatched && o.queued).map((o) => o.sessionName);
+            if (oneResponder)
+                this.recordChosenResponders(persisted, dispatch, oneResponder);
             if (dispatch?.dispatched) {
                 // Someone here holds it — including a follow-up in a thread we were
                 // still waiting on.
@@ -1530,8 +1576,11 @@ export class SlackTeamChannelService {
                 // 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);
+                // With one responder the other awake agents no longer hear it, so an
+                // optional responder that stays silent needs the fallback in any room.
+                const optionalResponder = !!oneResponder && (dispatch.huddleOutcomes ?? []).length > 0 && allOptional;
+                if (((presence?.ownsSharedMessage && allOptional) || optionalResponder) && !handoffTo && isOwnerAuthored(message, this.deps.getOwnerUserId?.())) {
+                    this.watchUnanswered(message, mapping, persisted, dispatchOptions.threadId, recipients, heldBy);
                 }
             }
             else if (!remoteAgent) {
@@ -1550,8 +1599,17 @@ export class SlackTeamChannelService {
                 });
                 // 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);
+                // One the decision path consumed, or whose responder runs on another
+                // machine, is that path's / machine's to answer.
+                // A responder on another machine is watched from the room's owner
+                // machine (watchHere): never an owner message without a watcher.
+                const pinned = oneResponder?.pinned;
+                const watchHere = pinned?.watchHere === true;
+                const noteOnly = watchHere && pinned?.watchNoteOnly === true;
+                const answeredElsewhere = !!pinned && !pinned.session && !watchHere;
+                const watchable = watchHere || (!answeredElsewhere && !presence?.deferredElsewhere && !presence?.fallbackElsewhere);
+                if (!handoffTo && watchable && isOwnerAuthored(message, this.deps.getOwnerUserId?.())) {
+                    this.watchUnanswered(message, mapping, persisted, dispatchOptions.threadId, recipients, heldBy, noteOnly);
                 }
             }
             return { mapping, message: persisted, mentions: resolved.mentions, dispatch };
@@ -1564,6 +1622,253 @@ export class SlackTeamChannelService {
             routeGuard?.disarm();
         }
     }
+    /**
+     * Who answers a person's room message, from data only this layer has
+     * (specs/2026-10-03-one-responder-per-message.md §1): the decision path's
+     * outcome (a), else — for an un-@'d thread reply — the Slack thread's
+     * owner (c). @-mentions (b) and the top-level room rule (d) are applied by
+     * the dispatcher. Never throws.
+     *
+     * @param message - Inbound message
+     * @param mapping - Its room
+     * @param members - Agents the room resolves names against (local)
+     * @param team - The room's team, or null for an ad-hoc room
+     * @param mentions - Local agents @'d
+     * @param handoffTo - Local agent the message was handed to
+     * @returns One-responder options for the dispatcher
+     */
+    async oneResponderFor(message, mapping, members, team, mentions, handoffTo, threadId, messageId) {
+        const nameFor = (session) => members.find((m) => m.sessionName === session)?.name ??
+            message.room?.members.find((m) => localAgentSession(m.agentSession) === session)?.displayName;
+        const base = { nameFor };
+        const isThreadReply = !!message.threadTs && message.threadTs !== message.ts;
+        if (handoffTo || !isThreadReply)
+            return base;
+        try {
+            const roomSessions = team ? teamChannelMembers(team).map((m) => m.sessionName) : [...(mapping.members ?? [])];
+            const isLocal = (s) => this.deps.isLocalAgent?.(s) ?? members.some((m) => m.sessionName === s);
+            // Which machine decides when the shared picture is not enough: the
+            // #1019 room owner (or Cloud's fallback machine). Without presence this
+            // machine is the only one that can.
+            const room = message.room ?? null;
+            const me = room && this.deps.resolveInstanceId ? await this.deps.resolveInstanceId().catch(() => null) : null;
+            // The machine that decides and watches (owner, else fallback, else the
+            // lowest instance id). A machine that cannot tell who it is watches
+            // anyway: two watchers beat none (the fallback reads Slack first).
+            const watcher = room ? roomWatcherInstance(room) : null;
+            const ownsRoom = !room || !me || !watcher || watcher === me;
+            const isWatcher = !!room && !!me && (!watcher || watcher === me);
+            // Cloud named no owner and no fallback machine: the last-resort watcher
+            // may be gone, so every machine that received this keeps a note-only
+            // watch. So does a machine that cannot tell who it is.
+            const lastResort = !!room && !roomOwnerInstance(room) && !room.fallback;
+            const noteOnlyHere = !!room && !isWatcher && (!me || lastResort);
+            const watchFlags = () => isWatcher ? { watchHere: true } : noteOnlyHere ? { watchHere: true, watchNoteOnly: true } : {};
+            // Not ours to decide: the owner machine applies the room's rules and watches.
+            const deferToRoomOwner = { ...base, pinned: { session: null, reason: 'deferred', ...watchFlags() } };
+            // Ours to watch, but not to guess: nobody here answers; the 90 s watch does.
+            const watchOnly = { ...base, pinned: { session: null, reason: 'deferred', ...watchFlags() } };
+            // (a) The decision path: one shared run per Slack message.
+            const decision = this.deps.decisionReplyFor
+                ? await withinMs(this.deps.decisionReplyFor(message).catch(() => null), ROOM_RESPONDER_CONSTANTS.DECISION_WAIT_MS, null)
+                : null;
+            if (decision) {
+                const askerHere = isLocal(decision.asker) && roomSessions.includes(decision.asker);
+                const name = nameFor(decision.asker) ?? decision.asker;
+                if (decision.consumed) {
+                    return {
+                        ...base,
+                        pinned: { session: null, answeredBy: decision.asker, name, reason: 'decision-consumed', ...(askerHere ? { alreadyHas: decision.asker } : {}) },
+                    };
+                }
+                if (askerHere)
+                    return { ...base, pinned: { session: decision.asker, answeredBy: decision.asker, name, reason: 'decision' } };
+                // The asker is not in this room and the card is still open: the room's own rules.
+            }
+            if (mentions.length > 0)
+                return base;
+            // (c) The Slack thread's owner — the same answer on every machine.
+            const read = await this.slackThreadOwner(message, members, roomSessions, isLocal);
+            if (!read.readable) {
+                // Machines that cannot read the thread would each guess from their
+                // own log: only the room's owner machine does — and only when its log
+                // can be trusted to name the last speaker. Otherwise it answers
+                // nothing and keeps the 90 s watch.
+                if (!ownsRoom)
+                    return deferToRoomOwner;
+                if (!room)
+                    return base;
+                return this.localThreadLogTrusted(mapping.chatChannelId, threadId, messageId, room, me) ? base : watchOnly;
+            }
+            if (!read.owner)
+                return base;
+            const { agent, via } = read.owner;
+            // A remote owner counts only while Cloud shows it awake — an offline,
+            // 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);
+            if (live || via === 'card') {
+                if (agent.local)
+                    return { ...base, pinned: { session: agent.session, answeredBy: agent.session, name: agent.name, reason: 'thread-owner' } };
+                // An awake asker's machine answers a card through the decision path —
+                // no placeholder, no thread post — so a watch here would hand the
+                // message to our lead at 90 s and answer it twice. Watch only an
+                // asker that is not awake (its machine may be offline).
+                const watch = !(via === 'card' && live);
+                return { ...base, pinned: { session: null, answeredBy: agent.session, name: agent.name, reason: 'thread-owner', ...(watch ? watchFlags() : {}) } };
+            }
+            return ownsRoom ? base : deferToRoomOwner;
+        }
+        catch (err) {
+            this.logger.warn('Could not choose the responder — using the room rules', {
+                slackChannel: mapping.slackChannelName ?? message.channelId,
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+        return base;
+    }
+    /**
+     * Whether this machine's chat log can name a thread's last speaker when
+     * Slack cannot be read. Cloud never forwards other machines' bot posts, so
+     * with colleagues on other machines in the room the log is trusted only
+     * when its latest agent turn in the thread is local and recent.
+     *
+     * @param chatChannelId - The huddle
+     * @param threadId - The thread root here, when known
+     * @param messageId - The message being routed (not counted)
+     * @param room - Cloud's room presence
+     * @param me - This machine's instance id, when known
+     * @returns True when local rules may answer from the log
+     */
+    localThreadLogTrusted(chatChannelId, threadId, messageId, room, me) {
+        const othersInRoom = room.members.some((m) => !me || m.instanceId !== me);
+        if (!othersInRoom)
+            return true;
+        if (!threadId || !this.deps.chat.listThreadForBridge)
+            return false;
+        const rows = this.deps.chat.listThreadForBridge(chatChannelId, threadId).filter((r) => r.id !== messageId);
+        const isLocal = (s) => this.deps.isLocalAgent?.(localAgentSession(s)) ?? false;
+        // A person @'d an agent on another machine: that agent's answer (no @
+        // of anyone here) never reaches this log, so it cannot name the last speaker.
+        const askedElsewhere = (r) => {
+            if (r.senderType !== 'user' || typeof r.metadata?.[OWNER_EVIDENCE_METADATA.REMOTE_AGENT_SESSION] === 'string')
+                return false;
+            const named = r.metadata?.[SLACK_TEAM_CHANNEL_CONSTANTS.AGENT_MENTIONS_METADATA_KEY];
+            return Array.isArray(named) && named.some((s) => typeof s === 'string' && !isLocal(s));
+        };
+        for (let i = rows.length - 1; i >= 0; i--) {
+            const r = rows[i];
+            if (askedElsewhere(r))
+                return false;
+            const remote = r.senderType === 'user' && typeof r.metadata?.[OWNER_EVIDENCE_METADATA.REMOTE_AGENT_SESSION] === 'string';
+            if (r.senderType !== 'agent' && !remote)
+                continue;
+            if (remote)
+                return false;
+            const now = this.deps.now ? this.deps.now().getTime() : Date.now();
+            return now - r.createdAt <= ROOM_RESPONDER_CONSTANTS.LOCAL_LOG_FRESH_MS;
+        }
+        return false;
+    }
+    /**
+     * Record on the owner's row who was chosen to answer it — the reply gate
+     * holds only a post that repeats what one of them already said.
+     *
+     * @param persisted - The owner's huddle row
+     * @param dispatch - What was delivered here
+     * @param one - The one-responder options used
+     */
+    recordChosenResponders(persisted, dispatch, one) {
+        const chosen = [
+            ...new Set([
+                ...(dispatch?.huddleOutcomes ?? []).filter((o) => o.dispatched).map((o) => o.sessionName),
+                ...(one.pinned?.answeredBy ? [one.pinned.answeredBy] : []),
+            ]),
+        ];
+        if (chosen.length === 0 || !this.deps.chat.updateMessageMetadata)
+            return;
+        try {
+            this.deps.chat.updateMessageMetadata(persisted.id, { [ROOM_RESPONDER_CONSTANTS.CHOSEN_RESPONDERS_METADATA_KEY]: chosen });
+        }
+        catch {
+            // The gate then holds nothing for this message: never worse than before.
+        }
+    }
+    /**
+     * The owner of the Slack thread a message replies in, read from Slack
+     * (`message.threadContext`), so every machine names the same agent. Null
+     * owner when no agent has spoken in it; `readable: false` when the thread
+     * could not be read in time.
+     *
+     * @param message - Inbound thread reply
+     * @param members - Local agents the room resolves names against
+     * @param roomSessions - This machine's room members
+     * @param isLocal - Whether a session runs here
+     * @returns The thread owner, or null
+     */
+    async slackThreadOwner(message, members, roomSessions, isLocal) {
+        let ctx = message.threadContext
+            ? await withinMs(message.threadContext, ROOM_RESPONDER_CONSTANTS.THREAD_CONTEXT_WAIT_MS, null)
+            : null;
+        if (!ctx && this.deps.readThreadContext) {
+            // One retry after a short pause; a rate limit's retry-after is waited
+            // out too, up to THREAD_READ_RETRY_MAX_WAIT_MS in all.
+            const backoff = ROOM_RESPONDER_CONSTANTS.THREAD_READ_RETRY_BACKOFF_MS;
+            await new Promise((resolve) => {
+                const t = setTimeout(resolve, backoff);
+                t.unref?.();
+            });
+            const maxWaitMs = ROOM_RESPONDER_CONSTANTS.THREAD_READ_RETRY_MAX_WAIT_MS - backoff;
+            ctx = await withinMs(this.deps.readThreadContext(message, { maxWaitMs }).catch(() => null), ROOM_RESPONDER_CONSTANTS.THREAD_CONTEXT_WAIT_MS + maxWaitMs, null);
+        }
+        if (!ctx)
+            return { readable: false, owner: null };
+        const local = members
+            .filter((m) => roomSessions.includes(m.sessionName))
+            .map((m) => ({ session: m.sessionName, name: m.name, botUserId: this.deps.identities?.get(m.sessionName)?.botUserId ?? null }));
+        const remote = (message.room?.members ?? [])
+            .filter((m) => !isLocal(localAgentSession(m.agentSession)))
+            .map((m) => ({ session: m.agentSession, name: m.displayName }));
+        return { readable: true, owner: threadOwnerFromSlack(ctx, buildRoomAgentDirectory({ local, remote })) };
+    }
+    /**
+     * The reply gate (specs/2026-10-03-one-responder-per-message.md §2): an
+     * agent is about to post in a room thread where a different agent already
+     * answered the owner's latest message. Reads this machine's huddle thread
+     * only — no Slack call.
+     *
+     * @param input - Conversation (huddle id), the thread named (huddle message id or Slack thread key), and the agent
+     * @returns The earlier answer when the post should be held, else null
+     */
+    async heldReplyFor(input) {
+        try {
+            await this.load();
+            const mapping = (this.store?.mappings ?? []).find((m) => m.chatChannelId === input.conversationId);
+            const raw = input.thread?.trim();
+            if (!mapping || !raw || !this.deps.chat.listThreadForBridge)
+                return null;
+            let rootId;
+            const named = this.deps.chat.getMessageForBridge(raw);
+            if (named && named.channelId === input.conversationId)
+                rootId = named.threadId ?? named.id;
+            const key = parseSlackThreadKey(raw);
+            if (!rootId && key && key.slackChannelId === mapping.slackChannelId) {
+                rootId = this.deps.chat.findSlackThreadRoot(input.conversationId, key.threadTs)?.id;
+            }
+            if (!rootId)
+                return null;
+            const thread = this.deps.chat.listThreadForBridge(input.conversationId, rootId).slice(-ROOM_RESPONDER_CONSTANTS.GATE_THREAD_SCAN);
+            const local = (await this.deps.storage.getTeams()).flatMap((t) => teamChannelMembers(t));
+            const nameFor = (s) => local.find((m) => m.sessionName === s)?.name ??
+                this.lastRooms.get(mapping.slackChannelId)?.members.find((m) => localAgentSession(m.agentSession) === s)?.displayName;
+            return findPriorRoomAnswer(thread, input.agentSession, nameFor);
+        }
+        catch {
+            // The gate is a backstop: never block a reply because it failed.
+            return null;
+        }
+    }
     /**
      * Hold an owner's room message that reached nobody here until an agent
      * takes it — on this machine or another — or the fallback runs.
@@ -1573,13 +1878,13 @@ 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, recipients = []) {
+    watchUnanswered(message, mapping, persisted, threadId, recipients = [], heldBy = [], noteOnly = false) {
         const threadTs = message.threadTs || message.ts;
         const key = `${message.channelId}:${threadTs}`;
         this.settleUnanswered(key);
         const timer = setTimeout(() => {
             void this.runUnansweredFallback(key);
-        }, SLACK_TEAM_CHANNEL_CONSTANTS.ROOM_UNANSWERED_FALLBACK_MS);
+        }, noteOnly ? ROOM_RESPONDER_CONSTANTS.NOTE_ONLY_WATCH_MS : SLACK_TEAM_CHANNEL_CONSTANTS.ROOM_UNANSWERED_FALLBACK_MS);
         timer.unref?.();
         this.unanswered.set(key, {
             message,
@@ -1589,6 +1894,8 @@ export class SlackTeamChannelService {
             threadId,
             messageId: persisted.id,
             recipients,
+            ...(heldBy.length > 0 ? { heldBy } : {}),
+            ...(noteOnly ? { noteOnly: true } : {}),
             timer,
         });
     }
@@ -1618,6 +1925,7 @@ export class SlackTeamChannelService {
     armRouteGuard(message, mapping, persisted, threadId) {
         let done = false;
         let rescued = false;
+        const placeholders = [];
         const rescue = (why, err) => {
             if (done)
                 return;
@@ -1633,7 +1941,17 @@ export class SlackTeamChannelService {
                 handoff: message.handoffTo ?? null,
                 ...(err !== undefined ? { error: err instanceof Error ? err.message : String(err) } : {}),
             });
-            void this.rescueUnroutedMessage(message, mapping, persisted, threadId).catch((rescueErr) => this.logger.error('Could not rescue an unrouted owner room message', {
+            // The original routing's placeholders come down first (quietly): the
+            // hand-off posts its own, and a placeholder of an agent that never
+            // got the message would promise an answer nobody owes.
+            const withdraw = async () => {
+                for (const key of placeholders.splice(0)) {
+                    await this.deps.typing?.withdraw?.(key).catch(() => 0);
+                }
+            };
+            void withdraw()
+                .then(() => this.rescueUnroutedMessage(message, mapping, persisted, threadId))
+                .catch((rescueErr) => this.logger.error('Could not rescue an unrouted owner room message', {
                 ts: message.ts,
                 error: rescueErr instanceof Error ? rescueErr.message : String(rescueErr),
             }));
@@ -1650,6 +1968,11 @@ export class SlackTeamChannelService {
             // After dispatch started, a throw is not an undelivered message:
             // rescuing then could deliver it twice.
             fail: (err) => rescue('failed', err),
+            rescued: () => rescued,
+            notePlaceholder: (key) => {
+                if (!rescued)
+                    placeholders.push(key);
+            },
             dispatchStarting: () => {
                 if (rescued)
                     return false;
@@ -1762,7 +2085,43 @@ export class SlackTeamChannelService {
             return;
         this.unanswered.delete(key);
         try {
+            // The chosen responder holds it on its queue (it was busy): it will
+            // answer when idle; handing it to the lead too means two answers.
+            if ((pending.heldBy ?? []).length > 0) {
+                this.logger.info('Unanswered room message: the responder holds it on its queue — no hand-off', {
+                    slackChannel: pending.slackChannelId,
+                    ts: pending.message.ts,
+                    heldBy: pending.heldBy,
+                });
+                return;
+            }
+            // An agent — here or on another machine — already replied in the
+            // thread, or shows "working on it": nothing to hand over.
+            const after = this.deps.slackRepliesAfter
+                ? await withinMs(this.deps.slackRepliesAfter(pending.slackChannelId, pending.threadTs, pending.message.ts).catch(() => null), ROOM_RESPONDER_CONSTANTS.THREAD_CONTEXT_WAIT_MS, null)
+                : null;
+            const harnessNotes = [SLACK_TEAM_CHANNEL_CONSTANTS.ROOM_UNANSWERED_NOTE, SLACK_TEAM_CHANNEL_CONSTANTS.ROOM_ROUTE_STALLED_NOTE];
+            if (after?.some((m) => m.isBot && !harnessNotes.includes(m.text.trim()))) {
+                this.logger.info('Unanswered room message: an agent has replied or is working on it in Slack — no hand-off', {
+                    slackChannel: pending.slackChannelId,
+                    ts: pending.message.ts,
+                });
+                return;
+            }
             const mapping = this.findBySlackChannelId(pending.slackChannelId);
+            // Not this machine's to hand over (another may be the watcher), or the
+            // thread could not be read just now: tell the owner rather than hand
+            // it over blind and risk a second answer.
+            const unreadable = !!this.deps.slackRepliesAfter && after === null && !!pending.timer;
+            if (pending.noteOnly || unreadable) {
+                this.logger.warn('Unanswered room message: telling the owner instead of handing it over', {
+                    slackChannel: pending.slackChannelId,
+                    ts: pending.message.ts,
+                    reason: pending.noteOnly ? 'not this machine\'s hand-off' : 'Slack thread unreadable',
+                });
+                await this.postUnansweredNote(pending, mapping);
+                return;
+            }
             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
@@ -1877,7 +2236,7 @@ export class SlackTeamChannelService {
      * @param remoteAgent - Authoring agent, when an agent wrote it
      * @returns The ticket the message belongs to, or null
      */
-    async intakeTicket(message, mapping, mentions, planned, handoffTo, remoteAgent) {
+    async intakeTicket(message, mapping, mentions, planned, handoffTo, remoteAgent, delivered) {
         try {
             const intake = getTicketIntakeService();
             if (!intake || remoteAgent)
@@ -1901,7 +2260,16 @@ export class SlackTeamChannelService {
                 userName: message.user?.realName || message.user?.name,
                 hasFiles: message.hasFiles,
                 ownerUserId: this.deps.getOwnerUserId?.() ?? null,
-            }, 'team-channel', { ...(targetAgent ? { targetAgent } : {}), ...(postAs ? { receiptPostAs: postAs } : {}) }));
+            }, 'team-channel', { ...(targetAgent ? { targetAgent } : {}), ...(postAs ? { receiptPostAs: postAs } : {}) }), undefined, 
+            // Filed after the message went out without its marker: link the
+            // ticket to the copy that was dispatched (crewly#1015 follow-up L2).
+            delivered
+                ? (late) => {
+                    const linked = linkLateTicket(late, delivered);
+                    if (linked)
+                        this.logger.info('Late ticket linked to the delivered message', { ticketId: linked.id, messageId: delivered.id });
+                }
+                : undefined);
             return ticketOfOutcome(outcome);
         }
         catch (err) {
@@ -3169,6 +3537,28 @@ export class SlackTeamChannelService {
     }
 }
 /** Type guard for persisted mapping rows. */
+/**
+ * A promise's value, or `fallback` when it takes longer than `ms`.
+ *
+ * @param promise - What to wait for
+ * @param ms - Longest wait
+ * @param fallback - Value on timeout
+ * @returns The value, or the fallback
+ */
+async function withinMs(promise, ms, fallback) {
+    let timer;
+    const timeout = new Promise((resolve) => {
+        timer = setTimeout(() => resolve(fallback), ms);
+        timer.unref?.();
+    });
+    try {
+        return await Promise.race([promise, timeout]);
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
+}
 function isMapping(value) {
     const v = value;
     return (!!v &&