crewly 1.20.225 → 1.20.227

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

@@ -44,6 +44,7 @@ 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 { getOwnerMessageWatchdog } from '../messaging/owner-message-watchdog.service.js';
 import { LoggerService } from '../core/logger.service.js';
 import { getSlackDirectoryService } from './slack-directory.service.js';
 import { SLACK_TEAM_CHANNEL_CONSTANTS, OWNER_EVIDENCE_METADATA, SLACK_THREAD_KEY_CONSTANTS } from '../../constants.js';
@@ -422,6 +423,7 @@ export class SlackTeamChannelService {
                 void this.inviteInstalledEverywhere(record.agentSession);
             }) ?? null;
         this.started = true;
+        await this.restoreUnanswered();
         this.logger.info('Slack team channels started', {
             mappings: this.store?.mappings.length ?? 0,
             autoCreate: this.store?.autoCreate ?? true,
@@ -1772,10 +1774,15 @@ export class SlackTeamChannelService {
                 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);
+                // A card answer consumed by the decision path for an asker on THIS
+                // machine is not answered elsewhere: the asker only got a note, which
+                // may sit on its queue while it is busy (2026-10-05, D-270: 18 min,
+                // no watch). Watched here, so the fallback follows it up.
+                const cardAsker = pinned?.reason === 'decision-consumed' && pinned.alreadyHas ? pinned.alreadyHas : null;
+                const answeredElsewhere = !!pinned && !pinned.session && !watchHere && !cardAsker;
+                const watchable = watchHere || !!cardAsker || (!answeredElsewhere && !presence?.deferredElsewhere && !presence?.fallbackElsewhere);
                 if (!handoffTo && watchable && isOwnerAuthored(message, this.deps.getOwnerUserId?.())) {
-                    this.watchUnanswered(message, mapping, persisted, dispatchOptions.threadId, recipients, heldBy, noteOnly);
+                    this.watchUnanswered(message, mapping, persisted, dispatchOptions.threadId, recipients, heldBy, noteOnly, cardAsker);
                 }
             }
             return { mapping, message: persisted, mentions: resolved.mentions, dispatch };
@@ -2050,14 +2057,16 @@ 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 = [], heldBy = [], noteOnly = false) {
+    watchUnanswered(message, mapping, persisted, threadId, recipients = [], heldBy = [], noteOnly = false, decisionAsker = null) {
         const threadTs = message.threadTs || message.ts;
         const key = `${message.channelId}:${threadTs}`;
         this.settleUnanswered(key);
+        const waitMs = noteOnly ? ROOM_RESPONDER_CONSTANTS.NOTE_ONLY_WATCH_MS : SLACK_TEAM_CHANNEL_CONSTANTS.ROOM_UNANSWERED_FALLBACK_MS;
         const timer = setTimeout(() => {
             void this.runUnansweredFallback(key);
-        }, noteOnly ? ROOM_RESPONDER_CONSTANTS.NOTE_ONLY_WATCH_MS : SLACK_TEAM_CHANNEL_CONSTANTS.ROOM_UNANSWERED_FALLBACK_MS);
+        }, waitMs);
         timer.unref?.();
+        const armedAt = Date.now();
         this.unanswered.set(key, {
             message,
             chatChannelId: mapping.chatChannelId,
@@ -2068,8 +2077,12 @@ export class SlackTeamChannelService {
             recipients,
             ...(heldBy.length > 0 ? { heldBy } : {}),
             ...(noteOnly ? { noteOnly: true } : {}),
+            ...(decisionAsker ? { decisionAsker } : {}),
+            armedAt,
+            dueAt: armedAt + waitMs,
             timer,
         });
+        this.persistUnanswered();
     }
     /** Stop waiting on a message: someone has it. */
     settleUnanswered(key) {
@@ -2079,6 +2092,73 @@ export class SlackTeamChannelService {
         if (pending.timer)
             clearTimeout(pending.timer);
         this.unanswered.delete(key);
+        this.persistUnanswered();
+    }
+    /** @returns Where pending watches are kept across restarts */
+    unansweredStorePath() {
+        return this.deps.unansweredStorePath ?? path.join(path.dirname(this.storePath), SLACK_TEAM_CHANNEL_CONSTANTS.ROOM_UNANSWERED_STORE_FILENAME);
+    }
+    unansweredWrite = Promise.resolve();
+    /**
+     * Write the pending watches (those with a timer) to disk, serialised and
+     * best-effort: a watch armed seconds before a restart must not vanish
+     * with its timer.
+     */
+    persistUnanswered() {
+        if (!this.started)
+            return;
+        const rows = [];
+        for (const [key, p] of this.unanswered) {
+            if (!p.timer)
+                continue;
+            const { timer: _timer, ...rest } = p;
+            void _timer;
+            const message = { ...rest.message };
+            delete message.threadContext;
+            rows.push({ ...rest, message, key, armedAt: p.armedAt ?? Date.now(), dueAt: p.dueAt ?? Date.now() });
+        }
+        const file = this.unansweredStorePath();
+        this.unansweredWrite = this.unansweredWrite
+            .then(async () => {
+            await fs.mkdir(path.dirname(file), { recursive: true });
+            await atomicWriteJson(file, { version: 1, watches: rows });
+        })
+            .catch((err) => this.logger.warn('Could not persist pending unanswered-message watches', { error: err instanceof Error ? err.message : String(err) }));
+    }
+    /**
+     * Re-arm the watches pending when the process last stopped. Each fires at
+     * its original due time, but no sooner than a grace period after boot;
+     * one older than the restore limit is dropped (the owner-message
+     * watchdog, also persisted, owns long waits).
+     */
+    async restoreUnanswered() {
+        const raw = await safeReadJson(this.unansweredStorePath(), null).catch(() => null);
+        const rows = Array.isArray(raw?.watches) ? raw.watches : [];
+        const now = Date.now();
+        let restored = 0;
+        for (const row of rows) {
+            if (!row || typeof row.key !== 'string' || !row.message || typeof row.armedAt !== 'number')
+                continue;
+            if (this.unanswered.has(row.key))
+                continue;
+            if (now - row.armedAt > SLACK_TEAM_CHANNEL_CONSTANTS.ROOM_UNANSWERED_RESTORE_MAX_AGE_MS) {
+                this.logger.info('Dropped a pending unanswered-message watch from before the restart — too old', { key: row.key });
+                continue;
+            }
+            const due = typeof row.dueAt === 'number' ? row.dueAt : row.armedAt + SLACK_TEAM_CHANNEL_CONSTANTS.ROOM_UNANSWERED_FALLBACK_MS;
+            const delay = Math.max(due - now, SLACK_TEAM_CHANNEL_CONSTANTS.ROOM_UNANSWERED_RESTORE_GRACE_MS);
+            const { key, ...entry } = row;
+            const timer = setTimeout(() => {
+                void this.runUnansweredFallback(key);
+            }, delay);
+            timer.unref?.();
+            this.unanswered.set(key, { ...entry, timer });
+            restored += 1;
+        }
+        if (restored > 0) {
+            this.logger.info('Restored pending unanswered-message watches from before the restart', { restored });
+            this.persistUnanswered();
+        }
     }
     /**
      * Arm the route guard for an owner's room message that was just recorded
@@ -2256,6 +2336,7 @@ export class SlackTeamChannelService {
         if (!pending)
             return;
         this.unanswered.delete(key);
+        this.persistUnanswered();
         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.
@@ -2280,6 +2361,10 @@ export class SlackTeamChannelService {
                 });
                 return;
             }
+            if (pending.decisionAsker) {
+                this.followUpCardAnswer(pending);
+                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
@@ -2327,6 +2412,50 @@ export class SlackTeamChannelService {
             });
         }
     }
+    /**
+     * The owner answered a card in its thread, the asker (here) got the
+     * answer as a note, and nothing has been posted in the thread since. No
+     * hand-off to the lead — the answer is the asker's to act on; the
+     * owner-message watchdog now follows it up with the asker (a reminder at
+     * its first deadline, then a note to the owner), and it survives a restart.
+     *
+     * @param pending - The watch that fell due
+     */
+    followUpCardAnswer(pending) {
+        const asker = pending.decisionAsker;
+        const tsMs = Math.round(Number.parseFloat(pending.message.ts) * 1000);
+        const input = {
+            surface: 'slack',
+            slackChannelId: pending.slackChannelId,
+            threadTs: pending.threadTs,
+            sourceTs: pending.message.ts,
+            chatChannelId: pending.chatChannelId,
+            chatThreadId: pending.threadId,
+            messageId: pending.messageId,
+            responsible: asker,
+            recipients: [asker],
+            required: true,
+            text: pending.message.text ?? '',
+            ...(Number.isFinite(tsMs) && tsMs > 0 ? { receivedAt: tsMs } : {}),
+        };
+        this.logger.warn('Owner answered a decision card, and its asker has not replied in the thread yet — following it up', {
+            slackChannel: pending.slackChannelId,
+            ts: pending.message.ts,
+            asker,
+        });
+        try {
+            if (this.deps.trackOwnerMessage)
+                this.deps.trackOwnerMessage(input);
+            else
+                getOwnerMessageWatchdog()?.track(input, { afterDecision: true });
+        }
+        catch (err) {
+            this.logger.warn('Could not hand the card answer to the owner-message watchdog', {
+                asker,
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+    }
     /**
      * The member of a room that should pick up a message nobody took, among
      * the agents that run on this machine: whoever of them spoke there last