@murphai/murph 1.2.0 → 1.2.4

package/node_modules/@murphai/assistant-engine/dist/assistant/automation/reply.js

@@ -4,7 +4,7 @@ import { conversationRefFromAssistantInputConversation } from '../conversation-r
 import { createHostedDeliveryId } from '../hosted-delivery-id.js';
 import { listAssistantOutboxIntents, } from '../outbox.js';
 import { isAssistantProviderConnectionLostError, isAssistantProviderStalledError, } from '../provider-failure-diagnostics.js';
-import { listAssistantTurnReceipts } from '../receipts.js';
+import { listAssistantTurnReceipts, } from '../receipts.js';
 import { sanitizeAssistantPortableStateString } from '../redaction.js';
 import { errorMessage, normalizeNullableString } from '../shared.js';
 import { sendAssistantMessage } from '../service.js';
@@ -17,7 +17,7 @@ import { AUTO_REPLY_RECEIPT_CROSS_SESSION_CONTEXT_INTENT_ID_KEY, AUTO_REPLY_RECE
 import { describeAssistantAutoReplyFailure, normalizeAssistantSafeFailureContext, } from './failure-observability.js';
 import { collectAssistantAutoReplyGroup, loadAssistantAutoReplyGroupItems, } from './grouping.js';
 import { AUTO_REPLY_PROVIDER_STALLED_DETAIL, createAssistantProviderWatchdog, } from './provider-watchdog.js';
-import { prepareAssistantAutoReplyInput, readTelegramAutoReplyMetadataFromAssistantInput, renderAssistantInputAttachmentDescriptorPromptSection, } from './prompt-builder.js';
+import { prepareAssistantAutoReplyInput, readTelegramAutoReplyMetadataFromAssistantInput, renderAssistantInputAttachmentDescriptorPromptSection, renderAssistantInputGroupContextPrompt, } from './prompt-builder.js';
 import { assistantAutomationInputSummaryFromCandidate, compareAssistantInputSummaryOrder, } from './input-summary.js';
 import { computeAssistantAutomationRetryAt, earliestAssistantAutomationWakeAt, } from './shared.js';
 import { buildAssistantAutomationTurnEnvelope } from './turn-envelope.js';
@@ -30,10 +30,28 @@ const ASSISTANT_PROVIDER_EMPTY_RESPONSE_CODE = 'ASSISTANT_PROVIDER_EMPTY_RESPONS
 const ASSISTANT_EMPTY_RESPONSE_SUPPRESSION_REASON = 'assistant provider completed without a reply';
 const ASSISTANT_PROVIDER_USAGE_LIMIT_SUPPRESSION_REASON = 'assistant provider usage limit reached; auto-reply suppressed until usage is restored.';
 const ASSISTANT_NO_REPLY_SUPPRESSION_REASON = 'assistant finished without a reply';
+function mergeAssistantTerminalLinqCleanupMessageIds(lists) {
+    const messageIds = new Set();
+    for (const list of lists) {
+        for (const messageId of list ?? []) {
+            messageIds.add(messageId);
+        }
+    }
+    return messageIds.size > 0 ? [...messageIds] : null;
+}
 export function applyAssistantAutoReplyProcessResult(input) {
     if (input.result.checkpointRequired) {
         input.summary.checkpointRequired = true;
     }
+    if (input.result.terminalLinqCleanup) {
+        const merged = mergeAssistantTerminalLinqCleanupMessageIds([
+            input.summary.terminalLinqCleanup,
+            input.result.terminalLinqCleanup,
+        ]);
+        if (merged) {
+            input.summary.terminalLinqCleanup = merged;
+        }
+    }
     input.summary.failed += input.result.failed;
     input.summary.nextWakeAt = earliestAssistantAutomationWakeAt(input.summary.nextWakeAt, input.result.nextWakeAt);
     input.summary.replied += input.result.replied;
@@ -62,13 +80,27 @@ export function createAssistantAutoReplyGroupContext(items) {
     };
 }
 export async function processAssistantAutoReplyGroup(input) {
+    const historyReader = input.historyReader ?? createAssistantAutoReplyHistoryReader({
+        vault: input.vault,
+    });
     let latestContext = input.context;
+    let observedTerminalLinqCleanup = null;
+    const withObservedTerminalLinqCleanup = (outcome) => ({
+        ...outcome,
+        ...(observedTerminalLinqCleanup && !outcome.terminalLinqCleanup
+            ? { terminalLinqCleanup: observedTerminalLinqCleanup }
+            : {}),
+    });
     try {
         const resolved = await resolveAssistantAutoReplyGroupOutcome({
             ...input,
+            historyReader,
             onAcceptedContext(context) {
                 latestContext = context;
             },
+            onTerminalLinqCleanup(messageIds) {
+                observedTerminalLinqCleanup = messageIds;
+            },
         });
         return commitAssistantAutoReplyGroupOutcome({
             context: resolved.context,
@@ -94,22 +126,22 @@ export async function processAssistantAutoReplyGroup(input) {
             return commitAssistantAutoReplyGroupOutcome({
                 context: latestContext,
                 onEvent: input.onEvent,
-                outcome: createDeferredGroupOutcome({
+                outcome: withObservedTerminalLinqCleanup(createDeferredGroupOutcome({
                     inputCount: latestContext.inputCount,
                     nextWakeAt: computeAssistantAutomationRetryAt(ASSISTANT_AUTO_REPLY_DEFERRED_RETRY_DELAY_MS),
                     reason,
                     stopScanning: true,
-                }),
+                })),
                 vault: input.vault,
             });
         }
         return commitAssistantAutoReplyGroupOutcome({
             context: latestContext,
             onEvent: input.onEvent,
-            outcome: classifyAssistantAutoReplyFailure({
+            outcome: withObservedTerminalLinqCleanup(classifyAssistantAutoReplyFailure({
                 inputCount: latestContext.inputCount,
                 error,
-            }),
+            })),
             vault: input.vault,
         });
     }
@@ -122,7 +154,7 @@ async function resolveAssistantAutoReplyGroupOutcome(input) {
         executionContext: input.executionContext,
         group: context,
         onEvent: input.onEvent,
-        receiptReader: input.receiptReader,
+        historyReader: input.historyReader,
         receiptFallbackEnabled: shouldUseAssistantAutoReplyReceiptFallback({
             deliveryDispatchMode: input.deliveryDispatchMode,
             executionContext: input.executionContext,
@@ -141,17 +173,43 @@ async function resolveAssistantAutoReplyGroupOutcome(input) {
         };
     }
     if (decision.kind === 'skip') {
+        const advanceInputIds = decision.advanceInputIds;
+        const skipContext = advanceInputIds
+            ? selectAssistantAutoReplyContextByInputIds({
+                context,
+                inputIds: advanceInputIds,
+            })
+            : context;
+        if (!skipContext ||
+            (advanceInputIds &&
+                (skipContext.inputIds.length !== advanceInputIds.length ||
+                    skipContext.inputIds.some((inputId, index) => inputId !== advanceInputIds[index]) ||
+                    advanceInputIds.some((inputId, index) => inputId !== context.inputIds[index])))) {
+            return {
+                context,
+                deferredTerminalSuppressionEvidence: [],
+                outcome: createDeferredGroupOutcome({
+                    inputCount: context.inputCount,
+                    reason: 'assistant reply terminal evidence prefix no longer matches pending input; will retry safely.',
+                    stopScanning: true,
+                }),
+                terminalSuppressedInputIds: [],
+            };
+        }
         return {
-            context,
+            context: skipContext,
             deferredTerminalSuppressionEvidence: [],
             outcome: createSkippedDecisionOutcome({
-                inputCount: context.inputCount,
-                decision,
+                inputCount: skipContext.inputCount,
+                decision: advanceInputIds && advanceInputIds.length < context.inputIds.length
+                    ? { ...decision, stopScanning: true }
+                    : decision,
             }),
             terminalSuppressedInputIds: [],
         };
     }
     let acceptedContext = context;
+    let terminalLinqCleanup = null;
     const deferredTerminalSuppressionEvidence = [];
     const terminalSuppressedInputIds = new Set();
     input.onEvent?.({
@@ -159,8 +217,20 @@ async function resolveAssistantAutoReplyGroupOutcome(input) {
         inputId: primaryAutoReplyInputId(context),
         details: 'assistant provider turn started',
     });
+    const assistantStyleSettingsAuthorized = decision.primaryInput.source === 'email'
+        ? context.items.every((item) => item.summary.source === 'email' &&
+            item.inputCandidate?.event.sourceMetadata?.kind === 'email' &&
+            item.inputCandidate.event.sourceMetadata
+                .assistantStyleSettingsAuthorized === true)
+        : context.items.some((item) => item.inputCandidate?.event.sourceRef.kind === 'hosted-mailbox' &&
+            item.inputCandidate.event.sourceRef.causalSeq == null)
+            ? false
+            : undefined;
     const activeTurnHooks = input.inputSource
         ? createAssistantAutoReplyActiveTurnInputHooks({
+            ...(assistantStyleSettingsAuthorized === undefined
+                ? {}
+                : { assistantStyleSettingsAuthorized }),
             context,
             deliveryTarget: decision.deliveryTarget,
             executionContext: input.executionContext,
@@ -180,14 +250,21 @@ async function resolveAssistantAutoReplyGroupOutcome(input) {
         executionContext: input.executionContext,
     });
     const result = await executeAssistantAutoReply({
+        ...(assistantStyleSettingsAuthorized === undefined
+            ? {}
+            : { assistantStyleSettingsAuthorized }),
         acceptedTurnInputInitialInputs: buildAutoReplyAcceptedTurnInputItems({
             inputSummaries: context.items.map((item) => item.summary),
             inputCandidates: context.items.map((item) => item.inputCandidate ?? null),
         }),
         bindingDeliveryTarget: decision.deliveryTarget,
+        ...(input.beforeProviderAcceptedInputs
+            ? { beforeProviderAcceptedInputs: input.beforeProviderAcceptedInputs }
+            : {}),
         captureIds: context.optionalInboxCaptureIds,
         inputIds: context.inputIds,
         deliveryDispatchMode: input.deliveryDispatchMode,
+        answeredMailboxItemIds: hostedDelivery.answeredMailboxItemIds,
         deliveryIdempotencyKey: hostedDelivery.deliveryIdempotencyKey,
         hostedDeliveryIdempotency: hostedDelivery.hostedDeliveryIdempotency,
         deliveryTarget: decision.deliveryTarget,
@@ -204,7 +281,13 @@ async function resolveAssistantAutoReplyGroupOutcome(input) {
         signal: input.signal,
         maxSessionAgeMs: input.sessionMaxAgeMs,
         onEvent: input.onEvent,
-        onProviderRequestStarted: input.onProviderRequestStarted ?? null,
+        onProviderEvent: input.onProviderEvent ?? null,
+        onProviderRequestStarted: input.onProviderRequestStarted
+            ? (event) => input.onProviderRequestStarted?.({
+                ...event,
+                autoReplyHistory: input.historyReader.readMetrics(),
+            })
+            : null,
         onTraceEvent: input.onTraceEvent,
         onFinishWithoutReplyAccepted: async (event) => {
             const acceptedInputIds = [...new Set(event.acceptedInputIds)];
@@ -227,10 +310,18 @@ async function resolveAssistantAutoReplyGroupOutcome(input) {
                 deferredTerminalSuppressionEvidence.push(evidenceDraft);
             }
             else {
-                await writeAssistantAutoReplySuppressionEvidence({
-                    ...evidenceDraft,
-                    vault: input.vault,
-                });
+                terminalLinqCleanup = mergeAssistantTerminalLinqCleanupMessageIds([
+                    terminalLinqCleanup,
+                    await writeAssistantAutoReplySuppressionEvidence({
+                        ...evidenceDraft,
+                        vault: input.vault,
+                    }),
+                ]);
+                if (terminalLinqCleanup) {
+                    // Keep the caller's observer current so a provider failure after
+                    // this hook cannot drop already-written cleanup obligations.
+                    input.onTerminalLinqCleanup?.(terminalLinqCleanup);
+                }
             }
             for (const inputId of acceptedInputIds) {
                 terminalSuppressedInputIds.add(inputId);
@@ -253,11 +344,14 @@ async function resolveAssistantAutoReplyGroupOutcome(input) {
         return {
             context: acceptedContext,
             deferredTerminalSuppressionEvidence,
-            outcome: createSkippedGroupOutcome({
-                inputCount: acceptedContext.inputCount,
-                reason: ASSISTANT_NO_REPLY_SUPPRESSION_REASON,
-                terminalSuppression: true,
-            }),
+            outcome: {
+                ...createSkippedGroupOutcome({
+                    inputCount: acceptedContext.inputCount,
+                    reason: ASSISTANT_NO_REPLY_SUPPRESSION_REASON,
+                    terminalSuppression: true,
+                }),
+                ...(terminalLinqCleanup ? { terminalLinqCleanup } : {}),
+            },
             terminalSuppressedInputIds: [...terminalSuppressedInputIds],
         };
     }
@@ -266,33 +360,45 @@ async function resolveAssistantAutoReplyGroupOutcome(input) {
         return {
             context: acceptedContext,
             deferredTerminalSuppressionEvidence,
-            outcome: createDeferredDeliveryGroupOutcome(result),
+            outcome: {
+                ...createDeferredDeliveryGroupOutcome(result),
+                ...(terminalLinqCleanup ? { terminalLinqCleanup } : {}),
+            },
             terminalSuppressedInputIds: [...terminalSuppressedInputIds],
         };
     }
     return {
         context: acceptedContext,
         deferredTerminalSuppressionEvidence,
-        outcome: createSuccessfulReplyGroupOutcome(result),
+        outcome: {
+            ...createSuccessfulReplyGroupOutcome(result),
+            ...(terminalLinqCleanup ? { terminalLinqCleanup } : {}),
+        },
         terminalSuppressedInputIds: [...terminalSuppressedInputIds],
     };
 }
 async function commitAssistantAutoReplyGroupOutcome(input) {
     const artifactResult = await writeAssistantAutoReplyOutcomeArtifacts(input).catch((error) => {
         if (input.outcome.artifact.kind === 'error') {
-            return { checkpointRequired: false };
+            return { checkpointRequired: false, terminalLinqCleanup: null };
         }
         throw error;
     });
-    const deferredSuppressionCheckpointRequired = await writeDeferredAssistantAutoReplySuppressionEvidence(input);
+    const deferredSuppression = await writeDeferredAssistantAutoReplySuppressionEvidence(input);
     emitAssistantAutoReplyOutcomeEvent(input);
+    const terminalLinqCleanup = mergeAssistantTerminalLinqCleanupMessageIds([
+        input.outcome.terminalLinqCleanup,
+        artifactResult.terminalLinqCleanup,
+        deferredSuppression.terminalLinqCleanup,
+    ]);
     return {
         advanceCursor: input.outcome.advanceCursor,
         ...(input.outcome.checkpointRequired ||
             artifactResult.checkpointRequired ||
-            deferredSuppressionCheckpointRequired
+            deferredSuppression.checkpointRequired
             ? { checkpointRequired: true }
             : {}),
+        ...(terminalLinqCleanup ? { terminalLinqCleanup } : {}),
         currentTurnDeliveryIntentIds: collectAssistantAutoReplyOutcomeDeliveryIntentIds(input.outcome),
         failed: input.outcome.summary.failed,
         lastInputCursor: input.context.lastInputCursor,
@@ -307,15 +413,19 @@ async function writeDeferredAssistantAutoReplySuppressionEvidence(input) {
     if (evidence.length === 0 ||
         (input.outcome.artifact.kind !== 'result' &&
             input.outcome.artifact.kind !== 'deferred')) {
-        return false;
+        return { checkpointRequired: false, terminalLinqCleanup: null };
     }
+    let terminalLinqCleanup = null;
     for (const draft of evidence) {
-        await writeAssistantAutoReplySuppressionEvidence({
-            ...draft,
-            vault: input.vault,
-        });
+        terminalLinqCleanup = mergeAssistantTerminalLinqCleanupMessageIds([
+            terminalLinqCleanup,
+            await writeAssistantAutoReplySuppressionEvidence({
+                ...draft,
+                vault: input.vault,
+            }),
+        ]);
     }
-    return true;
+    return { checkpointRequired: true, terminalLinqCleanup };
 }
 function collectAssistantAutoReplyOutcomeDeliveryIntentIds(outcome) {
     const result = outcome.artifact.kind === 'result' || outcome.artifact.kind === 'deferred'
@@ -330,14 +440,14 @@ async function writeAssistantAutoReplyOutcomeArtifacts(input) {
     switch (input.outcome.artifact.kind) {
         case 'none':
             if (input.outcome.kind === 'skipped' && input.outcome.terminalSuppression) {
-                await writeAssistantAutoReplySuppressionEvidence({
+                const terminalLinqCleanup = await writeAssistantAutoReplySuppressionEvidence({
                     captureIds: input.context.optionalInboxCaptureIds,
                     inputIds: input.context.inputIds,
                     linqMessageIds: resolveAutoReplyLinqProviderMessageIdsFromContext(input.context),
                     reason: sanitizeAssistantAutoReplySuppressionReason(input.outcome.event?.details),
                     vault: input.vault,
                 });
-                return { checkpointRequired: true };
+                return { checkpointRequired: true, terminalLinqCleanup };
             }
             return { checkpointRequired: false };
         case 'result': {
@@ -352,7 +462,7 @@ async function writeAssistantAutoReplyOutcomeArtifacts(input) {
             if (!evidenceContext) {
                 return { checkpointRequired: false };
             }
-            await writeAssistantAutoReplyReplyIntentEvidence({
+            const terminalLinqCleanup = await writeAssistantAutoReplyReplyIntentEvidence({
                 captureIds: evidenceContext.optionalInboxCaptureIds,
                 inputIds: evidenceContext.inputIds,
                 linqMessageIds: resolveAutoReplyLinqProviderMessageIdsFromContext(evidenceContext),
@@ -361,7 +471,7 @@ async function writeAssistantAutoReplyOutcomeArtifacts(input) {
                 result: input.outcome.artifact.result,
                 vault: input.vault,
             });
-            return { checkpointRequired: true };
+            return { checkpointRequired: true, terminalLinqCleanup };
         }
         case 'deferred': {
             const queuedAt = new Date().toISOString();
@@ -372,7 +482,7 @@ async function writeAssistantAutoReplyOutcomeArtifacts(input) {
             if (!evidenceContext) {
                 return { checkpointRequired: false };
             }
-            await writeAssistantAutoReplyReplyIntentEvidence({
+            const terminalLinqCleanup = await writeAssistantAutoReplyReplyIntentEvidence({
                 captureIds: evidenceContext.optionalInboxCaptureIds,
                 inputIds: evidenceContext.inputIds,
                 linqMessageIds: resolveAutoReplyLinqProviderMessageIdsFromContext(evidenceContext),
@@ -381,7 +491,7 @@ async function writeAssistantAutoReplyOutcomeArtifacts(input) {
                 result: input.outcome.artifact.result,
                 vault: input.vault,
             });
-            return { checkpointRequired: true };
+            return { checkpointRequired: true, terminalLinqCleanup };
         }
         case 'error':
             await writeAssistantChatErrorArtifacts({
@@ -439,6 +549,9 @@ function createSkippedDecisionOutcome(input) {
         return {
             ...outcome,
             ...(input.decision.checkpointRequired ? { checkpointRequired: true } : {}),
+            ...(input.decision.terminalLinqCleanup
+                ? { terminalLinqCleanup: input.decision.terminalLinqCleanup }
+                : {}),
         };
     }
     return createDeferredGroupOutcome({
@@ -571,36 +684,64 @@ async function evaluateAssistantAutoReplyGroup(input) {
     if (input.group.firstItem.summary.actorIsSelf && !input.allowSelfAuthored) {
         return createAdvancingSkipDecision('input is self-authored');
     }
-    const existingTerminalEvidence = await Promise.all(input.group.items.map((item) => {
+    const existingTerminalEvidenceEntries = (await Promise.all(input.group.items.map(async (item) => {
         const inputId = item.inputCandidate.event.inputId;
-        return readAssistantAutoReplyTerminalEvidenceByEvidenceId(input.vault, inputId).then((evidence) => evidence ??
-            readAssistantAutoReplyTerminalEvidenceByEvidenceId(input.vault, item.summary.optionalInboxCaptureId ?? inputId));
-    }));
-    const repairEvidence = input.group.optionalInboxCaptureIds.length === input.group.items.length
-        ? findRepairableTerminalEvidenceForGroup(input.group.optionalInboxCaptureIds, existingTerminalEvidence)
-        : null;
-    if (repairEvidence) {
-        const repairCaptureIds = resolveTerminalEvidenceRepairCaptureIds({
-            captureIds: input.group.optionalInboxCaptureIds,
-            evidence: repairEvidence,
-        });
-        if (!(await terminalEvidenceExistsForEveryCapture(input.vault, repairCaptureIds))) {
-            await backfillAssistantAutoReplyTerminalEvidenceFromTerminalEvidence({
-                captureIds: repairCaptureIds,
-                evidence: repairEvidence,
-                vault: input.vault,
-            });
-            return createAdvancingSkipDecision('assistant reply already handled', {
-                checkpointRequired: true,
-                terminalSuppression: false,
+        const inputEvidence = await readAssistantAutoReplyTerminalEvidenceByEvidenceId(input.vault, inputId);
+        const fallbackEvidenceId = item.summary.optionalInboxCaptureId;
+        const fallbackEvidence = fallbackEvidenceId && fallbackEvidenceId !== inputId
+            ? await readAssistantAutoReplyTerminalEvidenceByEvidenceId(input.vault, fallbackEvidenceId)
+            : null;
+        return [
+            {
+                evidence: inputEvidence,
+                evidenceId: inputEvidence ? inputId : null,
+                lookup: inputEvidence ? 'input' : null,
+                ownerInputId: inputId,
+            },
+            ...(fallbackEvidenceId && fallbackEvidenceId !== inputId
+                ? [{
+                        evidence: fallbackEvidence,
+                        evidenceId: fallbackEvidence ? fallbackEvidenceId : null,
+                        lookup: fallbackEvidence ? 'capture' : null,
+                        ownerInputId: inputId,
+                    }]
+                : []),
+        ];
+    }))).flat();
+    const existingTerminalEvidence = existingTerminalEvidenceEntries.map((entry) => entry.evidence);
+    const terminalRepair = findRepairableTerminalEvidencePartitionsForGroup({
+        entries: existingTerminalEvidenceEntries,
+        group: input.group,
+    });
+    if (terminalRepair) {
+        let checkpointRequired = false;
+        let terminalLinqCleanup = null;
+        for (const repairPartition of terminalRepair.partitions) {
+            const repairEvidence = repairPartition.evidence;
+            const repairInputIds = [...repairPartition.inputIds];
+            const repairCaptureIds = resolveTerminalEvidenceRepairCaptureIds({
+                group: input.group,
+                inputIds: repairInputIds,
             });
+            if (await terminalEvidenceExistsForEveryId(input.vault, repairInputIds)) {
+                continue;
+            }
+            terminalLinqCleanup = mergeAssistantTerminalLinqCleanupMessageIds([
+                terminalLinqCleanup,
+                await backfillAssistantAutoReplyTerminalEvidenceFromTerminalEvidence({
+                    captureIds: repairCaptureIds,
+                    evidence: repairEvidence,
+                    inputIds: repairInputIds,
+                    vault: input.vault,
+                }),
+            ]);
+            checkpointRequired = true;
         }
         return createAdvancingSkipDecision('assistant reply already handled', {
-            terminalSuppression: false,
-        });
-    }
-    if (existingTerminalEvidence.every((evidence) => evidence !== null)) {
-        return createAdvancingSkipDecision('assistant reply already handled', {
+            advanceInputIds: terminalRepair.inputIds,
+            ...(checkpointRequired ? { checkpointRequired: true } : {}),
+            stopScanning: terminalRepair.inputIds.length < input.group.inputIds.length,
+            terminalLinqCleanup,
             terminalSuppression: false,
         });
     }
@@ -615,15 +756,15 @@ async function evaluateAssistantAutoReplyGroup(input) {
         return { kind: 'ignore' };
     }
     const primaryReplyInput = createAssistantAutoReplyPrimaryInput(primaryInput);
-    const receipts = await readAssistantAutoReplyReceiptRecords(input);
     if (input.receiptFallbackEnabled) {
+        const receipts = await input.historyReader.readReceipts();
         const handledReceipt = findHandledAutoReplyReceiptForGroup({
             captureIds: input.group.optionalInboxCaptureIds,
             inputIds: input.group.inputIds,
             receipts,
         });
         if (handledReceipt) {
-            await backfillAssistantAutoReplyTerminalEvidenceFromTerminalSnapshot({
+            const terminalLinqCleanup = await backfillAssistantAutoReplyTerminalEvidenceFromTerminalSnapshot({
                 captureIds: input.group.optionalInboxCaptureIds,
                 context: input.group,
                 snapshot: handledReceipt,
@@ -631,6 +772,7 @@ async function evaluateAssistantAutoReplyGroup(input) {
             });
             return createAdvancingSkipDecision('assistant reply already handled', {
                 checkpointRequired: true,
+                terminalLinqCleanup,
                 terminalSuppression: false,
             });
         }
@@ -639,6 +781,7 @@ async function evaluateAssistantAutoReplyGroup(input) {
     const autoReplySkipReason = channelAdapter?.canAutoReply({
         externalThreadRouteAuthorityPresent: primaryReplyInput.sourceMetadata?.kind === 'linq' &&
             primaryReplyInput.sourceMetadata.externalThreadRouteAuthorityPresent === true,
+        replyTargetThreadId: primaryReplyInput.replyTarget?.threadId ?? null,
         source: primaryReplyInput.source,
         threadIsDirect: primaryReplyInput.conversation.threadIsDirect,
     }) ?? null;
@@ -667,15 +810,16 @@ async function evaluateAssistantAutoReplyGroup(input) {
     if (input.group.firstItem.summary.actorIsSelf &&
         await isRecentSelfAuthoredAssistantEcho({
             deliveryTarget: conversationDeliveryTarget,
+            historyReader: input.historyReader,
             input: primaryReplyInput,
             session: existingSession,
             vault: input.vault,
         })) {
         return createAdvancingSkipDecision('capture matches a recent assistant delivery');
     }
-    const latestCrossSessionDelivery = await resolveAssistantAutoReplyLatestCrossSessionDelivery({
-        consumedIntentIds: readAssistantAutoReplyConsumedCrossSessionIntentIds(receipts),
+    const outboxContext = await resolveAssistantAutoReplyLatestCrossSessionDelivery({
         deliveryTarget: conversationDeliveryTarget,
+        historyReader: input.historyReader,
         input: primaryReplyInput,
         // Newest grouped input with a native reply. The selector treats it as
         // an authoritative provider-side identification, so it bypasses the
@@ -683,8 +827,14 @@ async function evaluateAssistantAutoReplyGroup(input) {
         // "latest" fallback.
         replyToMessageId: readPromptInputsCrossSessionReplyToMessageId(promptInputs),
         session: existingSession,
-        vault: input.vault,
     });
+    const affirmativeReaction = primaryReplyInput.sourceMetadata?.kind === 'linq' &&
+        primaryReplyInput.sourceMetadata.affirmativeReaction === true;
+    if (affirmativeReaction &&
+        outboxContext.replyTargetDelivery === null) {
+        return createAdvancingSkipDecision('affirmative Linq reaction target is not an attested assistant delivery');
+    }
+    const latestCrossSessionDelivery = outboxContext.delivery;
     if (input.executionContext?.hosted &&
         primaryReplyInput.source === 'telegram' &&
         deliveryTarget === null &&
@@ -709,7 +859,9 @@ async function evaluateAssistantAutoReplyGroup(input) {
         operatorAuthority: 'direct-operator',
         primaryInput: primaryReplyInput,
         prompt: preparedInput.prompt,
-        turnContext: buildAssistantAutoReplyCrossSessionTurnContext(latestCrossSessionDelivery?.message ?? null),
+        turnContext: affirmativeReaction
+            ? buildAssistantAutoReplyAffirmativeReactionTurnContext(outboxContext.replyTargetDelivery?.message ?? null)
+            : buildAssistantAutoReplyCrossSessionTurnContext(latestCrossSessionDelivery?.message ?? null),
         userMessageContent: preparedInput.userMessageContent,
     };
 }
@@ -728,6 +880,12 @@ function createAssistantAutoReplyPromptInputFromEvent(item) {
         attachmentDescriptors: event.attachmentDescriptors,
         attachmentEvidence: event.attachmentEvidence,
         conversation,
+        ...(event.groupParticipantAdded === true
+            ? { groupParticipantAdded: event.groupParticipantAdded }
+            : {}),
+        ...(event.groupReactionContext
+            ? { groupReactionContext: event.groupReactionContext }
+            : {}),
         inputId: event.inputId,
         occurredAt: event.occurredAt,
         projection: {
@@ -783,6 +941,7 @@ function createHostedAutoReplyDeliveryIdempotency(input) {
     const userId = normalizeNullableString(input.executionContext?.hosted?.memberId);
     if (!userId) {
         return {
+            answeredMailboxItemIds: [],
             deliveryIdempotencyKey: null,
             hostedDeliveryIdempotency: null,
         };
@@ -790,28 +949,38 @@ function createHostedAutoReplyDeliveryIdempotency(input) {
     const candidates = autoReplyInputCandidatesFromContext(input.context);
     if (candidates.length === 0) {
         return {
+            answeredMailboxItemIds: [],
             deliveryIdempotencyKey: null,
             hostedDeliveryIdempotency: null,
         };
     }
-    const deliveryKeyMailboxItemIds = [];
     const hostedMailboxItemIds = [];
+    let effectAnchorMailboxItemId = null;
     for (const candidate of candidates) {
         if (candidate.event.sourceRef.kind !== 'hosted-mailbox') {
             return {
+                answeredMailboxItemIds: [],
                 deliveryIdempotencyKey: null,
                 hostedDeliveryIdempotency: null,
             };
         }
-        deliveryKeyMailboxItemIds.push(candidate.event.sourceRef.itemId);
+        effectAnchorMailboxItemId = candidate.event.sourceRef.itemId;
         const hostedMailboxItemId = normalizeNullableString(candidate.event.hostedMailboxItemId ?? null);
         if (hostedMailboxItemId) {
             hostedMailboxItemIds.push(hostedMailboxItemId);
         }
     }
+    if (!effectAnchorMailboxItemId) {
+        return {
+            answeredMailboxItemIds: [],
+            deliveryIdempotencyKey: null,
+            hostedDeliveryIdempotency: null,
+        };
+    }
     const channel = normalizeNullableString(input.context.firstItem.summary.source);
     if (!channel) {
         return {
+            answeredMailboxItemIds: [],
             deliveryIdempotencyKey: null,
             hostedDeliveryIdempotency: null,
         };
@@ -840,11 +1009,14 @@ function createHostedAutoReplyDeliveryIdempotency(input) {
         }
         : null;
     return {
+        answeredMailboxItemIds: hostedMailboxItemIds,
         deliveryIdempotencyKey: createHostedDeliveryId({
             assistantTurnOrdinal,
             channel,
             conversationId,
-            inboundMailboxItemIds: deliveryKeyMailboxItemIds,
+            // The full mailbox set records what this reply answered. The newest item
+            // is the stable effect anchor when replay batches messages differently.
+            inboundMailboxItemIds: [effectAnchorMailboxItemId],
             recipientKey,
             userId,
         }),
@@ -878,6 +1050,11 @@ async function executeAssistantAutoReply(input) {
         const result = await sendAssistantMessage({
             vault: input.vault,
             ...automationTurn,
+            ...(input.assistantStyleSettingsAuthorized === undefined
+                ? {}
+                : {
+                    assistantStyleSettingsAuthorized: input.assistantStyleSettingsAuthorized,
+                }),
             acceptedTurnInput: {
                 initialInputs: input.acceptedTurnInputInitialInputs ?? null,
             },
@@ -885,6 +1062,9 @@ async function executeAssistantAutoReply(input) {
             conversation,
             activeTurnCheckpoint: input.activeTurnCheckpoint,
             activeTurnInput: input.activeTurnInput,
+            ...(input.beforeProviderAcceptedInputs
+                ? { beforeProviderAcceptedInputs: input.beforeProviderAcceptedInputs }
+                : {}),
             operatorAuthority: input.operatorAuthority,
             persistUserPromptOnFailure: false,
             prompt: input.prompt,
@@ -896,6 +1076,7 @@ async function executeAssistantAutoReply(input) {
             deliverResponse: true,
             onFinishWithoutReplyAccepted: input.onFinishWithoutReplyAccepted ?? null,
             bindingDeliveryTarget: input.bindingDeliveryTarget,
+            answeredMailboxItemIds: input.answeredMailboxItemIds,
             deliveryIdempotencyKey: input.deliveryIdempotencyKey,
             hostedDeliveryIdempotency: input.hostedDeliveryIdempotency,
             ...(input.deliveryMessageReactionsAvailable === undefined
@@ -916,11 +1097,32 @@ async function executeAssistantAutoReply(input) {
                     }),
             },
             maxSessionAgeMs: input.maxSessionAgeMs,
-            onProviderEvent: watchdog.onProviderEvent,
+            onProviderEvent: (event) => {
+                watchdog.onProviderEvent(event);
+                input.onProviderEvent?.(event);
+            },
             onProviderRequestStarted: input.onProviderRequestStarted
                 ? (event) => input.onProviderRequestStarted?.({
                     ...(event.admissionMs === undefined ? {} : { admissionMs: event.admissionMs }),
                     assistantInputIds: event.acceptedInputIds,
+                    ...(event.codexAppServerInitializeMs === undefined
+                        ? {}
+                        : { codexAppServerInitializeMs: event.codexAppServerInitializeMs }),
+                    ...(event.codexAppServerPreProviderMs === undefined
+                        ? {}
+                        : { codexAppServerPreProviderMs: event.codexAppServerPreProviderMs }),
+                    ...(event.codexAppServerSpawnReadyMs === undefined
+                        ? {}
+                        : { codexAppServerSpawnReadyMs: event.codexAppServerSpawnReadyMs }),
+                    ...(event.codexAppServerWarmReuseMs === undefined
+                        ? {}
+                        : { codexAppServerWarmReuseMs: event.codexAppServerWarmReuseMs }),
+                    ...(event.codexAppServerThreadResumeMs === undefined
+                        ? {}
+                        : { codexAppServerThreadResumeMs: event.codexAppServerThreadResumeMs }),
+                    ...(event.codexAppServerThreadStartMs === undefined
+                        ? {}
+                        : { codexAppServerThreadStartMs: event.codexAppServerThreadStartMs }),
                     ...(event.preProviderSetupMs === undefined
                         ? {}
                         : { preProviderSetupMs: event.preProviderSetupMs }),
@@ -960,11 +1162,15 @@ function createAssistantAutoReplyActiveTurnInputHooks(input) {
     let conversation = readAutoReplyConversationRef(context);
     const pendingAcceptances = [];
     const admit = async (admissionInput) => {
-        const refreshResult = await input.inputSource.refresh({
-            signal: admissionInput.signal,
-        });
-        if (refreshResult.reason === 'source_unavailable') {
-            throw new AssistantActiveTurnInputUnavailableError('same-conversation input source is temporarily unavailable during the active turn; will retry later.');
+        const availableInputIds = admissionInput.availableInputIds ?? [];
+        if (availableInputIds.length === 0 ||
+            !input.inputSource.listInputCandidatesByIds) {
+            const refreshResult = await input.inputSource.refresh({
+                signal: admissionInput.signal,
+            });
+            if (refreshResult.reason === 'source_unavailable') {
+                throw new AssistantActiveTurnInputUnavailableError('same-conversation input source is temporarily unavailable during the active turn; will retry later.');
+            }
         }
         const knownProjectionCaptureIds = [
             ...context.optionalInboxCaptureIds,
@@ -977,9 +1183,10 @@ function createAssistantAutoReplyActiveTurnInputHooks(input) {
             ...(admissionInput.knownInputIds ?? []),
         ];
         const lateInputs = await listAutoReplyActiveTurnInputs({
-            afterCursor: context.lastInputCursor,
+            afterCursor: pendingAcceptances.at(-1)?.lastInputCursor ?? context.lastInputCursor,
             conversation,
             context,
+            inputIds: availableInputIds,
             inputSource: input.inputSource,
             knownProjectionCaptureIds,
             knownInputIds,
@@ -990,6 +1197,13 @@ function createAssistantAutoReplyActiveTurnInputHooks(input) {
                 kind: 'no-new-input',
             };
         }
+        if (input.assistantStyleSettingsAuthorized === true &&
+            lateInputs.inputs.some((candidate) => candidate.event.sourceMetadata?.kind !== 'email' ||
+                candidate.event.sourceMetadata.assistantStyleSettingsAuthorized !== true)) {
+            return {
+                kind: 'no-new-input',
+            };
+        }
         // Cross-session turn context is resolved once before the active-turn
         // hooks install. A late native reply (provider replyToMessageId) anchors
         // to a specific prior message that may differ from the current turn's
@@ -1135,6 +1349,7 @@ function createAssistantAutoReplyActiveTurnInputHooks(input) {
             acceptedInputs,
             deliveryIdempotencyKey: hostedDelivery.deliveryIdempotencyKey,
             hostedDeliveryIdempotency: hostedDelivery.hostedDeliveryIdempotency,
+            answeredMailboxItemIds: hostedDelivery.answeredMailboxItemIds,
             ...(acceptedInputDeliveryTarget !== null
                 ? { deliveryTarget: acceptedInputDeliveryTarget }
                 : {}),
@@ -1172,6 +1387,29 @@ function createAssistantAutoReplyActiveTurnInputHooks(input) {
     };
 }
 async function listAutoReplyActiveTurnInputs(input) {
+    const expectedChannel = normalizeNullableString(input.context.firstItem.summary.source);
+    const deliveryTarget = readAutoReplyDeliveryTarget(input.context);
+    if (input.inputIds.length > 0 &&
+        input.inputSource.listInputCandidatesByIds &&
+        expectedChannel &&
+        deliveryTarget) {
+        const exact = await input.inputSource.listInputCandidatesByIds({
+            afterCursor: input.afterCursor,
+            inputIds: input.inputIds,
+            knownInputIds: input.knownInputIds,
+            limit: 100,
+            signal: input.signal,
+            sourceId: expectedChannel,
+        });
+        return selectAutoReplyRouteInput({
+            afterCursor: input.afterCursor,
+            candidates: exact.inputs,
+            conversation: input.conversation,
+            deliveryTarget,
+            expectedChannel,
+            knownProjectionCaptureIds: input.knownProjectionCaptureIds,
+        });
+    }
     const strict = await input.inputSource.listNewConversationInputs({
         afterCursor: input.afterCursor,
         conversation: input.conversation,
@@ -1179,12 +1417,10 @@ async function listAutoReplyActiveTurnInputs(input) {
         knownInputIds: input.knownInputIds,
         signal: input.signal,
     });
-    const expectedChannel = normalizeNullableString(input.context.firstItem.summary.source);
-    const deliveryTarget = readAutoReplyDeliveryTarget(input.context);
     if (!input.inputSource.listInputCandidates || !expectedChannel || !deliveryTarget) {
         return strict;
     }
-    const routeListed = await input.inputSource.listInputCandidates({
+    const route = await input.inputSource.listInputCandidates({
         afterCursor: input.afterCursor,
         knownInputIds: [
             ...input.knownInputIds,
@@ -1194,54 +1430,65 @@ async function listAutoReplyActiveTurnInputs(input) {
         signal: input.signal,
         sourceId: expectedChannel,
     });
-    const knownInputIds = new Set(input.knownInputIds);
-    const knownProjectionCaptureIds = new Set(input.knownProjectionCaptureIds);
-    const routeInputs = routeListed.inputs
-        .filter((candidate) => !knownInputIds.has(candidate.event.inputId))
-        .filter((candidate) => candidate.projection.captureId
-        ? !knownProjectionCaptureIds.has(candidate.projection.captureId)
-        : true)
-        .filter((candidate) => isSameAutoReplyDeliveryRoute({
-        candidate,
+    return selectAutoReplyRouteInput({
+        afterCursor: input.afterCursor,
+        candidates: [...strict.inputs, ...route.inputs],
+        conversation: input.conversation,
+        deliveryTarget,
         expectedChannel,
-        threadId: deliveryTarget,
-    }));
-    return mergeAssistantInputCandidateBatches([
-        strict,
-        {
-            inputs: routeInputs,
-            nextCursor: routeInputs[0]
-                ? routeInputs[routeInputs.length - 1].event.cursor
-                : strict.nextCursor,
-        },
-    ]);
+        knownProjectionCaptureIds: input.knownProjectionCaptureIds,
+    });
 }
-function mergeAssistantInputCandidateBatches(batches) {
-    const byInputId = new Map();
-    for (const batch of batches) {
-        for (const candidate of batch.inputs) {
-            byInputId.set(candidate.event.inputId, candidate);
+function selectAutoReplyRouteInput(input) {
+    const knownProjectionCaptureIds = new Set(input.knownProjectionCaptureIds);
+    let nextCursor = input.afterCursor;
+    for (const candidate of [...input.candidates].sort((left, right) => compareAssistantInputCursors(left.event.cursor, right.event.cursor))) {
+        if (!isSameAutoReplyDeliveryRoute({
+            accountId: input.conversation.accountId,
+            candidate,
+            expectedChannel: input.expectedChannel,
+            threadIsDirect: input.conversation.threadIsDirect,
+            threadId: input.deliveryTarget,
+        })) {
+            continue;
+        }
+        if (input.conversation.threadIsDirect === false &&
+            !isSameAutoReplyGroupActor(candidate.event.conversation, input.conversation)) {
+            break;
         }
+        nextCursor = candidate.event.cursor;
+        if (candidate.projection.captureId &&
+            knownProjectionCaptureIds.has(candidate.projection.captureId)) {
+            continue;
+        }
+        return {
+            inputs: [candidate],
+            nextCursor,
+        };
     }
-    const inputs = [...byInputId.values()].sort((left, right) => compareAssistantInputCursors(left.event.cursor, right.event.cursor));
-    const cursorCandidates = [
-        ...batches.map((batch) => batch.nextCursor).filter((cursor) => cursor !== null),
-        ...inputs.map((candidate) => candidate.event.cursor),
-    ];
-    const nextCursor = cursorCandidates.reduce((latest, cursor) => !latest || compareAssistantInputCursors(cursor, latest) > 0
-        ? cursor
-        : latest, null);
     return {
-        inputs,
+        inputs: [],
         nextCursor,
     };
 }
 function isSameAutoReplyDeliveryRoute(input) {
     const replyTarget = input.candidate.event.replyTarget;
-    return (normalizeNullableString(replyTarget?.channel) === input.expectedChannel &&
+    return (typeof input.threadIsDirect === 'boolean' &&
+        input.candidate.event.conversation?.accountId === input.accountId &&
+        input.candidate.event.conversation?.threadIsDirect === input.threadIsDirect &&
+        normalizeNullableString(replyTarget?.channel) === input.expectedChannel &&
         normalizeNullableString(input.candidate.event.source) === input.expectedChannel &&
         readProviderRouteScalar(replyTarget?.threadId) === input.threadId);
 }
+function isSameAutoReplyGroupActor(candidate, expected) {
+    return Boolean(expected.actorId &&
+        candidate?.actorId &&
+        candidate.accountId === expected.accountId &&
+        candidate.actorId === expected.actorId &&
+        candidate.actorIsSelf === expected.actorIsSelf &&
+        candidate.source === expected.source &&
+        candidate.threadIsDirect === false);
+}
 function loadAssistantInputCandidateSummaries(input) {
     return input.candidates.map((candidate) => assistantAutoReplyGroupItemFromInputCandidate(candidate).summary);
 }
@@ -1381,6 +1628,7 @@ function admitCapturelessAssistantInputs(input) {
         acceptedInputs,
         deliveryIdempotencyKey: hostedDelivery.deliveryIdempotencyKey,
         hostedDeliveryIdempotency: hostedDelivery.hostedDeliveryIdempotency,
+        answeredMailboxItemIds: hostedDelivery.answeredMailboxItemIds,
         ...(deliveryReplyToMessageId !== undefined
             ? { deliveryReplyToMessageId }
             : {}),
@@ -1426,9 +1674,11 @@ function buildCapturelessAssistantInputPrompt(candidates) {
             projectionReasonCode: candidate.projection.reasonCode,
             projectionStatus: candidate.projection.status,
         });
+        const groupContext = renderAssistantInputGroupContextPrompt(candidate.event);
         const sections = [
             `Source: ${candidate.event.source}
 Occurred at: ${candidate.event.occurredAt}`,
+            groupContext,
             transcript
                 ? `Message text:
 ${transcript}`
@@ -1689,8 +1939,7 @@ function replyTargetUsesThreadAsExplicitDeliveryTarget(replyTarget) {
     const channel = normalizeNullableString(replyTarget?.channel);
     return channel === 'linq'
         || channel === 'telegram'
-        || channel === 'email'
-        || channel === 'whatsapp';
+        || channel === 'email';
 }
 function autoReplyInputCandidatesFromContext(context) {
     return context.items
@@ -1929,11 +2178,17 @@ function isAssistantProviderEmptyResponseFailure(error) {
 function createAdvancingSkipDecision(reason, input) {
     return {
         advanceCursor: true,
+        ...(input?.advanceInputIds
+            ? { advanceInputIds: [...input.advanceInputIds] }
+            : {}),
         ...(input?.checkpointRequired ? { checkpointRequired: true } : {}),
         kind: 'skip',
         nextWakeAt: null,
         reason,
-        stopScanning: false,
+        stopScanning: input?.stopScanning ?? false,
+        ...(input?.terminalLinqCleanup?.length
+            ? { terminalLinqCleanup: [...input.terminalLinqCleanup] }
+            : {}),
         terminalSuppression: input?.terminalSuppression ?? true,
     };
 }
@@ -1946,6 +2201,10 @@ function resolveAutoReplyLinqProviderMessageIdsFromContext(context) {
         if (item.summary.source !== 'linq') {
             continue;
         }
+        if (item.inputCandidate?.event.sourceMetadata?.kind === 'linq' &&
+            item.inputCandidate.event.sourceMetadata.affirmativeReaction === true) {
+            continue;
+        }
         const replyTargetMessageId = readLinqProviderMessageId(item.inputCandidate?.event.replyTarget?.channel === 'linq'
             ? item.inputCandidate.event.replyTarget.messageId
             : null);
@@ -1958,42 +2217,208 @@ function resolveAutoReplyLinqProviderMessageIdsFromContext(context) {
 function readLinqProviderMessageId(value) {
     return readProviderRouteScalar(value);
 }
-function findRepairableTerminalEvidenceForGroup(captureIds, evidence) {
-    if (captureIds.length === 0) {
+function findRepairableTerminalEvidencePartitionsForGroup(input) {
+    const currentItems = input.group.items.map((item) => ({
+        captureId: item.summary.optionalInboxCaptureId,
+        inputId: item.inputCandidate.event.inputId,
+    }));
+    const currentInputIds = currentItems.map((item) => item.inputId);
+    if (new Set(currentInputIds).size !== currentInputIds.length ||
+        currentInputIds.length !== input.group.inputIds.length ||
+        currentInputIds.some((inputId, index) => inputId !== input.group.inputIds[index])) {
         return null;
     }
-    return evidence.find((item) => {
-        if (!item) {
-            return false;
+    const currentInputIdSet = new Set(currentInputIds);
+    const currentInputIndexById = new Map(currentInputIds.map((inputId, index) => [inputId, index]));
+    const currentCaptureIndexById = new Map();
+    let hasDuplicateCurrentCaptureId = false;
+    for (const [index, item] of currentItems.entries()) {
+        if (!item.captureId) {
+            continue;
         }
-        return captureIds.every((captureId) => item.groupCaptureIds.includes(captureId));
-    }) ?? null;
+        if (currentCaptureIndexById.has(item.captureId)) {
+            hasDuplicateCurrentCaptureId = true;
+            continue;
+        }
+        currentCaptureIndexById.set(item.captureId, index);
+    }
+    const partitions = [];
+    const partitionByKey = new Map();
+    for (const entry of input.entries) {
+        if (!entry.evidence || !entry.evidenceId || !entry.lookup) {
+            continue;
+        }
+        const evidence = entry.evidence;
+        let fingerprint;
+        let mode;
+        let partitionInputIds;
+        if (entry.lookup === 'input') {
+            partitionInputIds = [...new Set(evidence.groupInputIds)];
+            if (entry.evidenceId !== entry.ownerInputId ||
+                evidence.captureId !== entry.ownerInputId ||
+                evidence.inputId !== entry.ownerInputId ||
+                partitionInputIds.length === 0 ||
+                partitionInputIds.length !== evidence.groupInputIds.length ||
+                !partitionInputIds.includes(entry.ownerInputId) ||
+                partitionInputIds.some((inputId) => !currentInputIdSet.has(inputId)) ||
+                !isExactContiguousAssistantInputPartition({
+                    currentInputIndexById,
+                    inputIds: partitionInputIds,
+                })) {
+                return null;
+            }
+            fingerprint = terminalEvidencePartitionFingerprint(evidence);
+            mode = 'modern-input';
+        }
+        else {
+            const ownerItemIndex = currentInputIndexById.get(entry.ownerInputId);
+            const ownerCaptureId = ownerItemIndex === undefined
+                ? null
+                : currentItems[ownerItemIndex]?.captureId ?? null;
+            const partitionCaptureIds = [...new Set(evidence.groupCaptureIds)];
+            if (hasDuplicateCurrentCaptureId ||
+                !ownerCaptureId ||
+                entry.evidenceId !== ownerCaptureId ||
+                evidence.captureId !== ownerCaptureId ||
+                evidence.inputId !== ownerCaptureId ||
+                evidence.groupInputIds.length > 0 ||
+                partitionCaptureIds.length === 0 ||
+                partitionCaptureIds.length !== evidence.groupCaptureIds.length ||
+                !partitionCaptureIds.includes(ownerCaptureId)) {
+                return null;
+            }
+            const partitionIndexes = partitionCaptureIds.map((captureId) => currentCaptureIndexById.get(captureId) ?? -1);
+            if (!isExactContiguousAssistantInputPartitionIndexes(partitionIndexes)) {
+                return null;
+            }
+            partitionInputIds = partitionIndexes.map((index) => currentItems[index].inputId);
+            fingerprint = terminalEvidenceLegacyPartitionFingerprint(evidence);
+            mode = 'legacy-capture';
+        }
+        const partitionKey = JSON.stringify(partitionInputIds);
+        const terminalFingerprint = terminalEvidenceOutcomeFingerprint(evidence);
+        const existingPartition = partitionByKey.get(partitionKey);
+        if (existingPartition) {
+            if (existingPartition.terminalFingerprint !== terminalFingerprint ||
+                (existingPartition.mode === mode &&
+                    existingPartition.fingerprint !== fingerprint)) {
+                return null;
+            }
+            if (existingPartition.mode === 'legacy-capture' &&
+                mode === 'modern-input') {
+                existingPartition.evidence = evidence;
+                existingPartition.fingerprint = fingerprint;
+                existingPartition.mode = mode;
+            }
+            continue;
+        }
+        if (partitions.some((partition) => partition.inputIds.some((inputId) => partitionInputIds.includes(inputId)))) {
+            return null;
+        }
+        const partition = {
+            evidence,
+            fingerprint,
+            inputIds: partitionInputIds,
+            mode,
+            terminalFingerprint,
+        };
+        partitions.push(partition);
+        partitionByKey.set(partitionKey, partition);
+    }
+    const coveredInputIds = new Set(partitions.flatMap((partition) => partition.inputIds));
+    const repairInputIds = [];
+    let foundUncoveredInput = false;
+    // Cursor progress can retire only the oldest contiguous handled prefix.
+    // Evidence after an uncovered input belongs to a later obligation and must
+    // stay fail-closed instead of letting recovery jump over the gap.
+    for (const currentInputId of currentInputIds) {
+        if (coveredInputIds.has(currentInputId)) {
+            if (foundUncoveredInput) {
+                return null;
+            }
+            repairInputIds.push(currentInputId);
+        }
+        else {
+            foundUncoveredInput = true;
+        }
+    }
+    return partitions.length > 0 && repairInputIds.length > 0
+        ? {
+            inputIds: repairInputIds,
+            partitions: partitions.map((partition) => ({
+                evidence: partition.evidence,
+                inputIds: partition.inputIds,
+            })),
+        }
+        : null;
 }
-function resolveTerminalEvidenceRepairCaptureIds(input) {
-    return [...new Set([
-            ...input.evidence.groupCaptureIds,
-            ...input.captureIds,
-        ])];
+function isExactContiguousAssistantInputPartition(input) {
+    return isExactContiguousAssistantInputPartitionIndexes(input.inputIds.map((inputId) => input.currentInputIndexById.get(inputId) ?? -1));
+}
+function isExactContiguousAssistantInputPartitionIndexes(indexes) {
+    return indexes.length > 0 && indexes.every((index, offset) => index >= 0 && (offset === 0 || index === indexes[offset - 1] + 1));
+}
+function terminalEvidencePartitionFingerprint(evidence) {
+    return JSON.stringify({
+        groupCaptureIds: evidence.groupCaptureIds,
+        groupId: evidence.groupId,
+        groupInputIds: evidence.groupInputIds,
+        primaryCaptureId: evidence.primaryCaptureId,
+        primaryInputId: evidence.primaryInputId,
+        providerCleanupLinqMessageIds: evidence.providerCleanup.linqMessageIds,
+        recordedAt: evidence.recordedAt,
+        terminal: evidence.terminal,
+    });
+}
+function terminalEvidenceLegacyPartitionFingerprint(evidence) {
+    return JSON.stringify({
+        groupCaptureIds: evidence.groupCaptureIds,
+        groupId: evidence.groupId,
+        primaryCaptureId: evidence.primaryCaptureId,
+        terminalOutcome: terminalEvidenceOutcomeFingerprint(evidence),
+    });
 }
-async function terminalEvidenceExistsForEveryCapture(vault, captureIds) {
-    const evidence = await Promise.all(captureIds.map((captureId) => readAssistantAutoReplyTerminalEvidenceByEvidenceId(vault, captureId)));
+function terminalEvidenceOutcomeFingerprint(evidence) {
+    const terminal = evidence.terminal.kind === 'retry_exhausted'
+        ? {
+            kind: 'suppressed',
+            reason: evidence.terminal.reason,
+        }
+        : evidence.terminal;
+    return JSON.stringify({
+        providerCleanupLinqMessageIds: evidence.providerCleanup.linqMessageIds,
+        recordedAt: evidence.recordedAt,
+        terminal,
+    });
+}
+function resolveTerminalEvidenceRepairCaptureIds(input) {
+    const inputIdSet = new Set(input.inputIds);
+    return [...new Set(input.group.items.flatMap((item) => {
+            const inputId = item.inputCandidate.event.inputId;
+            const captureId = item.summary.optionalInboxCaptureId;
+            return inputIdSet.has(inputId) && captureId ? [captureId] : [];
+        }))];
+}
+async function terminalEvidenceExistsForEveryId(vault, evidenceIds) {
+    const evidence = await Promise.all(evidenceIds.map((evidenceId) => readAssistantAutoReplyTerminalEvidenceByEvidenceId(vault, evidenceId)));
     return evidence.every((item) => item !== null);
 }
 async function backfillAssistantAutoReplyTerminalEvidenceFromTerminalEvidence(input) {
     if (input.evidence.terminal.kind === 'suppressed' ||
         input.evidence.terminal.kind === 'retry_exhausted') {
-        await writeAssistantAutoReplySuppressionEvidence({
+        return await writeAssistantAutoReplySuppressionEvidence({
             captureIds: input.captureIds,
+            ...(input.inputIds.length > 0 ? { inputIds: input.inputIds } : {}),
             linqMessageIds: input.evidence.providerCleanup.linqMessageIds,
             reason: input.evidence.terminal.reason,
             recordedAt: input.evidence.recordedAt,
             vault: input.vault,
         });
-        return;
     }
-    await writeAssistantAutoReplyReplyTerminalEvidence({
+    return await writeAssistantAutoReplyReplyTerminalEvidence({
         captureIds: input.captureIds,
         deliveryIntentId: input.evidence.terminal.deliveryIntentId,
+        ...(input.inputIds.length > 0 ? { inputIds: input.inputIds } : {}),
         linqMessageIds: input.evidence.providerCleanup.linqMessageIds,
         outcome: input.evidence.terminal.kind === 'replied' ? 'result' : 'deferred',
         recordedAt: input.evidence.recordedAt,
@@ -2003,7 +2428,7 @@ async function backfillAssistantAutoReplyTerminalEvidenceFromTerminalEvidence(in
     });
 }
 async function backfillAssistantAutoReplyTerminalEvidenceFromTerminalSnapshot(input) {
-    await writeAssistantAutoReplyReplyTerminalEvidence({
+    return await writeAssistantAutoReplyReplyTerminalEvidence({
         captureIds: input.captureIds,
         deliveryIntentId: input.snapshot.deliveryIntentId,
         inputIds: input.context.inputIds,
@@ -2014,21 +2439,47 @@ async function backfillAssistantAutoReplyTerminalEvidenceFromTerminalSnapshot(in
         vault: input.vault,
     });
 }
-export function createAssistantAutoReplyReceiptReader(input) {
+export function createAssistantAutoReplyHistoryReader(input) {
+    let outboxIntents = null;
+    let outboxScanElapsedMs = null;
+    let receiptScanMetrics = null;
     let receipts = null;
     return {
+        readMetrics() {
+            return {
+                ...(outboxScanElapsedMs === null ? {} : { outboxScanElapsedMs }),
+                outboxScanPerformed: outboxScanElapsedMs !== null,
+                ...(receiptScanMetrics === null
+                    ? {}
+                    : {
+                        receiptScanBytesRead: receiptScanMetrics.bytesRead,
+                        receiptScanElapsedMs: receiptScanMetrics.scanElapsedMs,
+                        receiptScanFilesRead: receiptScanMetrics.filesRead,
+                        receiptScanLockWaitMs: receiptScanMetrics.lockWaitMs,
+                    }),
+                receiptScanPerformed: receiptScanMetrics !== null,
+            };
+        },
+        readOutboxIntents() {
+            outboxIntents ??= (async () => {
+                const startedAt = Date.now();
+                try {
+                    return await listAssistantOutboxIntents(input.vault);
+                }
+                finally {
+                    outboxScanElapsedMs = Math.max(0, Date.now() - startedAt);
+                }
+            })();
+            return outboxIntents;
+        },
         readReceipts() {
-            receipts ??= listAssistantTurnReceipts(input.vault, ASSISTANT_AUTO_REPLY_RECEIPT_SCAN_LIMIT);
+            receipts ??= listAssistantTurnReceipts(input.vault, ASSISTANT_AUTO_REPLY_RECEIPT_SCAN_LIMIT, (metrics) => {
+                receiptScanMetrics = metrics;
+            });
             return receipts;
         },
     };
 }
-async function readAssistantAutoReplyReceiptRecords(input) {
-    if (input.receiptReader) {
-        return input.receiptReader.readReceipts();
-    }
-    return listAssistantTurnReceipts(input.vault, ASSISTANT_AUTO_REPLY_RECEIPT_SCAN_LIMIT);
-}
 function findHandledAutoReplyReceiptForGroup(input) {
     const captureIds = input.captureIds ?? [];
     let latestReceipt = null;
@@ -2112,8 +2563,8 @@ async function isRecentSelfAuthoredAssistantEcho(input) {
     const inputProviderMessageId = readProviderRouteScalar(input.input.replyTarget?.messageId);
     const matchingDeliveries = await listAssistantAutoReplyMatchingOutboxDeliveries({
         deliveryTarget: input.deliveryTarget,
+        historyReader: input.historyReader,
         input: input.input,
-        vault: input.vault,
     });
     if (inputProviderMessageId !== null &&
         matchingDeliveries.some((delivery) => delivery.providerMessageIds.includes(inputProviderMessageId))) {
@@ -2179,13 +2630,21 @@ async function resolveAssistantAutoReplyLatestCrossSessionDelivery(input) {
     const channel = normalizeNullableString(input.input.source);
     const deliveryTarget = normalizeNullableString(input.deliveryTarget);
     if (!channel || !deliveryTarget) {
-        return null;
+        return {
+            delivery: null,
+            replyTargetDelivery: null,
+        };
     }
-    const sessionEligible = (await listAssistantAutoReplyMatchingOutboxDeliveries({
+    const matchingDeliveries = await listAssistantAutoReplyMatchingOutboxDeliveries({
         deliveryTarget,
+        historyReader: input.historyReader,
         input: input.input,
-        vault: input.vault,
-    }))
+    });
+    const replyToMessageId = input.replyToMessageId;
+    const replyTargetDelivery = replyToMessageId === null
+        ? null
+        : matchingDeliveries.find((delivery) => delivery.providerMessageIds.includes(replyToMessageId)) ?? null;
+    const sessionEligible = matchingDeliveries
         .filter((delivery) => input.session === null || delivery.sessionId !== input.session.sessionId)
         .sort((left, right) => left.sentAtMs === right.sentAtMs
         ? left.intentId.localeCompare(right.intentId)
@@ -2197,26 +2656,39 @@ async function resolveAssistantAutoReplyLatestCrossSessionDelivery(input) {
     // stale deliveries; an exact provider-id match across the same route can't
     // be either. The send-ack/inbound-webhook race that records sentAt after
     // the inbound input's receivedAt is the realistic case this protects.
-    if (input.replyToMessageId) {
-        return (sessionEligible.find((delivery) => delivery.providerMessageIds.includes(input.replyToMessageId)) ?? null);
+    if (replyToMessageId) {
+        return {
+            delivery: sessionEligible.find((delivery) => delivery.providerMessageIds.includes(replyToMessageId)) ?? null,
+            replyTargetDelivery,
+        };
     }
     const causalUpperBoundMs = resolveAssistantAutoReplyOutboxCausalUpperBoundMs(input.input);
     if (causalUpperBoundMs === null) {
-        return null;
+        return {
+            delivery: null,
+            replyTargetDelivery,
+        };
     }
     const fresh = sessionEligible.filter((delivery) => delivery.sentAtMs <= causalUpperBoundMs);
     if (fresh.length === 0) {
-        return null;
+        return {
+            delivery: null,
+            replyTargetDelivery,
+        };
     }
     // Unanchored fallback: once a delivery has been used as turn context, no
     // earlier delivery from the same route should resurface as "latest".
+    const consumedIntentIds = readAssistantAutoReplyConsumedCrossSessionIntentIds(await input.historyReader.readReceipts());
     let firstFreshIndex = 0;
     for (let index = 0; index < fresh.length; index++) {
-        if (input.consumedIntentIds.has(fresh[index].intentId)) {
+        if (consumedIntentIds.has(fresh[index].intentId)) {
             firstFreshIndex = index + 1;
         }
     }
-    return fresh.slice(firstFreshIndex).at(-1) ?? null;
+    return {
+        delivery: fresh.slice(firstFreshIndex).at(-1) ?? null,
+        replyTargetDelivery,
+    };
 }
 function readAssistantAutoReplyConsumedCrossSessionIntentIds(receipts) {
     const consumed = new Set();
@@ -2250,7 +2722,7 @@ async function listAssistantAutoReplyMatchingOutboxDeliveries(input) {
     if (!channel || !deliveryTarget) {
         return [];
     }
-    const intents = await listAssistantOutboxIntents(input.vault);
+    const intents = await input.historyReader.readOutboxIntents();
     return intents.flatMap((intent) => {
         if (intent.status !== 'sent' || intent.operation !== null) {
             return [];
@@ -2382,6 +2854,20 @@ function buildAssistantAutoReplyCrossSessionTurnContext(message) {
         'Use it only to interpret the current user message.',
     ].join('\n');
 }
+function buildAssistantAutoReplyAffirmativeReactionTurnContext(message) {
+    const normalized = normalizeNullableString(message);
+    if (!normalized) {
+        return null;
+    }
+    return [
+        'Affirmative reaction target:',
+        'The user reacted affirmatively to this exact assistant message:',
+        '',
+        normalized.slice(0, ASSISTANT_AUTO_REPLY_PRIOR_MESSAGE_MAX_LENGTH),
+        '',
+        'Bind the affirmative response only to this message.',
+    ].join('\n');
+}
 function normalizeComparableText(text) {
     return text.replace(/\s+/gu, ' ').trim();
 }