recordProcessed("skipped", { reason: "duplicate" });

return { queuedFinal: false, counts: dispatcher.getQueuedCounts() };

}

let inboundDedupeReplayUnsafe = false;

const markInboundDedupeReplayUnsafe = () => {

inboundDedupeReplayUnsafe = true;

};

const initialSessionStoreEntry = resolveSessionStoreLookup(ctx, cfg);

const boundAcpDispatchSessionKey = resolveBoundAcpDispatchSessionKey({ ctx, cfg });

if (!shouldRouteToOriginating || !routeReplyChannel || !routeReplyTo || !routeReplyRuntime) {

return null;

}

markInboundDedupeReplayUnsafe();

return await routeReplyRuntime.routeReply({

payload,

channel: routeReplyChannel,

}

return result.ok;

}

markInboundDedupeReplayUnsafe();

return mode === "additive"

? dispatcher.sendToolResult(payload)

: dispatcher.sendFinalReply(payload);

);

}

} else {

markInboundDedupeReplayUnsafe();

queuedFinal = dispatcher.sendFinalReply(payload);

}

} else {

const sendFinalPayload = async (

payload: ReplyPayload,

): Promise<{ queuedFinal: boolean; routedFinalCount: number }> => {

if (resolveSendableOutboundReplyParts(payload).hasContent) {

markInboundDedupeReplayUnsafe();

}

const ttsPayload = await maybeApplyTtsToReplyPayload({

payload,

cfg,

routedFinalCount: result.ok ? 1 : 0,

};

}

markInboundDedupeReplayUnsafe();

return {

queuedFinal: dispatcher.sendFinalReply(normalizedPayload),

routedFinalCount: 0,

await sendPayloadAsync(payload, undefined, false);

return;

}

markInboundDedupeReplayUnsafe();

dispatcher.sendToolResult(payload);

};

const sendPlanUpdate = async (payload: {

await sendPayloadAsync(replyPayload, undefined, false);

return;

}

markInboundDedupeReplayUnsafe();

dispatcher.sendToolResult(replyPayload);

};

const summarizeApprovalLabel = (payload: {

suppressTyping: typing.suppressTyping,

onToolResult: (payload: ReplyPayload) => {

const run = async () => {

markInboundDedupeReplayUnsafe();

await onToolResultFromReplyOptions?.(payload);

if (suppressDelivery) {

return;

if (shouldRouteToOriginating) {

await sendPayloadAsync(deliveryPayload, undefined, false);

} else {

markInboundDedupeReplayUnsafe();

dispatcher.sendToolResult(deliveryPayload);

}

};

return run();

},

onPlanUpdate: async (payload) => {

markInboundDedupeReplayUnsafe();

await onPlanUpdateFromReplyOptions?.(payload);

if (payload.phase !== "update" || suppressDefaultToolProgressMessages) {

return;

}

await sendPlanUpdate({ explanation: payload.explanation, steps: payload.steps });

},

onApprovalEvent: async (payload) => {

markInboundDedupeReplayUnsafe();

await onApprovalEventFromReplyOptions?.(payload);

if (payload.phase !== "requested" || suppressDefaultToolProgressMessages) {

return;

await maybeSendWorkingStatus(label);

},

onPatchSummary: async (payload) => {

markInboundDedupeReplayUnsafe();

await onPatchSummaryFromReplyOptions?.(payload);

if (payload.phase !== "end" || suppressDefaultToolProgressMessages) {

return;

},

onBlockReply: (payload: ReplyPayload, context?: BlockReplyContext) => {

const run = async () => {

if (

payload.isReasoning !== true &&

resolveSendableOutboundReplyParts(payload).hasContent

) {

markInboundDedupeReplayUnsafe();

}

if (suppressDelivery) {

return;

}

if (shouldRouteToOriginating) {

await sendPayloadAsync(normalizedPayload, context?.abortSignal, false);

} else {

markInboundDedupeReplayUnsafe();

dispatcher.sendBlockReply(normalizedPayload);

}

};

);

}

} else {

markInboundDedupeReplayUnsafe();

const didQueue = dispatcher.sendFinalReply(normalizedTtsOnlyPayload);

queuedFinal = didQueue || queuedFinal;

}

return { queuedFinal, counts };

} catch (err) {

if (inboundDedupeClaim.status === "claimed") {

releaseInboundDedupe(inboundDedupeClaim.key);

if (inboundDedupeReplayUnsafe) {

commitInboundDedupe(inboundDedupeClaim.key);

} else {

releaseInboundDedupe(inboundDedupeClaim.key);

}

}

recordProcessed("error", { error: String(err) });

markIdle("message_error");