@zq-silk/yui 0.6.8 → 0.6.10

package/dist/coordination/workMailbox.js

@@ -1,4 +1,5 @@
 import { validateTaskRecordReference } from "../task/taskRecordReference.js";
+const RECENT_DEDUPE_KEY_LIMIT = 256;
 function requireText(value, label) {
     const normalized = value.trim();
     if (normalized.length === 0) {
@@ -128,7 +129,15 @@ function mergeBatches(earlier, later) {
         refs: appendUnique(earlier.refs, later.refs, mailboxEntityRefKey),
         requestCount: earlier.requestCount + later.requestCount,
         firstQueuedAt: earlier.firstQueuedAt,
-        lastQueuedAt: later.lastQueuedAt
+        lastQueuedAt: later.lastQueuedAt,
+        sources: appendUnique(earlier.sources, later.sources, (source) => source),
+        dedupeKeys: appendUnique(earlier.dedupeKeys, later.dedupeKeys, (key) => key),
+        deliveryModes: appendUnique(earlier.deliveryModes, later.deliveryModes, (mode) => mode),
+        ...((earlier.highestFactRevision ?? later.highestFactRevision) === undefined
+            ? {}
+            : {
+                highestFactRevision: Math.max(earlier.highestFactRevision ?? 0, later.highestFactRevision ?? 0)
+            })
     };
     return merged;
 }
@@ -144,32 +153,87 @@ function requireProcessing(mailbox, batchId) {
 }
 export function createWorkMailbox(target) {
     return {
-        schemaVersion: 1,
+        schemaVersion: 2,
         target: copyTarget(target),
         nextSequence: 1,
         processing: null,
-        pending: null
+        pending: {
+            normal: null,
+            userCorrection: null,
+            cursors: { normal: 0, userCorrection: 0 },
+            recentDedupeKeys: []
+        },
+        inputDelivery: null
     };
 }
 export function validateWorkMailbox(value) {
     const mailbox = record(value, "WorkMailbox");
-    exact(mailbox, ["schemaVersion", "target", "nextSequence", "processing", "pending"], "WorkMailbox");
-    if (mailbox.schemaVersion !== 1)
-        throw new Error("WorkMailbox must use schemaVersion 1");
+    exact(mailbox, ["schemaVersion", "target", "nextSequence", "processing", "pending", "inputDelivery"], "WorkMailbox");
+    if (mailbox.schemaVersion !== 2)
+        throw new Error("WorkMailbox must use schemaVersion 2");
     const target = parseTarget(mailbox.target);
     const nextSequence = requireInteger(mailbox.nextSequence, 1, "WorkMailbox nextSequence");
     const processing = mailbox.processing === null ? null : parseProcessing(mailbox.processing);
-    const pending = mailbox.pending === null ? null : parseBatch(mailbox.pending, "WorkMailbox pending");
-    const batches = [processing?.batch, pending].filter((batch) => batch !== null && batch !== undefined);
+    const pending = parsePendingLanes(mailbox.pending);
+    for (const cursor of [pending.cursors.normal, pending.cursors.userCorrection]) {
+        if (cursor >= nextSequence) {
+            throw new Error("WorkMailbox lane cursor must be lower than nextSequence");
+        }
+    }
+    if (pending.normal !== null && pending.normal.fromSequence <= pending.cursors.normal) {
+        throw new Error("WorkMailbox normal pending batch is behind its cursor");
+    }
+    if (pending.userCorrection !== null
+        && pending.userCorrection.fromSequence <= pending.cursors.userCorrection) {
+        throw new Error("WorkMailbox user-correction pending batch is behind its cursor");
+    }
+    const inputDelivery = mailbox.inputDelivery === null
+        ? null
+        : parseInputDelivery(mailbox.inputDelivery);
+    const batches = [
+        processing?.batch,
+        pending.normal,
+        pending.userCorrection,
+        inputDelivery?.batch
+    ].filter((batch) => batch !== null && batch !== undefined);
     for (const batch of batches) {
         if (batch.toSequence >= nextSequence) {
             throw new Error("WorkMailbox batch sequence must be lower than nextSequence");
         }
     }
-    if (processing !== null && pending !== null && processing.batch.toSequence >= pending.fromSequence) {
-        throw new Error("WorkMailbox processing and pending sequences overlap");
+    const ranges = batches
+        .map((batch) => [batch.fromSequence, batch.toSequence])
+        .sort((left, right) => left[0] - right[0]);
+    for (let index = 1; index < ranges.length; index += 1) {
+        if (ranges[index - 1][1] >= ranges[index][0]) {
+            throw new Error("WorkMailbox batch sequences overlap");
+        }
+    }
+    if (inputDelivery !== null && target.kind !== "role" && target.kind !== "operator") {
+        throw new Error("WorkMailbox inputDelivery requires a Role or Operator target");
+    }
+    return { schemaVersion: 2, target, nextSequence, processing, pending, inputDelivery };
+}
+function parsePendingLanes(value) {
+    const lanes = record(value, "WorkMailbox pending");
+    exact(lanes, ["normal", "userCorrection", "cursors", "recentDedupeKeys"], "WorkMailbox pending");
+    const cursors = record(lanes.cursors, "WorkMailbox pending cursors");
+    exact(cursors, ["normal", "userCorrection"], "WorkMailbox pending cursors");
+    const recentDedupeKeys = requireStringArray(lanes.recentDedupeKeys, "WorkMailbox recent dedupe keys");
+    if (recentDedupeKeys.length > RECENT_DEDUPE_KEY_LIMIT) {
+        throw new Error("WorkMailbox recent dedupe keys exceed the bounded limit");
     }
-    return { schemaVersion: 1, target, nextSequence, processing, pending };
+    return {
+        normal: lanes.normal === null ? null : parseBatch(lanes.normal, "WorkMailbox pending normal"),
+        userCorrection: lanes.userCorrection === null
+            ? null
+            : parseBatch(lanes.userCorrection, "WorkMailbox pending userCorrection"),
+        cursors: {
+            normal: requireInteger(cursors.normal, 0, "WorkMailbox normal cursor"),
+            userCorrection: requireInteger(cursors.userCorrection, 0, "WorkMailbox user-correction cursor")
+        },
+        recentDedupeKeys
+    };
 }
 function parseTarget(value) {
     const target = record(value, "WorkMailbox target");
@@ -206,7 +270,9 @@ function parseTarget(value) {
 }
 function parseRef(value, label) {
     const ref = record(value, label);
-    const types = ["task", "run", "work-item", "input", "session", "message"];
+    const types = [
+        "task", "run", "work-item", "input", "session", "message", "event"
+    ];
     if (!types.includes(ref.type))
         throw new Error(`${label} type is invalid`);
     if (ref.type === "task" || ref.type === "session") {
@@ -222,8 +288,19 @@ function parseRef(value, label) {
 }
 function parseBatch(value, label) {
     const batch = record(value, label);
-    const required = ["fromSequence", "toSequence", "reasons", "refs", "requestCount", "firstQueuedAt", "lastQueuedAt"];
-    exact(batch, required, label);
+    const required = [
+        "fromSequence",
+        "toSequence",
+        "reasons",
+        "refs",
+        "requestCount",
+        "firstQueuedAt",
+        "lastQueuedAt",
+        "sources",
+        "dedupeKeys",
+        "deliveryModes"
+    ];
+    exact(batch, batch.highestFactRevision === undefined ? required : [...required, "highestFactRevision"], label);
     const fromSequence = requireInteger(batch.fromSequence, 1, `${label} fromSequence`);
     const toSequence = requireInteger(batch.toSequence, fromSequence, `${label} toSequence`);
     const requestCount = requireInteger(batch.requestCount, 1, `${label} requestCount`);
@@ -246,16 +323,34 @@ function parseBatch(value, label) {
         refs,
         requestCount,
         firstQueuedAt: requireTimestamp(batch.firstQueuedAt, `${label} firstQueuedAt`),
-        lastQueuedAt: requireTimestamp(batch.lastQueuedAt, `${label} lastQueuedAt`)
+        lastQueuedAt: requireTimestamp(batch.lastQueuedAt, `${label} lastQueuedAt`),
+        sources: requireStringArray(batch.sources, `${label} sources`),
+        dedupeKeys: requireStringArray(batch.dedupeKeys, `${label} dedupeKeys`),
+        deliveryModes: parseDeliveryModes(batch.deliveryModes, `${label} deliveryModes`),
+        ...(batch.highestFactRevision === undefined
+            ? {}
+            : {
+                highestFactRevision: requireInteger(batch.highestFactRevision, 0, `${label} highestFactRevision`)
+            })
     };
     return result;
 }
+function parseDeliveryModes(value, label) {
+    const modes = requireStringArray(value, label);
+    for (const mode of modes) {
+        if (mode !== "followup" && mode !== "steer-if-safe" && mode !== "inject") {
+            throw new Error(`${label} contains an invalid delivery mode`);
+        }
+    }
+    return modes;
+}
 function parseProcessing(value) {
     const processing = record(value, "WorkMailbox processing");
-    const required = ["batchId", "batch", "owner", "startedAt"];
+    const required = ["batchId", "lane", "batch", "owner", "startedAt"];
     exact(processing, processing.executionRef === undefined ? required : [...required, "executionRef"], "WorkMailbox processing");
     const result = {
         batchId: requireString(processing.batchId, "WorkMailbox processing batchId"),
+        lane: parseLane(processing.lane, "WorkMailbox processing lane"),
         batch: parseBatch(processing.batch, "WorkMailbox processing batch"),
         owner: requireString(processing.owner, "WorkMailbox processing owner"),
         startedAt: requireTimestamp(processing.startedAt, "WorkMailbox processing startedAt")
@@ -264,11 +359,97 @@ function parseProcessing(value) {
         ? result
         : { ...result, executionRef: parseRef(processing.executionRef, "WorkMailbox processing executionRef") };
 }
+function parseInputDelivery(value) {
+    const input = record(value, "WorkMailbox inputDelivery");
+    const required = [
+        "attemptId",
+        "lane",
+        "mode",
+        "batch",
+        "owner",
+        "status",
+        "startedAt",
+        "executionRef"
+    ];
+    const optional = [
+        ...(input.pushedAt === undefined ? [] : ["pushedAt"]),
+        ...(input.unknownReason === undefined ? [] : ["unknownReason"]),
+        ...(input.providerFence === undefined ? [] : ["providerFence"])
+    ];
+    exact(input, [...required, ...optional], "WorkMailbox inputDelivery");
+    const lane = parseLane(input.lane, "WorkMailbox inputDelivery lane");
+    const mode = parseDeliveryMode(input.mode, "WorkMailbox inputDelivery mode");
+    if (input.status !== "dispatching" && input.status !== "delivery-unknown") {
+        throw new Error("WorkMailbox inputDelivery status is invalid");
+    }
+    const status = input.status;
+    if ((status === "delivery-unknown") !== (input.unknownReason !== undefined)) {
+        throw new Error("WorkMailbox delivery-unknown requires exactly one unknownReason");
+    }
+    const result = {
+        attemptId: requireString(input.attemptId, "WorkMailbox inputDelivery attemptId"),
+        lane,
+        mode,
+        batch: parseBatch(input.batch, "WorkMailbox inputDelivery batch"),
+        owner: requireString(input.owner, "WorkMailbox inputDelivery owner"),
+        status,
+        startedAt: requireTimestamp(input.startedAt, "WorkMailbox inputDelivery startedAt"),
+        executionRef: parseRef(input.executionRef, "WorkMailbox inputDelivery executionRef"),
+        ...(input.pushedAt === undefined
+            ? {}
+            : { pushedAt: requireTimestamp(input.pushedAt, "WorkMailbox inputDelivery pushedAt") }),
+        ...(input.unknownReason === undefined
+            ? {}
+            : { unknownReason: requireString(input.unknownReason, "WorkMailbox inputDelivery unknownReason") }),
+        ...(input.providerFence === undefined
+            ? {}
+            : { providerFence: parseProviderFence(input.providerFence) })
+    };
+    if (result.pushedAt !== undefined
+        && Date.parse(result.pushedAt) < Date.parse(result.startedAt)) {
+        throw new Error("WorkMailbox inputDelivery pushedAt is earlier than startedAt");
+    }
+    return result;
+}
+function parseProviderFence(value) {
+    const fence = record(value, "WorkMailbox inputDelivery providerFence");
+    exact(fence, fence.nativeTurnId === undefined
+        ? ["conversationId", "activationId"]
+        : ["conversationId", "activationId", "nativeTurnId"], "WorkMailbox inputDelivery providerFence");
+    return {
+        conversationId: requireString(fence.conversationId, "Provider Conversation id"),
+        activationId: requireString(fence.activationId, "Provider Activation id"),
+        ...(fence.nativeTurnId === undefined
+            ? {}
+            : { nativeTurnId: requireString(fence.nativeTurnId, "Provider Turn id") })
+    };
+}
+function parseLane(value, label) {
+    if (value !== "normal" && value !== "user-correction") {
+        throw new Error(`${label} is invalid`);
+    }
+    return value;
+}
+function parseDeliveryMode(value, label) {
+    if (value !== "followup" && value !== "steer-if-safe" && value !== "inject") {
+        throw new Error(`${label} is invalid`);
+    }
+    return value;
+}
 export function enqueueSignal(mailbox, signal) {
     const reason = requireText(signal.reason, "signal reason");
     const occurredAt = requireText(signal.occurredAt, "signal occurredAt");
+    const lane = signal.lane ?? "normal";
+    const laneKey = lane === "normal" ? "normal" : "userCorrection";
+    const deliveryMode = signal.deliveryMode ?? "followup";
+    const source = requireText(signal.source ?? "yui", "signal source");
     const refs = signal.refs.map(copyRef);
     const sequence = mailbox.nextSequence;
+    const dedupeKey = signal.dedupeKey === undefined
+        ? `sequence:${sequence}`
+        : requireText(signal.dedupeKey, "signal dedupeKey");
+    if (mailboxContainsDedupeKey(mailbox, dedupeKey))
+        return mailbox;
     const incoming = {
         fromSequence: sequence,
         toSequence: sequence,
@@ -276,38 +457,98 @@ export function enqueueSignal(mailbox, signal) {
         refs: appendUnique([], refs, mailboxEntityRefKey),
         requestCount: 1,
         firstQueuedAt: occurredAt,
-        lastQueuedAt: occurredAt
+        lastQueuedAt: occurredAt,
+        sources: [source],
+        dedupeKeys: [dedupeKey],
+        deliveryModes: [deliveryMode],
+        ...(signal.factRevision === undefined
+            ? {}
+            : { highestFactRevision: requireInteger(signal.factRevision, 0, "signal factRevision") })
     };
     return {
         ...mailbox,
         nextSequence: sequence + 1,
-        pending: mailbox.pending === null
-            ? incoming
-            : mergeBatches(mailbox.pending, incoming)
+        pending: {
+            ...mailbox.pending,
+            [laneKey]: mailbox.pending[laneKey] === null
+                ? incoming
+                : mergeBatches(mailbox.pending[laneKey], incoming)
+        }
     };
 }
+function mailboxContainsDedupeKey(mailbox, key) {
+    if (mailbox.pending.recentDedupeKeys.includes(key))
+        return true;
+    return [
+        mailbox.pending.normal,
+        mailbox.pending.userCorrection,
+        mailbox.processing?.batch,
+        mailbox.inputDelivery?.batch
+    ].some((batch) => batch?.dedupeKeys.includes(key) === true);
+}
+export function pendingLane(mailbox, lane) {
+    return lane === "normal" ? mailbox.pending.normal : mailbox.pending.userCorrection;
+}
+export function mailboxHasPending(mailbox) {
+    return mailbox.pending.normal !== null || mailbox.pending.userCorrection !== null;
+}
+export function nextPendingLane(mailbox) {
+    if (mailbox.pending.userCorrection !== null)
+        return "user-correction";
+    return mailbox.pending.normal === null ? null : "normal";
+}
+export function nextPendingBatch(mailbox) {
+    const lane = nextPendingLane(mailbox);
+    return lane === null ? null : pendingLane(mailbox, lane);
+}
+export function mailboxHasWork(mailbox) {
+    return mailbox.processing !== null
+        || mailbox.inputDelivery !== null
+        || mailboxHasPending(mailbox);
+}
+export function mailboxBatches(mailbox) {
+    return [
+        mailbox.processing?.batch,
+        mailbox.inputDelivery?.batch,
+        mailbox.pending.userCorrection,
+        mailbox.pending.normal
+    ].filter((batch) => batch !== null && batch !== undefined);
+}
 function mailboxTaskRecordKind(type) {
     switch (type) {
         case "run": return "agentRun";
         case "work-item": return "workItem";
         case "input": return "inputRequest";
         case "message": return "message";
+        case "event": return "event";
     }
 }
 export function claimPending(mailbox, options) {
     if (mailbox.processing !== null) {
         throw new Error("Mailbox is already processing a batch");
     }
-    if (mailbox.pending === null) {
+    const lane = options.lane ?? nextPendingLane(mailbox);
+    if (lane === null) {
         throw new Error("Mailbox has no pending work to claim");
     }
+    const batch = pendingLane(mailbox, lane);
+    if (batch === null)
+        throw new Error(`Mailbox has no pending ${lane} work to claim`);
     const processing = {
         batchId: requireText(options.batchId, "batch id"),
-        batch: mailbox.pending,
+        lane,
+        batch,
         owner: requireText(options.owner, "claim owner"),
         startedAt: requireText(options.startedAt, "claim startedAt")
     };
-    return { ...mailbox, processing, pending: null };
+    return {
+        ...mailbox,
+        processing,
+        pending: {
+            ...mailbox.pending,
+            [lane === "normal" ? "normal" : "userCorrection"]: null
+        }
+    };
 }
 export function bindExecution(mailbox, batchId, executionRef) {
     const processing = requireProcessing(mailbox, batchId);
@@ -317,13 +558,152 @@ export function bindExecution(mailbox, batchId, executionRef) {
     };
 }
 export function completeProcessing(mailbox, batchId) {
-    requireProcessing(mailbox, batchId);
-    return { ...mailbox, processing: null };
+    const processing = requireProcessing(mailbox, batchId);
+    const lane = processing.lane;
+    return validateWorkMailbox({
+        ...mailbox,
+        processing: null,
+        pending: advanceLaneCursor(mailbox.pending, lane, processing.batch)
+    });
 }
 export function releaseProcessing(mailbox, batchId) {
     const processing = requireProcessing(mailbox, batchId);
-    const released = mailbox.pending === null
+    const lane = processing.lane;
+    const key = lane === "normal" ? "normal" : "userCorrection";
+    const released = mailbox.pending[key] === null
         ? processing.batch
-        : mergeBatches(processing.batch, mailbox.pending);
-    return { ...mailbox, processing: null, pending: released };
+        : mergeBatches(processing.batch, mailbox.pending[key]);
+    return {
+        ...mailbox,
+        processing: null,
+        pending: { ...mailbox.pending, [key]: released }
+    };
+}
+function requireInputDelivery(mailbox, attemptId) {
+    const id = requireText(attemptId, "input delivery attempt id");
+    if (mailbox.inputDelivery === null)
+        throw new Error("Mailbox has no input delivery");
+    if (mailbox.inputDelivery.attemptId !== id) {
+        throw new Error(`Mailbox input delivery does not match ${id}`);
+    }
+    return mailbox.inputDelivery;
+}
+export function claimInputDelivery(mailbox, options) {
+    if (mailbox.inputDelivery !== null) {
+        if (mailbox.inputDelivery.attemptId === options.attemptId)
+            return mailbox;
+        throw new Error("Mailbox already has an input delivery");
+    }
+    const batch = pendingLane(mailbox, options.lane);
+    if (batch === null)
+        throw new Error(`Mailbox has no pending ${options.lane} input`);
+    const inputDelivery = {
+        attemptId: requireText(options.attemptId, "input delivery attempt id"),
+        lane: options.lane,
+        mode: options.mode,
+        batch,
+        owner: requireText(options.owner, "input delivery owner"),
+        status: "dispatching",
+        startedAt: requireTimestamp(options.startedAt, "input delivery startedAt"),
+        executionRef: copyRef(options.executionRef),
+        ...(options.providerFence === undefined
+            ? {}
+            : { providerFence: parseProviderFence(options.providerFence) })
+    };
+    return validateWorkMailbox({
+        ...mailbox,
+        pending: {
+            ...mailbox.pending,
+            [options.lane === "normal" ? "normal" : "userCorrection"]: null
+        },
+        inputDelivery
+    });
+}
+export function markInputDeliveryPushed(mailbox, attemptId, pushedAt) {
+    const delivery = requireInputDelivery(mailbox, attemptId);
+    if (delivery.pushedAt !== undefined)
+        return mailbox;
+    const timestamp = requireTimestamp(pushedAt.toISOString(), "input delivery pushedAt");
+    return validateWorkMailbox({
+        ...mailbox,
+        inputDelivery: { ...delivery, pushedAt: timestamp }
+    });
+}
+export function markInputDeliveryUnknown(mailbox, attemptId, reason, observedAt) {
+    const delivery = requireInputDelivery(mailbox, attemptId);
+    const timestamp = requireTimestamp(observedAt.toISOString(), "delivery unknown observedAt");
+    return validateWorkMailbox({
+        ...mailbox,
+        inputDelivery: {
+            ...delivery,
+            status: "delivery-unknown",
+            unknownReason: requireText(reason, "delivery unknown reason"),
+            pushedAt: delivery.pushedAt ?? timestamp
+        }
+    });
+}
+export function completeInputDelivery(mailbox, attemptId, _acceptedAt) {
+    const delivery = requireInputDelivery(mailbox, attemptId);
+    return validateWorkMailbox({
+        ...mailbox,
+        inputDelivery: null,
+        pending: advanceLaneCursor(mailbox.pending, delivery.lane, delivery.batch)
+    });
+}
+export function consumePendingBatch(mailbox, lane) {
+    const key = lane === "normal" ? "normal" : "userCorrection";
+    const batch = mailbox.pending[key];
+    if (batch === null)
+        throw new Error(`Mailbox has no pending ${lane} batch`);
+    return validateWorkMailbox({
+        ...mailbox,
+        pending: {
+            ...advanceLaneCursor(mailbox.pending, lane, batch),
+            [key]: null
+        }
+    });
+}
+function advanceLaneCursor(pending, lane, batch) {
+    const key = lane === "normal" ? "normal" : "userCorrection";
+    const recentDedupeKeys = appendUnique(pending.recentDedupeKeys, batch.dedupeKeys, (value) => value).slice(-RECENT_DEDUPE_KEY_LIMIT);
+    return {
+        ...pending,
+        cursors: {
+            ...pending.cursors,
+            [key]: Math.max(pending.cursors[key], batch.toSequence)
+        },
+        recentDedupeKeys
+    };
+}
+export function releaseInputDelivery(mailbox, attemptId) {
+    const delivery = requireInputDelivery(mailbox, attemptId);
+    if (delivery.pushedAt !== undefined || delivery.status === "delivery-unknown") {
+        throw new Error("A pushed or delivery-unknown input cannot return to pending");
+    }
+    const key = delivery.lane === "normal" ? "normal" : "userCorrection";
+    return validateWorkMailbox({
+        ...mailbox,
+        pending: {
+            ...mailbox.pending,
+            [key]: mailbox.pending[key] === null
+                ? delivery.batch
+                : mergeBatches(delivery.batch, mailbox.pending[key])
+        },
+        inputDelivery: null
+    });
+}
+/** Exact Provider readback proved that a previously uncertain mutation is absent. */
+export function resolveInputDeliveryNotAccepted(mailbox, attemptId) {
+    const delivery = requireInputDelivery(mailbox, attemptId);
+    const key = delivery.lane === "normal" ? "normal" : "userCorrection";
+    return validateWorkMailbox({
+        ...mailbox,
+        pending: {
+            ...mailbox.pending,
+            [key]: mailbox.pending[key] === null
+                ? delivery.batch
+                : mergeBatches(delivery.batch, mailbox.pending[key])
+        },
+        inputDelivery: null
+    });
 }

package/dist/coordination/workMailboxQueue.js

@@ -1,11 +1,12 @@
-import { completeProcessing, createWorkMailbox, enqueueSignal, mailboxEntityRefKey } from "./workMailbox.js";
+import { completeProcessing, consumePendingBatch, createWorkMailbox, enqueueSignal, mailboxBatches, mailboxEntityRefKey } from "./workMailbox.js";
 /** Atomically useful when called inside the caller's TaskStore transaction. */
-export function enqueueWork(store, target, reason, occurredAt, refs = []) {
+export function enqueueWork(store, target, reason, occurredAt, refs = [], metadata = {}) {
     const mailbox = store.getWorkMailbox(target) ?? createWorkMailbox(target);
     const queued = enqueueSignal(mailbox, {
         reason,
         refs,
-        occurredAt: timestamp(occurredAt)
+        occurredAt: timestamp(occurredAt),
+        ...metadata
     });
     store.saveWorkMailbox(queued);
     return queued;
@@ -59,17 +60,18 @@ export function settleExactWorkExecution(store, target, executionRef) {
     const mailbox = store.getWorkMailbox(target);
     if (mailbox === null)
         return "absent";
-    const pending = mailbox.pending;
-    if (pending === null)
+    const matching = mailboxBatches(mailbox).filter((batch) => batch.refs.some((ref) => mailboxEntityRefKey(ref) === mailboxEntityRefKey(executionRef)));
+    if (matching.length === 0)
         return "absent";
-    const matches = pending.refs.some((ref) => mailboxEntityRefKey(ref) === mailboxEntityRefKey(executionRef));
-    if (!matches)
-        return "absent";
-    if (pending.requestCount !== 1) {
+    if (matching.length !== 1 || matching[0].requestCount !== 1) {
         throw new Error(`Cannot settle a merged pending mailbox batch for ${targetLabel(target)}: `
             + `${executionRef.type}/${executionRef.id}.`);
     }
-    store.saveWorkMailbox({ ...mailbox, pending: null });
+    const pending = matching[0];
+    const pendingKey = mailbox.pending.normal === pending ? "normal" : "userCorrection";
+    if (mailbox.pending[pendingKey] !== pending)
+        return "absent";
+    store.saveWorkMailbox(consumePendingBatch(mailbox, pendingKey === "normal" ? "normal" : "user-correction"));
     return "pending";
 }
 function timestamp(value) {