crewly 1.20.364 → 1.20.366

package/dist/backend/backend/src/services/orc/reply-destination.wiring.js

@@ -12,9 +12,10 @@ import { REPLY_ROUTING_CONSTANTS, TURN_TRIGGER_CONSTANTS } from '../../constants
 import { parseSlackThreadKey } from '../slack/slack-thread-key.js';
 import { LoggerService } from '../core/logger.service.js';
 import { AgentPromptReferenceService } from './agent-prompt-reference.service.js';
-import { fixCommand, resolveReplyDestination, } from './reply-destination-resolver.js';
+import { fixCommand, latestInputOf, resolveReplyDestination, } from './reply-destination-resolver.js';
 import { defaultWorkDestinationDeps, deliverToWorkDestination } from './work-item-destination.wiring.js';
-import { currentWorkItemOf, shortTopic, withTopicLine } from './work-item-destination.js';
+import { originOfWorkItem } from './work-item-destination.js';
+import { comparePostPlace, placeOfOwnerRoute, routeOfTrigger } from './message-route.js';
 import { isSlackDm } from './orc-reply-route.service.js';
 import { traceOutboundReply } from '../trace/trace-recorder.js';
 import { stripTraceMarkers } from '../trace/trace-markers.js';
@@ -35,13 +36,12 @@ const logger = LoggerService.getInstance().createComponentLogger('ReplyDestinati
  * Resolve and deliver an agent's message. Never guesses: a destination that
  * does not take the message is reported as an error with the command to run.
  *
- * When the chosen place refuses the message, only these real places are
- * tried next (each logged), never "the latest thread" or the global current
- * conversation:
- *  - a hint that did not take it → resolution without the hints;
- *  - the current work's owner conversation → a new top-level post in the
- *    team channel, opened with the work's topic;
- *  - the current work's Slack place → the owner's turn origin, else the DM.
+ * When the chosen place refuses the message, only the SAME place is tried
+ * by another way (each logged): the Slack thread a delegate was handed, or
+ * the Slack thread a chat thread with no row stands for. It is never moved
+ * to another place — not a new top-level post, not the owner DM, not the
+ * agent's last owner conversation (message-routing audit 2026-10-18, R2):
+ * the agent gets the error and the command that works.
  *
  * @param input - Agent, text, references, hints
  * @param deps - Collaborators (default: the real ones)
@@ -71,8 +71,95 @@ export async function deliverReply(input, deps) {
         recentDeliveries.set(dupKey, { at: Date.now(), delivery: result });
     }
     traceOutboundReply(clean, result);
+    if (result.ok)
+        await checkLandedRoute(clean, result, deps).catch(() => undefined);
     return result;
 }
+/** Route check outcomes since boot (the regression check of the routing invariant). */
+const routeCheckStats = { match: 0, mismatch: 0, unknown: 0 };
+/**
+ * Counts of the route check since boot.
+ *
+ * @returns match / mismatch / unknown counts
+ */
+export function getRouteCheckStats() {
+    return { ...routeCheckStats };
+}
+/** Zero the route check counts (tests). */
+export function resetRouteCheckStatsForTesting() {
+    routeCheckStats.match = 0;
+    routeCheckStats.mismatch = 0;
+    routeCheckStats.unknown = 0;
+}
+/**
+ * Compare where a delivered post landed with the place of the request it
+ * answers (the route of the agent's latest routed input), and log a
+ * mismatch. A post the agent addressed by an explicit reference answers that
+ * reference and is not checked; an internal message to an agent has no
+ * Slack place. Never throws, never blocks: it is a regression signal.
+ *
+ * @param input - The delivered input
+ * @param delivery - Where it landed
+ * @param deps - Collaborators (default: the real ones)
+ * @returns The outcome, or null when not checked
+ */
+export async function checkLandedRoute(input, delivery, deps) {
+    const dest = delivery.destination;
+    if (REFERENCE_SOURCES.has(dest.source) || dest.source === 'prompt' || delivery.agentSession)
+        return null;
+    const d = deps ?? (await defaultReplyDeliveryDeps());
+    const trigger = d.routedTrigger?.(input.session) ?? null;
+    const route = routeOfTrigger(trigger, d.resolver.turnOrigin(input.session));
+    if (!route)
+        return null;
+    const expected = await expectedPlaceOf(route, d);
+    const landed = {
+        ...(delivery.conversationId ? { conversationId: delivery.conversationId } : {}),
+        ...(dest.kind === 'conversation' && dest.thread ? { thread: dest.thread } : {}),
+        ...(delivery.slackChannelId ? { slackChannelId: delivery.slackChannelId } : {}),
+        ...(delivery.threadTs ? { threadTs: delivery.threadTs } : {}),
+    };
+    const outcome = expected === 'internal' ? 'mismatch' : comparePostPlace(expected, landed);
+    routeCheckStats[outcome] += 1;
+    if (outcome === 'mismatch') {
+        logger.warn('[RouteCheck] Post landed outside the thread of the request it answers', {
+            session: input.session,
+            route,
+            expected: expected === 'internal' ? 'internal (agent-to-agent)' : expected,
+            landed,
+            source: dest.source,
+            mismatches: routeCheckStats.mismatch,
+        });
+    }
+    return outcome;
+}
+/**
+ * The place a route's answer belongs in: an owner route's thread, a work
+ * item's owner origin, or `internal` for work an agent delegated (its answer
+ * goes to that agent, never to Slack).
+ *
+ * @param route - The route
+ * @param d - Collaborators
+ * @returns The place, `internal`, or null when unknown
+ */
+async function expectedPlaceOf(route, d) {
+    if (route.kind === 'owner')
+        return placeOfOwnerRoute(route);
+    const wi = await d.resolver.workItem(route.workItemId).catch(() => null);
+    const origin = wi ? originOfWorkItem(wi) : null;
+    if (!origin)
+        return null;
+    if (origin.kind === 'agent')
+        return 'internal';
+    if (origin.kind !== 'owner')
+        return null;
+    return {
+        ...(origin.conversationId ? { conversationId: origin.conversationId } : {}),
+        ...(origin.chatThreadId ? { thread: origin.chatThreadId } : {}),
+        ...(origin.slackChannelId ? { slackChannelId: origin.slackChannelId } : {}),
+        ...(origin.threadTs ? { threadTs: origin.threadTs } : {}),
+    };
+}
 /**
  * {@link deliverReply} without the run-trace record.
  *
@@ -103,16 +190,15 @@ async function deliverReplyUntraced(input, deps) {
     const delegated = await postToDelegatedThread(input, dest, d);
     if (delegated)
         return delegated;
-    const ownDm = dest.source === 'hint' ? null : await ownDmInsteadOfOthers(input, dest, d);
-    if (ownDm) {
-        logger.warn('Destination is another agent\'s DM with the owner — answering in this agent\'s own owner DM', {
-            session: input.session,
-            from: dest.kind === 'conversation' ? dest.conversationId : undefined,
-            to: ownDm.dest.conversationId,
-        });
-        const viaDm = await attempt({ ...input, content: ownDm.content }, ownDm.dest, prompt, d);
-        if (viaDm.ok)
-            return viaDm;
+    // Work handed over from another agent's DM with the owner: this agent
+    // cannot post there, and its answer is not moved to its own DM — it goes
+    // to the agent the owner asked (message-routing audit 2026-10-18, R2).
+    if (!result.ok && dest.kind === 'conversation' && (await isOthersOwnerDm(input.session, dest.conversationId, d))) {
+        const delegator = await delegatorOfWork(input, d);
+        return {
+            ...result,
+            error: notDelivered(`conversation ${dest.conversationId} is another agent's DM with the owner, where you cannot post`, delegator ? `send-message --to ${delegator} "<your answer>"  (${delegator} answers the owner there)` : 'send your answer to the agent who handed you this work (send-message --to <agent>)'),
+        };
     }
     const hintedThread = dest.source === 'hint' && dest.kind === 'conversation' ? dest.thread : undefined;
     if (dest.source === 'hint') {
@@ -128,25 +214,10 @@ async function deliverReplyUntraced(input, deps) {
         logger.warn('The conversation the agent named did not take its message', { session: input.session, error: result.error });
         return withCardFix(result, hintedThread, d);
     }
-    // The current WORK's place refused it (the owner's own turn origin is not
-    // swapped for another place: that is an error the agent sees).
-    if (dest.source === 'current-work') {
-        const fallback = await currentWorkFallback(input.session, dest, d);
-        if (fallback) {
-            logger.warn('Current work destination did not take the message — trying the next real place', {
-                session: input.session,
-                from: dest.kind === 'work' ? dest.destination.kind : 'conversation',
-                to: fallback.kind === 'work' ? fallback.destination.kind : `conversation ${fallback.conversationId}`,
-            });
-            const retry = await attempt(input, fallback, prompt, d);
-            if (retry.ok)
-                return retry;
-        }
-    }
-    // An answered reference (decision / ticket / work item / message) must not
-    // die in a thread the conversation could not post into: post straight to
-    // that Slack thread, then as a new top-level post in the room's channel.
-    if (dest.kind === 'conversation' && REFERENCE_SOURCES.has(dest.source)) {
+    // An answered reference (decision / ticket / work item / message / route)
+    // must not die in a thread the conversation could not post into: post
+    // straight to that same Slack thread. Never a new top-level post instead.
+    if (dest.kind === 'conversation' && (REFERENCE_SOURCES.has(dest.source) || dest.source === 'route' || dest.source === 'current-work' || dest.source === 'turn-origin')) {
         for (const fallback of await referenceFallbacks(input.session, dest, d)) {
             logger.warn('Referenced conversation did not take the reply — trying the next real place', {
                 session: input.session,
@@ -260,8 +331,8 @@ async function withCardFix(result, thread, d) {
 const REFERENCE_SOURCES = new Set(['decision', 'ticket', 'work-item', 'message']);
 /**
  * Where an answered reference goes when its conversation refused the post:
- * the Slack thread it names (a card posted straight to Slack has no chat row),
- * then a new top-level post in the room's channel.
+ * the Slack thread it names (a card posted straight to Slack has no chat
+ * row). Only that same thread — never a new top-level post.
  *
  * @param session - Agent
  * @param failed - The conversation destination that refused
@@ -280,13 +351,7 @@ async function referenceFallbacks(session, failed, d) {
             reason: `conversation ${failed.conversationId} could not post into thread ${failed.thread} — Slack thread post`,
         });
     }
-    const wi = currentWorkItemOf(await d.resolver.poolItems().catch(() => []), session);
-    out.push({
-        kind: 'work',
-        destination: { kind: 'new-top-level', ...(wi ? { topic: shortTopic(wi.title) } : {}), reason: `conversation ${failed.conversationId} did not take the reply` },
-        source: failed.source,
-        reason: `conversation ${failed.conversationId} did not take the reply — new top-level post`,
-    });
+    void session;
     return out;
 }
 /**
@@ -298,67 +363,45 @@ async function referenceFallbacks(session, failed, d) {
  * @param prompt - The agent's prompt reference
  * @returns A different instruction, or empty when there is none
  */
+/**
+ * What to do when the place a reply resolved to cannot take it. Resending
+ * the same `reply` would resolve to the same place, so the advice names
+ * the explicit alternatives (message-routing audit 2026-10-18: refusals
+ * must be actionable).
+ */
+const UNPOSTABLE_ADVICE = 'reply --conversation <id> --thread <thread> "<message>" to name a place you can post in, or tell whoever gave you this work (send-message --to <session> "<message>")';
 function retryAdvice(dest, prompt) {
     const same = REFERENCE_SOURCES.has(dest.source) || dest.source === 'prompt';
     const cmd = fixCommand(prompt);
     return same && cmd !== 'reply "<your message>"' ? '' : cmd;
 }
 /**
- * The agent's own owner DM, when the destination that refused its message is
- * ANOTHER agent's DM with the owner (work delegated from that DM). The text
- * is opened with `Re: <work title>` so the owner sees what it answers.
+ * Whether a conversation is another agent's DM with the owner (a Slack DM
+ * the replying agent is not in).
  *
- * @param input - Agent, text, references
- * @param failed - The destination that refused
+ * @param session - Replying agent
+ * @param conversationId - The conversation that refused
  * @param d - Collaborators
- * @returns The DM destination and the text to post, or null
+ * @returns True for another agent's owner DM
  */
-async function ownDmInsteadOfOthers(input, failed, d) {
-    if (failed.kind !== 'conversation')
-        return null;
-    const slack = d.resolver.slackChannelOfConversation(failed.conversationId);
+async function isOthersOwnerDm(session, conversationId, d) {
+    const slack = d.resolver.slackChannelOfConversation(conversationId);
     if (!slack || !isSlackDm(slack))
-        return null;
-    if (await d.resolver.ownsConversation(input.session, failed.conversationId).catch(() => true))
-        return null;
-    const dm = await d.resolver.ownerDm(input.session).catch(() => null);
-    if (!dm || dm === failed.conversationId)
-        return null;
-    const wi = input.reference?.workItemId
-        ? await d.resolver.workItem(input.reference.workItemId).catch(() => null)
-        : currentWorkItemOf(await d.resolver.poolItems().catch(() => []), input.session);
-    const topic = wi ? `Re: ${shortTopic(wi.title)}` : undefined;
-    return {
-        dest: { kind: 'conversation', conversationId: dm, source: 'owner-dm', reason: 'the owner asked in a DM with another agent — your DM with the owner' },
-        content: withTopicLine(topic, input.content),
-    };
+        return false;
+    return !(await d.resolver.ownsConversation(session, conversationId).catch(() => true));
 }
 /**
- * The next real place after the current work's destination refused a message.
+ * The agent that handed the replier the work it is answering, when known.
  *
- * @param session - Agent
- * @param failed - The destination that refused
+ * @param input - Agent, reference
  * @param d - Collaborators
- * @returns A fallback destination, or null
+ * @returns The delegator's session, or null
  */
-async function currentWorkFallback(session, failed, d) {
-    if (failed.kind === 'conversation') {
-        const items = await d.resolver.poolItems().catch(() => []);
-        const wi = currentWorkItemOf(items, session);
-        return {
-            kind: 'work',
-            destination: { kind: 'new-top-level', ...(wi ? { topic: shortTopic(wi.title) } : {}), reason: `conversation ${failed.conversationId} did not take the reply` },
-            source: 'current-work',
-            reason: `conversation ${failed.conversationId} did not take the reply — new top-level post`,
-        };
-    }
-    const origin = d.resolver.turnOrigin(session);
-    if (origin) {
-        const thread = origin.slackThreadKey ?? origin.chatThreadId;
-        return { kind: 'conversation', conversationId: origin.conversationId, ...(thread ? { thread } : {}), source: 'turn-origin', reason: 'the work destination did not take the reply — your last owner conversation' };
-    }
-    const dm = await d.resolver.ownerDm(session).catch(() => null);
-    return dm ? { kind: 'conversation', conversationId: dm, source: 'owner-dm', reason: 'the work destination did not take the reply — your DM with the owner' } : null;
+async function delegatorOfWork(input, d) {
+    const id = input.reference?.workItemId ?? d.resolver.latestInput?.(input.session)?.workItemId;
+    const wi = id ? await d.resolver.workItem(id).catch(() => null) : null;
+    const by = wi?.metadata?.delegatedBy;
+    return typeof by === 'string' && by && by !== input.session ? by : null;
 }
 /**
  * Why the agent is posting: the provenance record for the row and the text
@@ -371,15 +414,21 @@ async function currentWorkFallback(session, failed, d) {
  * @param d - Collaborators
  * @returns Metadata and the text to post, or null when no trigger is known
  */
-async function provenanceOf(input, postedConversationId, d) {
+async function provenanceOf(input, postedConversationId, d, answering) {
     try {
-        const trigger = d.turnTrigger?.(input.session) ?? null;
+        const trigger = triggerOfAnsweredInput(input.session, d, answering);
         if (!trigger)
             return null;
         const workItem = trigger.workItemId ? await d.resolver.workItem(trigger.workItemId).catch(() => null) : null;
+        // The post answers the owner's message in the conversation it lands in
+        // when the owner wrote to the agent there — even when a newer owner
+        // message elsewhere is the agent's latest (R8).
+        const answersOwnerHere = !!postedConversationId &&
+            ((d.ownerAskedRecently?.(input.session, postedConversationId) ?? false) ||
+                (trigger.triggerKind === 'owner_message' && trigger.conversationId !== postedConversationId && (d.ownerAskedEarlier?.(input.session, postedConversationId) ?? false)));
         const phrase = triggeredByPhrase(trigger, {
             ...(postedConversationId ? { postedConversationId } : {}),
-            ownerAskedHere: !!postedConversationId && (d.ownerAskedRecently?.(input.session, postedConversationId) ?? false),
+            ownerAskedHere: answersOwnerHere,
             workItem,
             ...(d.conversationPlace ? { conversationPlace: d.conversationPlace } : {}),
         });
@@ -394,6 +443,23 @@ async function provenanceOf(input, postedConversationId, d) {
         return null;
     }
 }
+/**
+ * The trigger of the input a post answers: for a post addressed to a work
+ * item, that work item's dispatch (the session's own trigger when it is that
+ * dispatch), never whatever was delivered to the agent last (R8).
+ *
+ * @param session - Agent
+ * @param d - Collaborators
+ * @param answering - The work item the post names, when it names one
+ * @returns The trigger, or null
+ */
+function triggerOfAnsweredInput(session, d, answering) {
+    const current = d.turnTrigger?.(session) ?? null;
+    const id = answering?.workItemId;
+    if (!id || current?.workItemId === id)
+        return current;
+    return { triggerKind: 'dispatch', workItemId: id, rootKind: 'dispatch', rootRef: id, viaAgents: [], at: Date.now(), ...(current?.traceId ? { traceId: current.traceId } : {}) };
+}
 /**
  * Provenance for a post an agent makes straight into a conversation
  * (`reply-channel`, `POST /chat/channels/:id/messages`), outside
@@ -431,7 +497,8 @@ async function attempt(input, dest, prompt, d) {
     const ticket = dest.source === 'ticket' ? input.reference?.ticket : dest.source === 'prompt' ? prompt?.ticket : undefined;
     const deliversTicket = ticket ? { [REPLY_ROUTING_CONSTANTS.DELIVERS_TICKET_METADATA_KEY]: ticket } : undefined;
     const answeredReference = dest.source === 'prompt' || dest.source === 'ticket' || dest.source === 'decision' || dest.source === 'work-item' || dest.source === 'message';
-    const provenance = await provenanceOf(input, dest.kind === 'conversation' ? dest.conversationId : undefined, d);
+    const answeredWorkItem = dest.source === 'work-item' ? input.reference?.workItemId : dest.source === 'prompt' ? prompt?.workItemId : undefined;
+    const provenance = await provenanceOf(input, dest.kind === 'conversation' ? dest.conversationId : undefined, d, answeredWorkItem ? { workItemId: answeredWorkItem } : undefined);
     const metadata = { ...(deliversTicket ?? {}), ...(provenance?.metadata ?? {}) };
     if (provenance?.content !== undefined)
         input = { ...input, content: provenance.content };
@@ -461,18 +528,27 @@ async function attempt(input, dest, prompt, d) {
             const why = member
                 ? `conversation ${dest.conversationId} (${dest.reason}) could not post it into its Slack thread`
                 : `conversation ${dest.conversationId} (${dest.reason}) did not take it — you are not a member there`;
-            return { ok: false, destination: dest, error: notDelivered(why, retryAdvice(dest, prompt)) };
+            // A work item's place is fixed by the item: resending the same reply lands there again.
+            const advice = dest.source === 'work-item' || dest.source === 'current-work' || dest.source === 'route' ? UNPOSTABLE_ADVICE : retryAdvice(dest, prompt);
+            return { ok: false, destination: dest, error: notDelivered(why, advice) };
         }
         if (answeredReference && input.interim !== true)
             AgentPromptReferenceService.getInstance().clear(input.session);
         return { ok: true, destination: dest, messageId, conversationId: dest.conversationId };
     }
+    if (dest.source === 'agent-message' && dest.destination.kind === 'agent' && d.answerAgent) {
+        const to = dest.destination.sessionName;
+        const taken = await d.answerAgent(input.session, to, input.content).catch(() => false);
+        if (!taken)
+            return { ok: false, destination: dest, error: notDelivered(`${dest.reason}: ${to} could not be reached`, `send-message --to ${to} "<your answer>"`) };
+        return { ok: true, destination: dest, agentSession: to };
+    }
     try {
         const wd = await d.workDestination();
         const posted = await deliverToWorkDestination(input.session, dest.destination, input.content, wd);
         if (!posted) {
             const why = dest.destination.kind === 'agent' ? `${dest.reason}: ${dest.destination.sessionName} could not be reached` : `${dest.reason}: there is no Slack channel to post in`;
-            return { ok: false, destination: dest, error: notDelivered(why, fixCommand(prompt)) };
+            return { ok: false, destination: dest, error: notDelivered(why, UNPOSTABLE_ADVICE) };
         }
         if (answeredReference && input.interim !== true)
             AgentPromptReferenceService.getInstance().clear(input.session);
@@ -486,9 +562,35 @@ async function attempt(input, dest, prompt, d) {
         };
     }
     catch (err) {
-        return { ok: false, destination: dest, error: notDelivered(`posting to Slack failed (${err instanceof Error ? err.message : String(err)})`, fixCommand(prompt)) };
+        return { ok: false, destination: dest, error: notDelivered(`posting to Slack failed (${err instanceof Error ? err.message : String(err)})`, UNPOSTABLE_ADVICE) };
     }
 }
+/**
+ * Whether a chat thread is agent-to-agent coordination kept inside Crewly
+ * (crewly#1340): the message, or the root of its thread, carries
+ * `agentCoordinationInternal`. `reply-channel` keeps a post in such a thread
+ * internal; a file must not go to the Slack thread key stored on that
+ * message either (Pia's v3/v4 videos for Ella landed in Steve's thread,
+ * 2026-10-18).
+ *
+ * @param threadId - A chat message id (anything else is not internal)
+ * @param deps - Collaborators (default: the real ones)
+ * @returns Why the thread is internal, or null
+ */
+export async function internalCoordinationThread(threadId, deps) {
+    if (typeof threadId !== 'string' || !threadId.trim() || parseSlackThreadKey(threadId))
+        return null;
+    const d = deps ?? (await defaultReplyDeliveryDeps());
+    const { AGENT_COORDINATION_CONSTANTS } = await import('../../constants.js');
+    const reasonOf = (id) => {
+        const v = id ? d.resolver.getMessage(id)?.metadata?.[AGENT_COORDINATION_CONSTANTS.INTERNAL_METADATA_KEY] : undefined;
+        return typeof v === 'string' && v ? v : null;
+    };
+    const msg = d.resolver.getMessage(threadId.trim());
+    if (!msg)
+        return null;
+    return reasonOf(msg.id) ?? reasonOf(msg.threadId);
+}
 /**
  * The Slack place (channel + thread) the resolver gives, without posting —
  * for files and the `[DONE]` notice. Ticket threads that do not exist yet
@@ -576,6 +678,38 @@ function logResolution(session, r) {
         reason: d.reason,
     });
 }
+/**
+ * The real {@link ReplyDeliveryDeps.answerAgent}: the answer goes to the
+ * other agent with the replier's sender header (so it can answer back), and
+ * the replier's open ask from that agent counts as answered.
+ *
+ * @param fromSession - Replying agent
+ * @param toSession - Agent whose message it answers
+ * @param text - Answer
+ * @returns True when the message was taken
+ */
+async function defaultAnswerAgent(fromSession, toSession, text) {
+    const [{ getAgentMessenger }, { describeAgentSender, wrapAgentMessage }, { StorageService }, { getAgentAskLedger }] = await Promise.all([
+        import('./work-item-destination.wiring.js'),
+        import('../messaging/agent-message-envelope.js'),
+        import('../core/storage.service.js'),
+        import('../messaging/agent-ask-ledger.service.js'),
+    ]);
+    const messenger = getAgentMessenger();
+    if (!messenger)
+        return false;
+    const sender = (await describeAgentSender(fromSession, (s) => StorageService.getInstance().findMemberBySessionName(s))) ?? { session: fromSession };
+    const taken = await messenger(toSession, wrapAgentMessage(text, sender));
+    if (taken) {
+        try {
+            getAgentAskLedger()?.noteAnswered(fromSession, toSession);
+        }
+        catch {
+            /* best effort */
+        }
+    }
+    return taken;
+}
 /**
  * The real collaborators (lazy imports keep this module light for tests).
  *
@@ -708,6 +842,9 @@ export async function defaultReplyDeliveryDeps() {
             });
         },
         surfacedOwnerConversations: (session) => SubAgentMessageQueue.getInstance().surfacedUnansweredConversations(session),
+        // What the agent answers: the latest input that names it, not a reminder
+        // or notice delivered since (message-routing audit 2026-10-18).
+        latestInput: (session) => latestInputOf(getTurnTriggerTracker().routedTrigger(session)),
         now: () => Date.now(),
     };
     const { deliverAgentReplyToConversation } = await import('../../controllers/chat/chat.controller.js');
@@ -716,6 +853,7 @@ export async function defaultReplyDeliveryDeps() {
         resolver,
         deliverToConversation: deliverAgentReplyToConversation,
         workDestination: defaultWorkDestinationDeps,
+        answerAgent: defaultAnswerAgent,
         priorRoomAnswer: async (input) => {
             const { getSlackTeamChannelService } = await import('../slack/slack-team-channel.service.js');
             return (await getSlackTeamChannelService()?.heldReplyFor(input)) ?? null;
@@ -727,6 +865,8 @@ export async function defaultReplyDeliveryDeps() {
         },
         turnTrigger: (session) => getTurnTriggerTracker().trigger(session),
         ownerAskedRecently: (session, conversationId) => getTurnTriggerTracker().ownerAskedRecently(session, conversationId),
+        ownerAskedEarlier: (session, conversationId) => getTurnTriggerTracker().ownerAskedWithin(session, conversationId, TURN_TRIGGER_CONSTANTS.FRESH_MS),
+        routedTrigger: (session) => getTurnTriggerTracker().routedTrigger(session),
         currentTrace: (session) => getTraceContext().currentTrace(session),
         conversationPlace: (id) => chatConversationPlace(chatLookup, id),
     };
@@ -766,4 +906,20 @@ export function chatConversationPlace(chat, conversationId) {
         return null;
     }
 }
+/**
+ * The route an agent's own messages carry onward: what it is answering now
+ * (its latest routed input; message-route.ts). Never throws.
+ *
+ * @param session - Agent session
+ * @returns The route, or null when its input names none
+ */
+export async function currentRouteOf(session) {
+    try {
+        const { OrcReplyRouteService } = await import('./orc-reply-route.service.js');
+        return routeOfTrigger(getTurnTriggerTracker().routedTrigger(session), OrcReplyRouteService.getInstance().getLastOrigin(session));
+    }
+    catch {
+        return null;
+    }
+}
 //# sourceMappingURL=reply-destination.wiring.js.map