@caupulican/pi-adaptative 0.86.3 → 0.86.5

package/dist/core/delegation/worker-agent-control.js

@@ -1,15 +1,45 @@
 import { createHash, randomUUID } from "node:crypto";
 import { existsSync } from "node:fs";
 import { workerAgentMailboxFile } from "../agent-paths.js";
+import { parseBoundedStringArray } from "../orchestration/bounded-string-array.js";
+import { MAX_ORCHESTRATION_COLLECTION_LENGTH, MAX_ORCHESTRATION_IDENTIFIER_LENGTH, } from "../orchestration/contracts.js";
 import { withFileLockSync, writeFileAtomicSync } from "../util/atomic-file.js";
 import { readBoundedTextFileSync } from "../util/bounded-file.js";
+import { createReplaySafeMailboxBounder } from "./replay-safe-mailbox-bounds.js";
 const MAX_MAILBOX_MESSAGES = 64;
 const MAX_MAILBOX_MESSAGE_CHARS = 4_096;
-const MAX_MAILBOX_BYTES = 128 * 1024;
+const MAX_ORDINARY_MAILBOX_BYTES = 128 * 1024;
 const MAX_MAILBOX_MESSAGE_ID_CHARS = 512;
 const MAX_MAILBOX_TIMESTAMP_CHARS = 128;
 const MAX_MAILBOX_IDENTITY_CHARS = 512;
-const MAX_MAILBOX_RETAINED_MESSAGES = MAX_MAILBOX_MESSAGES * 2;
+const MAX_MAILBOX_IDEMPOTENCY_KEY_CHARS = 2_048;
+const MAX_ORDINARY_RETAINED_MESSAGES = MAX_MAILBOX_MESSAGES * 2;
+const MAX_MANDATORY_RETAINED_MESSAGES = MAX_MAILBOX_MESSAGES;
+const MAX_MAILBOX_RETAINED_MESSAGES = MAX_ORDINARY_RETAINED_MESSAGES + MAX_MANDATORY_RETAINED_MESSAGES;
+const MAX_REPLAY_EVIDENCE_SLOTS = MAX_ORDINARY_RETAINED_MESSAGES * 4;
+const MAX_MAILBOX_REPLAY_RECEIPTS = MAX_REPLAY_EVIDENCE_SLOTS + MAX_ORDINARY_RETAINED_MESSAGES;
+const MAX_MAILBOX_TRANSITION_TIMESTAMP = "9999-12-31T23:59:59.999Z";
+const MAX_ENCODED_MANDATORY_MESSAGE_BYTES = Buffer.byteLength(JSON.stringify({
+    messageId: `worker-message-${"f".repeat(64)}`,
+    kind: "follow_up",
+    content: `c${"\0".repeat(MAX_MAILBOX_MESSAGE_CHARS - 1)}`,
+    senderAgentId: `s${"\0".repeat(MAX_MAILBOX_IDENTITY_CHARS - 1)}`,
+    threadId: `t${"\0".repeat(MAX_MAILBOX_IDENTITY_CHARS - 1)}`,
+    replyToMessageId: `r${"\0".repeat(MAX_MAILBOX_MESSAGE_ID_CHARS - 1)}`,
+    expectReply: true,
+    task: {
+        kind: "terminal_handoff",
+        sourceAttemptId: `a${"\0".repeat(MAX_MAILBOX_IDENTITY_CHARS - 1)}`,
+    },
+    createdAt: MAX_MAILBOX_TRANSITION_TIMESTAMP,
+    deliveredAt: MAX_MAILBOX_TRANSITION_TIMESTAMP,
+}), "utf-8") + 1;
+// The additive reserve keeps every previously valid 128 KiB ordinary mailbox migration-safe and
+// covers one maximum accepted source acknowledgement transaction (locked by the saturation tests).
+const MAX_MANDATORY_TRANSITION_RESERVE_BYTES = Math.max(48 * 1024, MAX_ENCODED_MANDATORY_MESSAGE_BYTES + 1_024);
+const MAX_MAILBOX_BYTES = MAX_ORDINARY_MAILBOX_BYTES + MAX_MANDATORY_TRANSITION_RESERVE_BYTES;
+const CONTENT_DIGEST_PATTERN = /^[a-f0-9]{64}$/;
+const assertWorkerAgentMailboxBounds = createReplaySafeMailboxBounder("Worker agent mailbox", MAX_MAILBOX_RETAINED_MESSAGES, MAX_MAILBOX_REPLAY_RECEIPTS, MAX_MAILBOX_BYTES);
 function mailboxDigest(parentSessionId, agentId) {
     return createHash("sha256")
         .update("pi-worker-agent-mailbox-v1")
@@ -27,6 +57,92 @@ function assertIdentity(value, label) {
         throw new TypeError(`Worker ${label} exceeds 512 characters.`);
     return normalized;
 }
+/** Derive one target-fenced mailbox replay identity from a host-owned broadcast call identity. */
+export function workerAgentBroadcastTargetIdempotencyKey(baseIdempotencyKey, agentId) {
+    const replayIdentity = baseIdempotencyKey.trim();
+    if (!replayIdentity || replayIdentity.length > MAX_MAILBOX_IDEMPOTENCY_KEY_CHARS) {
+        throw new TypeError("Worker broadcast idempotency key is invalid.");
+    }
+    const targetAgentId = assertIdentity(agentId, "agent id");
+    return `worker-broadcast-${createHash("sha256")
+        .update("pi-worker-broadcast-target-v1")
+        .update("\0")
+        .update(replayIdentity)
+        .update("\0")
+        .update(targetAgentId)
+        .digest("hex")}`;
+}
+/** Session-scoped replay identity. The coordinator fences one accepted id to exactly one target mailbox. */
+export function workerAgentMessageId(parentSessionId, idempotencyKey) {
+    const sessionId = assertIdentity(parentSessionId, "parent session id");
+    const replayIdentity = idempotencyKey.trim();
+    if (!replayIdentity || replayIdentity.length > MAX_MAILBOX_IDEMPOTENCY_KEY_CHARS) {
+        throw new TypeError("Worker control idempotency key is invalid.");
+    }
+    return `worker-message-${createHash("sha256")
+        .update("pi-worker-agent-message-v2")
+        .update("\0")
+        .update(sessionId)
+        .update("\0")
+        .update(replayIdentity)
+        .digest("hex")}`;
+}
+function contentDigest(domain, content) {
+    return createHash("sha256").update(domain).update("\0").update(content).digest("hex");
+}
+function controlIntentDigest(input) {
+    return contentDigest("pi-worker-agent-control-intent-v1", JSON.stringify([
+        input.content,
+        input.senderAgentId ?? null,
+        input.threadId ?? null,
+        input.replyToMessageId ?? null,
+        input.expectReply === true,
+        input.task ?? null,
+    ]));
+}
+function replyIntentDigest(content) {
+    return contentDigest("pi-worker-reply-content-v1", content);
+}
+function controlReplayReceipt(messageId, intentDigest, deliveredAt) {
+    return { kind: "control", messageId, intentDigest, ...(deliveredAt ? { deliveredAt } : {}) };
+}
+function controlReplayReceiptFor(receipts, messageId) {
+    return receipts.find((receipt) => receipt.kind === "control" && receipt.messageId === messageId);
+}
+function replyReplayReceiptFor(receipts, messageId) {
+    return receipts.find((receipt) => receipt.kind === "reply" && receipt.messageId === messageId);
+}
+function requiredMailboxTimestamp(value, label) {
+    if (typeof value !== "string" || value.length === 0 || value.length > MAX_MAILBOX_TIMESTAMP_CHARS) {
+        throw new Error(`Worker agent mailbox contains an invalid message ${label}.`);
+    }
+    const parsed = new Date(value);
+    if (!Number.isFinite(parsed.getTime()) || parsed.toISOString() !== value) {
+        throw new Error(`Worker agent mailbox contains an invalid message ${label}.`);
+    }
+    return value;
+}
+function transitionTimestamp(floor) {
+    const current = new Date().toISOString();
+    return Date.parse(current) < Date.parse(floor) ? floor : current;
+}
+function parseReplyReceiptFields(receipt, label) {
+    if (typeof receipt.replyMessageId !== "string" ||
+        !receipt.replyMessageId ||
+        receipt.replyMessageId.length > MAX_MAILBOX_MESSAGE_ID_CHARS ||
+        typeof receipt.requestSenderId !== "string" ||
+        !receipt.requestSenderId ||
+        receipt.requestSenderId.length > MAX_MAILBOX_IDENTITY_CHARS ||
+        typeof receipt.contentDigest !== "string" ||
+        !CONTENT_DIGEST_PATTERN.test(receipt.contentDigest)) {
+        throw new Error(`Worker agent mailbox contains invalid ${label}.`);
+    }
+    return {
+        replyMessageId: receipt.replyMessageId,
+        requestSenderId: receipt.requestSenderId,
+        contentDigest: receipt.contentDigest,
+    };
+}
 function parseState(raw, parentSessionId, agentId) {
     let candidate;
     try {
@@ -46,6 +162,42 @@ function parseState(raw, parentSessionId, agentId) {
         throw new Error("Worker agent mailbox identity conflicts with the requested logical worker.");
     }
     const messages = state.messages.map((message) => {
+        let task;
+        let replyReceipt;
+        if (message?.task !== undefined) {
+            if (!message.task || typeof message.task !== "object" || Array.isArray(message.task)) {
+                throw new Error("Worker agent mailbox contains invalid task-bearing message metadata.");
+            }
+            const taskRecord = message.task;
+            if (taskRecord.kind === "agent_turn" &&
+                Object.keys(taskRecord).every((field) => field === "kind" || field === "dependsOnTaskIds")) {
+                const dependsOnTaskIds = normalizeWorkerAgentDependencyTaskIds(taskRecord.dependsOnTaskIds);
+                task = {
+                    kind: "agent_turn",
+                    ...(dependsOnTaskIds.length > 0 ? { dependsOnTaskIds } : {}),
+                };
+            }
+            else if (taskRecord.kind === "terminal_handoff" &&
+                typeof taskRecord.sourceAttemptId === "string" &&
+                taskRecord.sourceAttemptId.length > 0 &&
+                taskRecord.sourceAttemptId.length <= MAX_MAILBOX_IDENTITY_CHARS &&
+                Object.keys(taskRecord).every((field) => field === "kind" || field === "sourceAttemptId")) {
+                task = { kind: "terminal_handoff", sourceAttemptId: taskRecord.sourceAttemptId };
+            }
+            else {
+                throw new Error("Worker agent mailbox contains invalid task-bearing message metadata.");
+            }
+        }
+        if (message?.replyReceipt !== undefined) {
+            if (!message.replyReceipt || typeof message.replyReceipt !== "object" || Array.isArray(message.replyReceipt)) {
+                throw new Error("Worker agent mailbox contains invalid reply receipt metadata.");
+            }
+            const receipt = message.replyReceipt;
+            if (!Object.keys(receipt).every((field) => field === "replyMessageId" || field === "requestSenderId" || field === "contentDigest")) {
+                throw new Error("Worker agent mailbox contains invalid reply receipt metadata.");
+            }
+            replyReceipt = parseReplyReceiptFields(receipt, "reply receipt metadata");
+        }
         if (!message ||
             typeof message !== "object" ||
             Array.isArray(message) ||
@@ -79,17 +231,192 @@ function parseState(raw, parentSessionId, agentId) {
             (message.repliedAt !== undefined &&
                 (typeof message.repliedAt !== "string" ||
                     message.repliedAt.length === 0 ||
-                    message.repliedAt.length > MAX_MAILBOX_TIMESTAMP_CHARS))) {
+                    message.repliedAt.length > MAX_MAILBOX_TIMESTAMP_CHARS)) ||
+            (message.failedAt !== undefined &&
+                (typeof message.failedAt !== "string" ||
+                    message.failedAt.length === 0 ||
+                    message.failedAt.length > MAX_MAILBOX_TIMESTAMP_CHARS)) ||
+            (message.failureReason !== undefined &&
+                (typeof message.failureReason !== "string" ||
+                    message.failureReason.length === 0 ||
+                    message.failureReason.length > MAX_MAILBOX_IDENTITY_CHARS))) {
             throw new Error("Worker agent mailbox contains an invalid message.");
         }
-        return { ...message };
+        const createdAt = requiredMailboxTimestamp(message.createdAt, "creation timestamp");
+        const deliveredAt = message.deliveredAt === undefined
+            ? undefined
+            : requiredMailboxTimestamp(message.deliveredAt, "delivery timestamp");
+        const repliedAt = message.repliedAt === undefined ? undefined : requiredMailboxTimestamp(message.repliedAt, "reply timestamp");
+        const failedAt = message.failedAt === undefined ? undefined : requiredMailboxTimestamp(message.failedAt, "failure timestamp");
+        if (deliveredAt !== undefined && Date.parse(deliveredAt) < Date.parse(createdAt)) {
+            throw new Error("Worker agent mailbox message delivery timestamp predates creation.");
+        }
+        if (repliedAt !== undefined && deliveredAt === undefined) {
+            throw new Error("Worker agent mailbox message reply timestamp has no delivery timestamp.");
+        }
+        if (repliedAt !== undefined && deliveredAt !== undefined && Date.parse(repliedAt) < Date.parse(deliveredAt)) {
+            throw new Error("Worker agent mailbox message reply timestamp predates delivery.");
+        }
+        if (repliedAt !== undefined && message.expectReply !== true) {
+            throw new Error("Worker agent mailbox replied message did not expect a reply.");
+        }
+        if (failedAt !== undefined && Date.parse(failedAt) < Date.parse(createdAt)) {
+            throw new Error("Worker agent mailbox message failure timestamp predates creation.");
+        }
+        if ((failedAt === undefined) !== (message.failureReason === undefined) ||
+            (failedAt !== undefined && deliveredAt !== undefined)) {
+            throw new Error("Worker agent mailbox contains invalid task failure state.");
+        }
+        if (failedAt !== undefined && (task === undefined || repliedAt !== undefined || replyReceipt !== undefined)) {
+            throw new Error("Worker agent mailbox contains invalid task failure state.");
+        }
+        if ((repliedAt === undefined) !== (replyReceipt === undefined)) {
+            throw new Error("Worker agent mailbox replied message is missing its durable reply receipt.");
+        }
+        return {
+            ...message,
+            createdAt,
+            ...(deliveredAt ? { deliveredAt } : {}),
+            ...(repliedAt ? { repliedAt } : {}),
+            ...(replyReceipt ? { replyReceipt } : {}),
+            ...(failedAt ? { failedAt, failureReason: message.failureReason } : {}),
+            ...(task ? { task } : {}),
+        };
     });
-    const pendingMessages = messages.filter((message) => message.deliveredAt === undefined);
-    if (pendingMessages.length > MAX_MAILBOX_MESSAGES)
+    if (new Set(messages.map((message) => message.messageId)).size !== messages.length) {
+        throw new Error("Worker agent mailbox contains duplicate message identities.");
+    }
+    const pendingMessages = messages.filter(isPendingMessage);
+    if (pendingMessages.filter((message) => !hasExternalReplayAuthority(message)).length > MAX_MAILBOX_MESSAGES)
         throw new Error("Worker agent mailbox exceeds its pending-message bound.");
+    if (pendingMessages.filter(hasExternalReplayAuthority).length > MAX_MAILBOX_MESSAGES) {
+        throw new Error("Worker agent mailbox exceeds its mandatory pending-message bound.");
+    }
     if (messages.length > MAX_MAILBOX_RETAINED_MESSAGES)
         throw new Error("Worker agent mailbox exceeds its retained-message bound.");
-    return { version: 1, parentSessionId, agentId, messages };
+    if (messages.filter(usesMandatoryRetainedReserve).length > MAX_MANDATORY_RETAINED_MESSAGES) {
+        throw new Error("Worker agent mailbox exceeds its mandatory retained-message reserve.");
+    }
+    if (messages.filter((message) => !usesMandatoryRetainedReserve(message)).length > MAX_ORDINARY_RETAINED_MESSAGES) {
+        throw new Error("Worker agent mailbox exceeds its ordinary retained-message bound.");
+    }
+    if (state.replyAcknowledgements !== undefined && !Array.isArray(state.replyAcknowledgements)) {
+        throw new Error("Worker agent mailbox contains invalid reply acknowledgement state.");
+    }
+    const messagesById = new Map(messages.map((message) => [message.messageId, message]));
+    const acknowledgedMessageIds = new Set();
+    const acknowledgementIds = new Set();
+    const replyAcknowledgements = (state.replyAcknowledgements ?? []).map((acknowledgement) => {
+        if (!acknowledgement ||
+            typeof acknowledgement !== "object" ||
+            Array.isArray(acknowledgement) ||
+            typeof acknowledgement.messageId !== "string" ||
+            acknowledgement.messageId.length === 0 ||
+            acknowledgement.messageId.length > MAX_MAILBOX_MESSAGE_ID_CHARS ||
+            typeof acknowledgement.acknowledgementId !== "string" ||
+            acknowledgement.acknowledgementId.length === 0 ||
+            acknowledgement.acknowledgementId.length > MAX_MAILBOX_MESSAGE_ID_CHARS ||
+            typeof acknowledgement.replyContent !== "string" ||
+            acknowledgement.replyContent.length === 0 ||
+            acknowledgement.replyContent.length > MAX_MAILBOX_MESSAGE_CHARS ||
+            acknowledgement.replyContent.trim() !== acknowledgement.replyContent ||
+            acknowledgedMessageIds.has(acknowledgement.messageId) ||
+            acknowledgementIds.has(acknowledgement.acknowledgementId)) {
+            throw new Error("Worker agent mailbox contains invalid reply acknowledgement state.");
+        }
+        const message = messagesById.get(acknowledgement.messageId);
+        if (!message ||
+            message.deliveredAt === undefined ||
+            message.expectReply !== true ||
+            message.repliedAt === undefined ||
+            message.replyReceipt?.replyMessageId !== acknowledgement.acknowledgementId ||
+            message.replyReceipt.contentDigest !== replyIntentDigest(acknowledgement.replyContent)) {
+            throw new Error("Worker agent mailbox reply acknowledgement does not reference a retained request.");
+        }
+        acknowledgedMessageIds.add(acknowledgement.messageId);
+        acknowledgementIds.add(acknowledgement.acknowledgementId);
+        return {
+            messageId: acknowledgement.messageId,
+            acknowledgementId: acknowledgement.acknowledgementId,
+            replyContent: acknowledgement.replyContent,
+        };
+    });
+    if (state.replayReceipts !== undefined && !Array.isArray(state.replayReceipts)) {
+        throw new Error("Worker agent mailbox contains invalid replay receipt state.");
+    }
+    const replayIdentities = new Set();
+    const replyMessageIds = new Set();
+    const replayReceipts = (state.replayReceipts ?? []).map((receipt) => {
+        if (!receipt ||
+            typeof receipt !== "object" ||
+            Array.isArray(receipt) ||
+            typeof receipt.messageId !== "string" ||
+            !receipt.messageId ||
+            receipt.messageId.length > MAX_MAILBOX_MESSAGE_ID_CHARS) {
+            throw new Error("Worker agent mailbox contains invalid replay receipt state.");
+        }
+        const replayIdentity = `${String(receipt.kind)}:${receipt.messageId}`;
+        if (replayIdentities.has(replayIdentity)) {
+            throw new Error("Worker agent mailbox contains duplicate replay receipt identities.");
+        }
+        replayIdentities.add(replayIdentity);
+        if (receipt.kind === "control") {
+            if (typeof receipt.intentDigest !== "string" ||
+                !CONTENT_DIGEST_PATTERN.test(receipt.intentDigest) ||
+                !Object.keys(receipt).every((field) => field === "kind" || field === "messageId" || field === "intentDigest" || field === "deliveredAt")) {
+                throw new Error("Worker agent mailbox contains invalid control replay receipt state.");
+            }
+            const deliveredAt = receipt.deliveredAt === undefined
+                ? undefined
+                : requiredMailboxTimestamp(receipt.deliveredAt, "replay delivery timestamp");
+            return controlReplayReceipt(receipt.messageId, receipt.intentDigest, deliveredAt);
+        }
+        if (receipt.kind !== "reply" ||
+            !Object.keys(receipt).every((field) => field === "kind" ||
+                field === "messageId" ||
+                field === "replyMessageId" ||
+                field === "requestSenderId" ||
+                field === "contentDigest")) {
+            throw new Error("Worker agent mailbox contains invalid reply replay receipt state.");
+        }
+        const replyReceipt = parseReplyReceiptFields(receipt, "reply replay receipt state");
+        if (replyMessageIds.has(replyReceipt.replyMessageId)) {
+            throw new Error("Worker agent mailbox contains duplicate reply replay identities.");
+        }
+        replyMessageIds.add(replyReceipt.replyMessageId);
+        return {
+            kind: "reply",
+            messageId: receipt.messageId,
+            ...replyReceipt,
+        };
+    });
+    if (replayReceipts.length > MAX_MAILBOX_REPLAY_RECEIPTS) {
+        throw new Error("Worker agent mailbox exceeds its replay receipt bound.");
+    }
+    if (replayReceipts.filter((receipt) => receipt.kind === "control").length > MAX_REPLAY_EVIDENCE_SLOTS) {
+        throw new Error("Worker agent mailbox exceeds its control replay receipt bound.");
+    }
+    if (replayReceipts.length +
+        messages.filter((message) => message.expectReply === true && message.repliedAt === undefined).length >
+        MAX_MAILBOX_REPLAY_RECEIPTS) {
+        throw new Error("Worker agent mailbox exceeds its projected replay evidence bound.");
+    }
+    for (const message of messages) {
+        const controlReceipt = controlReplayReceiptFor(replayReceipts, message.messageId);
+        if (controlReceipt && controlReceipt.deliveredAt !== message.deliveredAt) {
+            throw new Error("Worker agent mailbox control delivery conflicts with its durable replay receipt.");
+        }
+        if (message.replyReceipt) {
+            const replyReceipt = replyReplayReceiptFor(replayReceipts, message.messageId);
+            if (!replyReceipt ||
+                replyReceipt.replyMessageId !== message.replyReceipt.replyMessageId ||
+                replyReceipt.requestSenderId !== message.replyReceipt.requestSenderId ||
+                replyReceipt.contentDigest !== message.replyReceipt.contentDigest) {
+                throw new Error("Worker agent mailbox reply conflicts with its durable replay receipt.");
+            }
+        }
+    }
+    return { version: 1, parentSessionId, agentId, messages, replyAcknowledgements, replayReceipts };
 }
 function normalizeOptionalIdentity(value, label) {
     if (value === undefined)
@@ -100,17 +427,135 @@ function normalizeOptionalIdentity(value, label) {
     }
     return normalized;
 }
-function pruneDeliveredHistory(messages) {
-    const pending = messages.filter((message) => message.deliveredAt === undefined);
-    const awaitingReply = messages.filter((message) => message.deliveredAt !== undefined && message.expectReply === true && message.repliedAt === undefined);
-    const retainedIds = new Set([...pending, ...awaitingReply].map((message) => message.messageId));
-    const remainingSlots = Math.max(0, MAX_MAILBOX_RETAINED_MESSAGES - retainedIds.size);
-    const deliveredCandidates = messages.filter((message) => message.deliveredAt !== undefined && !retainedIds.has(message.messageId));
-    const recentDelivered = remainingSlots > 0 ? deliveredCandidates.slice(-remainingSlots) : [];
-    return [...pending, ...awaitingReply, ...recentDelivered].sort((left, right) => left.createdAt.localeCompare(right.createdAt));
+export function normalizeWorkerAgentDependencyTaskIds(value) {
+    return parseBoundedStringArray(value === undefined ? [] : value, {
+        maxEntries: MAX_ORCHESTRATION_COLLECTION_LENGTH,
+        maxLength: MAX_ORCHESTRATION_IDENTIFIER_LENGTH,
+        trim: true,
+        invalidMessage: "Worker dependency task ids must contain bounded, non-empty strings.",
+        duplicateMessage: "Worker dependency task ids must contain unique strings.",
+        createError: (message) => new TypeError(message),
+    });
+}
+function normalizeTaskMetadata(task) {
+    if (task === undefined)
+        return undefined;
+    if (task.kind === "agent_turn") {
+        const dependsOnTaskIds = normalizeWorkerAgentDependencyTaskIds(task.dependsOnTaskIds);
+        return {
+            kind: "agent_turn",
+            ...(dependsOnTaskIds.length > 0 ? { dependsOnTaskIds } : {}),
+        };
+    }
+    const sourceAttemptId = normalizeOptionalIdentity(task.sourceAttemptId, "terminal source attempt id");
+    if (!sourceAttemptId)
+        throw new TypeError("Worker terminal source attempt id is invalid.");
+    return { kind: "terminal_handoff", sourceAttemptId };
+}
+function sameTaskMetadata(left, right) {
+    if (left?.kind !== right?.kind)
+        return false;
+    if (left?.kind === "agent_turn" && right?.kind === "agent_turn") {
+        const leftDependencies = left.dependsOnTaskIds ?? [];
+        const rightDependencies = right.dependsOnTaskIds ?? [];
+        return (leftDependencies.length === rightDependencies.length &&
+            leftDependencies.every((dependencyId, index) => dependencyId === rightDependencies[index]));
+    }
+    if (left?.kind === "terminal_handoff" && right?.kind === "terminal_handoff") {
+        return left.sourceAttemptId === right.sourceAttemptId;
+    }
+    return true;
+}
+function hasExternalReplayAuthority(message) {
+    return message.replyToMessageId !== undefined || message.task?.kind === "terminal_handoff";
+}
+function isPendingMessage(message) {
+    return message.deliveredAt === undefined && message.failedAt === undefined;
+}
+function usesMandatoryRetainedReserve(message) {
+    return isPendingMessage(message) && hasExternalReplayAuthority(message);
+}
+function projectedReplayEvidenceSlots(state) {
+    return (state.replayReceipts.length +
+        state.messages.filter((message) => message.expectReply === true && message.repliedAt === undefined).length);
+}
+function normalizeReplyAcknowledgement(messageId, acknowledgementId) {
+    const normalizedMessageId = messageId.trim();
+    if (!normalizedMessageId || normalizedMessageId.length > MAX_MAILBOX_MESSAGE_ID_CHARS) {
+        throw new TypeError("A worker control message id is invalid.");
+    }
+    const normalizedAcknowledgementId = acknowledgementId.trim();
+    if (!normalizedAcknowledgementId || normalizedAcknowledgementId.length > MAX_MAILBOX_MESSAGE_ID_CHARS) {
+        throw new TypeError("A worker reply acknowledgement id is invalid.");
+    }
+    return { messageId: normalizedMessageId, acknowledgementId: normalizedAcknowledgementId };
+}
+function normalizeReplyContent(replyContent) {
+    const normalized = replyContent.trim();
+    if (!normalized || normalized.length > MAX_MAILBOX_MESSAGE_CHARS) {
+        throw new TypeError(`Worker reply content must contain from 1 through ${MAX_MAILBOX_MESSAGE_CHARS.toLocaleString("en-US")} characters.`);
+    }
+    return normalized;
+}
+function pruneDeliveredHistory(parentSessionId, agentId, messages, replyAcknowledgements, replayReceipts, ordinaryAdmission) {
+    const protectedReplyIds = new Set(replyAcknowledgements.map((acknowledgement) => acknowledgement.messageId));
+    const protectedMessages = messages.filter((message) => isPendingMessage(message) ||
+        (message.expectReply === true && message.repliedAt === undefined) ||
+        protectedReplyIds.has(message.messageId));
+    const protectedMandatory = protectedMessages.filter(usesMandatoryRetainedReserve);
+    const protectedOrdinary = protectedMessages.filter((message) => !usesMandatoryRetainedReserve(message));
+    if (protectedMandatory.length > MAX_MANDATORY_RETAINED_MESSAGES) {
+        throw new Error("Worker agent mailbox mandatory retained-message reserve is exhausted.");
+    }
+    if (protectedOrdinary.length > MAX_ORDINARY_RETAINED_MESSAGES) {
+        throw new Error("Worker agent mailbox ordinary retained-message capacity is exhausted.");
+    }
+    const retainedIds = new Set(protectedMessages.map((message) => message.messageId));
+    const deliveredCandidates = messages.filter((message) => (message.deliveredAt !== undefined || message.failedAt !== undefined) && !retainedIds.has(message.messageId));
+    const remainingOrdinarySlots = MAX_ORDINARY_RETAINED_MESSAGES - protectedOrdinary.length;
+    const recentDelivered = remainingOrdinarySlots > 0 ? deliveredCandidates.slice(-remainingOrdinarySlots) : [];
+    let retained = [...protectedMessages, ...recentDelivered].sort((left, right) => left.createdAt.localeCompare(right.createdAt));
+    const retainedReplayReceipts = [...replayReceipts];
+    while (true) {
+        const state = {
+            version: 1,
+            parentSessionId,
+            agentId,
+            messages: retained,
+            replyAcknowledgements: [...replyAcknowledgements],
+            replayReceipts: retainedReplayReceipts,
+        };
+        const encodedBytes = ordinaryAdmission ? ordinaryAdmissionEncodedBytes(state) : encodedStateBytes(state);
+        const encodedLimit = ordinaryAdmission ? MAX_ORDINARY_MAILBOX_BYTES : MAX_MAILBOX_BYTES;
+        if (encodedBytes <= encodedLimit)
+            break;
+        const oldestCompletedIndex = retained.findIndex((message) => !retainedIds.has(message.messageId));
+        if (oldestCompletedIndex >= 0) {
+            retained = retained.filter((_, index) => index !== oldestCompletedIndex);
+            continue;
+        }
+        break;
+    }
+    return { messages: retained, replayReceipts: retainedReplayReceipts };
 }
 function encodedStateBytes(state) {
-    return Buffer.byteLength(JSON.stringify(state), "utf-8");
+    return Buffer.byteLength(`${JSON.stringify(state)}\n`, "utf-8");
+}
+function ordinaryAdmissionEncodedBytes(state) {
+    const projectedDeliveryIds = new Set(state.messages
+        .filter((message) => message.deliveredAt === undefined &&
+        message.failedAt === undefined &&
+        !hasExternalReplayAuthority(message))
+        .map((message) => message.messageId));
+    return encodedStateBytes({
+        ...state,
+        messages: state.messages.map((message) => projectedDeliveryIds.has(message.messageId)
+            ? { ...message, deliveredAt: MAX_MAILBOX_TRANSITION_TIMESTAMP }
+            : message),
+        replayReceipts: state.replayReceipts.map((receipt) => receipt.kind === "control" && receipt.deliveredAt === undefined && projectedDeliveryIds.has(receipt.messageId)
+            ? { ...receipt, deliveredAt: MAX_MAILBOX_TRANSITION_TIMESTAMP }
+            : receipt),
+    });
 }
 /**
  * Bounded durable inbox for a single logical worker agent.
@@ -127,6 +572,13 @@ export class WorkerAgentMailbox {
         this.file = workerAgentMailboxFile(options.agentDir, this.parentSessionId, mailboxDigest(this.parentSessionId, this.agentId));
     }
     enqueue(input) {
+        const accepted = this.enqueueWithReceipt(input);
+        if (accepted.status !== "retained")
+            throw new Error("Unkeyed worker control unexpectedly resolved as a replay.");
+        return accepted.message;
+    }
+    /** Enqueue with exact creation evidence for an idempotent surrounding acceptance flow. */
+    enqueueWithReceipt(input) {
         const content = input.content.trim();
         if (!content)
             throw new TypeError("A worker control message is required.");
@@ -136,21 +588,15 @@ export class WorkerAgentMailbox {
         const senderAgentId = normalizeOptionalIdentity(input.senderAgentId, "sender agent id");
         const threadId = normalizeOptionalIdentity(input.threadId, "thread id");
         const replyToMessageId = normalizeOptionalIdentity(input.replyToMessageId, "reply message id");
+        const task = normalizeTaskMetadata(input.task);
         const idempotencyKey = input.idempotencyKey?.trim();
-        if (input.idempotencyKey !== undefined && (!idempotencyKey || idempotencyKey.length > 2_048)) {
+        if (input.idempotencyKey !== undefined &&
+            (!idempotencyKey || idempotencyKey.length > MAX_MAILBOX_IDEMPOTENCY_KEY_CHARS)) {
             throw new TypeError("Worker control idempotency key is invalid.");
         }
         const message = {
             messageId: idempotencyKey
-                ? `worker-message-${createHash("sha256")
-                    .update("pi-worker-agent-message-v1")
-                    .update("\0")
-                    .update(this.parentSessionId)
-                    .update("\0")
-                    .update(this.agentId)
-                    .update("\0")
-                    .update(idempotencyKey)
-                    .digest("hex")}`
+                ? workerAgentMessageId(this.parentSessionId, idempotencyKey)
                 : `worker-message-${randomUUID()}`,
             kind: input.kind,
             content,
@@ -158,39 +604,93 @@ export class WorkerAgentMailbox {
             ...(threadId ? { threadId } : {}),
             ...(replyToMessageId ? { replyToMessageId } : {}),
             ...(input.expectReply === true ? { expectReply: true } : {}),
+            ...(task ? { task } : {}),
             createdAt: new Date().toISOString(),
         };
+        const intentDigest = idempotencyKey ? controlIntentDigest(message) : undefined;
+        const externallyReplayOwned = hasExternalReplayAuthority(message);
         let queued = message;
         let created = false;
+        let completedReplay = false;
         this.update((state) => {
             const existing = state.messages.find((candidate) => candidate.messageId === message.messageId);
+            const replayReceipt = controlReplayReceiptFor(state.replayReceipts, message.messageId);
+            const addsControlReceipt = intentDigest !== undefined && !externallyReplayOwned && replayReceipt === undefined;
+            if (addsControlReceipt &&
+                state.replayReceipts.filter((receipt) => receipt.kind === "control").length >= MAX_REPLAY_EVIDENCE_SLOTS) {
+                throw new Error(`Worker agent mailbox control replay receipt capacity reached its ${MAX_REPLAY_EVIDENCE_SLOTS} entry limit.`);
+            }
             if (existing) {
-                const sameIntent = existing.kind === message.kind &&
-                    existing.content === message.content &&
+                // `kind` is the delivery-mode projection at first acceptance. It is deliberately not
+                // part of task intent and is never rewritten when a retry observes a different live
+                // activity state. The durable `task` identity owns whether an idle turn is required.
+                const sameIntent = existing.content === message.content &&
                     existing.senderAgentId === message.senderAgentId &&
                     existing.threadId === message.threadId &&
                     existing.replyToMessageId === message.replyToMessageId &&
-                    existing.expectReply === message.expectReply;
+                    existing.expectReply === message.expectReply &&
+                    sameTaskMetadata(existing.task, message.task);
                 if (!sameIntent)
                     throw new Error("Worker control idempotency identity conflicts with an existing message.");
+                if (intentDigest && replayReceipt && replayReceipt.intentDigest !== intentDigest) {
+                    throw new Error("Worker control idempotency identity conflicts with its durable replay receipt.");
+                }
                 queued = existing;
+                return intentDigest && !externallyReplayOwned && !replayReceipt
+                    ? {
+                        ...state,
+                        replayReceipts: [
+                            ...state.replayReceipts,
+                            controlReplayReceipt(message.messageId, intentDigest, existing.deliveredAt),
+                        ],
+                    }
+                    : state;
+            }
+            if (replayReceipt) {
+                if (!intentDigest || replayReceipt.intentDigest !== intentDigest) {
+                    throw new Error("Worker control idempotency identity conflicts with its durable replay receipt.");
+                }
+                completedReplay = true;
                 return state;
             }
-            if (state.messages.filter((candidate) => candidate.deliveredAt === undefined).length >= MAX_MAILBOX_MESSAGES) {
-                throw new Error(`Worker agent mailbox reached its ${MAX_MAILBOX_MESSAGES} message limit.`);
+            const pending = state.messages.filter((candidate) => candidate.deliveredAt === undefined && candidate.failedAt === undefined);
+            if (pending.filter((candidate) => hasExternalReplayAuthority(candidate) === externallyReplayOwned).length >=
+                MAX_MAILBOX_MESSAGES) {
+                throw new Error(externallyReplayOwned
+                    ? `Worker agent mailbox reached its ${MAX_MAILBOX_MESSAGES} mandatory message limit.`
+                    : `Worker agent mailbox reached its ${MAX_MAILBOX_MESSAGES} message limit.`);
             }
             created = true;
-            return { ...state, messages: [...state.messages, message] };
-        });
+            return {
+                ...state,
+                messages: [...state.messages, message],
+                ...(intentDigest && !externallyReplayOwned
+                    ? {
+                        replayReceipts: [
+                            ...state.replayReceipts,
+                            controlReplayReceipt(message.messageId, intentDigest),
+                        ],
+                    }
+                    : {}),
+            };
+        }, !externallyReplayOwned, true);
         if (created)
             this.notify();
-        return structuredClone(queued);
+        if (completedReplay)
+            return { status: "completed_replay", messageId: message.messageId, created: false };
+        return { status: "retained", messageId: queued.messageId, message: structuredClone(queued), created };
     }
     pending(kind) {
         return this.read()
-            .messages.filter((message) => message.deliveredAt === undefined && (kind === undefined || message.kind === kind))
+            .messages.filter((message) => message.deliveredAt === undefined &&
+            message.failedAt === undefined &&
+            (kind === undefined || message.kind === kind))
             .map((message) => structuredClone(message));
     }
+    /** Oldest-first executable intents that have not reached the durable transcript boundary. */
+    pendingTaskBearing() {
+        return this.pending().filter((message) => message.task !== undefined);
+    }
     acknowledgeDelivered(messageId) {
         this.markTimestamp(messageId, "deliveredAt");
     }
@@ -206,8 +706,154 @@ export class WorkerAgentMailbox {
         const message = this.read().messages.find((candidate) => candidate.messageId === normalized);
         return message ? structuredClone(message) : undefined;
     }
-    markReplied(messageId) {
-        return this.markTimestamp(messageId, "repliedAt");
+    hasControlReplayReceipt(messageId) {
+        const normalized = messageId.trim();
+        if (!normalized)
+            throw new TypeError("A worker control message id is required.");
+        return controlReplayReceiptFor(this.read().replayReceipts, normalized) !== undefined;
+    }
+    hasDeliveredControlReceipt(messageId) {
+        const normalized = messageId.trim();
+        if (!normalized)
+            throw new TypeError("A worker control message id is required.");
+        const state = this.read();
+        const message = state.messages.find((candidate) => candidate.messageId === normalized);
+        return (message?.deliveredAt !== undefined ||
+            controlReplayReceiptFor(state.replayReceipts, normalized)?.deliveredAt !== undefined);
+    }
+    resolveCompletedReply(messageId, content) {
+        const normalized = messageId.trim();
+        if (!normalized)
+            throw new TypeError("A worker control message id is required.");
+        const normalizedContent = normalizeReplyContent(content);
+        const state = this.read();
+        const request = state.messages.find((candidate) => candidate.messageId === normalized);
+        const receipt = request?.replyReceipt ?? replyReplayReceiptFor(state.replayReceipts, normalized);
+        if (!receipt)
+            return undefined;
+        if (receipt.contentDigest !== replyIntentDigest(normalizedContent)) {
+            throw new Error("Worker reply identity conflicts with its durable source receipt.");
+        }
+        return {
+            replyMessageId: receipt.replyMessageId,
+            requestSenderId: receipt.requestSenderId,
+            contentDigest: receipt.contentDigest,
+        };
+    }
+    getReplyAcknowledgementId(messageId) {
+        const normalized = messageId.trim();
+        if (!normalized)
+            throw new TypeError("A worker control message id is required.");
+        return this.read().replyAcknowledgements.find((acknowledgement) => acknowledgement.messageId === normalized)
+            ?.acknowledgementId;
+    }
+    listReplyAcknowledgements() {
+        return this.read().replyAcknowledgements.map((acknowledgement) => ({ ...acknowledgement }));
+    }
+    /**
+     * Mark one request replied while retaining the exact target receipt until transcript consumption.
+     * The acknowledgement id is the durable target reply id, so a retry adopts a crash-left marker.
+     */
+    beginReplyAcknowledgement(messageId, acknowledgementId, replyContent) {
+        const normalized = normalizeReplyAcknowledgement(messageId, acknowledgementId);
+        const normalizedContent = normalizeReplyContent(replyContent);
+        const contentDigest = replyIntentDigest(normalizedContent);
+        let acquired = false;
+        let changed = false;
+        this.update((state) => {
+            const request = state.messages.find((message) => message.messageId === normalized.messageId);
+            if (!request || request.deliveredAt === undefined || request.expectReply !== true)
+                return state;
+            if (!request.senderAgentId) {
+                throw new Error("Worker reply request has no routable requester.");
+            }
+            const receipt = {
+                replyMessageId: normalized.acknowledgementId,
+                requestSenderId: request.senderAgentId,
+                contentDigest,
+            };
+            const durableReceipt = replyReplayReceiptFor(state.replayReceipts, normalized.messageId);
+            if (durableReceipt &&
+                (durableReceipt.replyMessageId !== receipt.replyMessageId ||
+                    durableReceipt.requestSenderId !== receipt.requestSenderId ||
+                    durableReceipt.contentDigest !== receipt.contentDigest)) {
+                throw new Error("Worker reply identity conflicts with its durable replay receipt.");
+            }
+            const existing = state.replyAcknowledgements.find((acknowledgement) => acknowledgement.messageId === normalized.messageId ||
+                acknowledgement.acknowledgementId === normalized.acknowledgementId);
+            if (existing) {
+                if (existing.messageId !== normalized.messageId ||
+                    existing.acknowledgementId !== normalized.acknowledgementId) {
+                    throw new Error("Worker reply acknowledgement identity conflicts with an active transaction.");
+                }
+                if (request?.replyReceipt?.replyMessageId !== receipt.replyMessageId ||
+                    request.replyReceipt.requestSenderId !== receipt.requestSenderId ||
+                    request.replyReceipt.contentDigest !== receipt.contentDigest ||
+                    existing.replyContent !== normalizedContent) {
+                    throw new Error("Worker reply content conflicts with its active acknowledgement transaction.");
+                }
+                acquired = true;
+                return state;
+            }
+            if (request.repliedAt !== undefined)
+                return state;
+            acquired = true;
+            changed = true;
+            return {
+                ...state,
+                messages: state.messages.map((message) => message.messageId === normalized.messageId
+                    ? {
+                        ...message,
+                        repliedAt: transitionTimestamp(message.deliveredAt ?? message.createdAt),
+                        replyReceipt: receipt,
+                    }
+                    : message),
+                replyAcknowledgements: [...state.replyAcknowledgements, { ...normalized, replyContent: normalizedContent }],
+                replayReceipts: durableReceipt
+                    ? state.replayReceipts
+                    : [...state.replayReceipts, { kind: "reply", messageId: normalized.messageId, ...receipt }],
+            };
+        });
+        if (changed)
+            this.notify();
+        return acquired;
+    }
+    /** Dead-letter only an ordinary executable turn with no reply or terminal-delivery obligation. */
+    deadLetterOrdinaryTask(messageId, reason) {
+        const normalized = messageId.trim();
+        const failureReason = reason.trim();
+        if (!normalized)
+            throw new TypeError("A worker control message id is required.");
+        if (!failureReason || failureReason.length > MAX_MAILBOX_IDENTITY_CHARS) {
+            throw new TypeError("A worker task failure reason is invalid.");
+        }
+        let changed = false;
+        this.update((state) => ({
+            ...state,
+            messages: state.messages.map((message) => {
+                if (message.messageId !== normalized ||
+                    message.task?.kind !== "agent_turn" ||
+                    message.replyToMessageId !== undefined ||
+                    message.expectReply === true ||
+                    message.deliveredAt !== undefined ||
+                    message.failedAt !== undefined) {
+                    return message;
+                }
+                changed = true;
+                return { ...message, failedAt: transitionTimestamp(message.createdAt), failureReason };
+            }),
+        }), true);
+        if (changed)
+            this.notify();
+        return changed;
+    }
+    /** Commit one exact reply acknowledgement and release its protected history slot. */
+    commitReplyAcknowledgement(messageId, acknowledgementId) {
+        return this.finishReplyAcknowledgement(messageId, acknowledgementId, false);
+    }
+    /** Roll back one exact reply acknowledgement without clearing a later or unrelated reply. */
+    rollbackReplyAcknowledgement(messageId, acknowledgementId) {
+        return this.finishReplyAcknowledgement(messageId, acknowledgementId, true);
     }
     markTimestamp(messageId, field) {
         const normalized = messageId.trim();
@@ -215,13 +861,56 @@ export class WorkerAgentMailbox {
             throw new TypeError("A worker control message id is required.");
         let changed = false;
         this.update((state) => {
+            let deliveredAt;
             const messages = state.messages.map((message) => {
-                if (message.messageId !== normalized || message[field] !== undefined)
+                if (message.messageId !== normalized || message[field] !== undefined || message.failedAt !== undefined) {
                     return message;
+                }
                 changed = true;
-                return { ...message, [field]: new Date().toISOString() };
+                deliveredAt = transitionTimestamp(message.createdAt);
+                return { ...message, [field]: deliveredAt };
             });
-            return changed ? { ...state, messages: pruneDeliveredHistory(messages) } : state;
+            if (!changed || !deliveredAt)
+                return state;
+            return {
+                ...state,
+                messages,
+                replayReceipts: state.replayReceipts.map((receipt) => receipt.kind === "control" && receipt.messageId === normalized ? { ...receipt, deliveredAt } : receipt),
+            };
+        });
+        if (changed)
+            this.notify();
+        return changed;
+    }
+    finishReplyAcknowledgement(messageId, acknowledgementId, rollback) {
+        const normalized = normalizeReplyAcknowledgement(messageId, acknowledgementId);
+        let changed = false;
+        this.update((state) => {
+            const acknowledgement = state.replyAcknowledgements.find((candidate) => candidate.messageId === normalized.messageId &&
+                candidate.acknowledgementId === normalized.acknowledgementId);
+            if (!acknowledgement)
+                return state;
+            changed = true;
+            const messages = rollback
+                ? state.messages.map((message) => {
+                    if (message.messageId !== normalized.messageId || message.repliedAt === undefined)
+                        return message;
+                    const restored = { ...message };
+                    delete restored.repliedAt;
+                    delete restored.replyReceipt;
+                    return restored;
+                })
+                : state.messages;
+            return {
+                ...state,
+                messages,
+                replyAcknowledgements: state.replyAcknowledgements.filter((candidate) => candidate !== acknowledgement),
+                ...(rollback
+                    ? {
+                        replayReceipts: state.replayReceipts.filter((receipt) => receipt.kind !== "reply" || receipt.messageId !== normalized.messageId),
+                    }
+                    : {}),
+            };
         });
         if (changed)
             this.notify();
@@ -232,24 +921,65 @@ export class WorkerAgentMailbox {
         return () => this.listeners.delete(listener);
     }
     notify() {
-        for (const listener of this.listeners)
-            listener();
+        for (const listener of this.listeners) {
+            try {
+                listener();
+            }
+            catch {
+                // Mailbox subscribers are advisory; durable mutation results remain authoritative.
+            }
+        }
     }
     read() {
         if (!existsSync(this.file)) {
-            return { version: 1, parentSessionId: this.parentSessionId, agentId: this.agentId, messages: [] };
+            return {
+                version: 1,
+                parentSessionId: this.parentSessionId,
+                agentId: this.agentId,
+                messages: [],
+                replyAcknowledgements: [],
+                replayReceipts: [],
+            };
         }
         return parseState(readBoundedTextFileSync(this.file, MAX_MAILBOX_BYTES, "Worker agent mailbox durable size bound"), this.parentSessionId, this.agentId);
     }
-    update(mutator) {
+    update(mutator, ordinaryAdmission = false, replayEvidenceAdmission = false) {
         withFileLockSync(this.file, () => {
             const state = this.read();
+            const previousOrdinaryBytes = ordinaryAdmissionEncodedBytes(state);
+            const previousReplayEvidenceSlots = projectedReplayEvidenceSlots(state);
             const mutated = mutator(state);
-            const next = { ...mutated, messages: pruneDeliveredHistory(mutated.messages) };
-            if (next.messages.length > MAX_MAILBOX_RETAINED_MESSAGES || encodedStateBytes(next) > MAX_MAILBOX_BYTES) {
-                throw new Error("Worker agent mailbox exceeds its durable size bound.");
+            const retained = pruneDeliveredHistory(this.parentSessionId, this.agentId, mutated.messages, mutated.replyAcknowledgements, mutated.replayReceipts, ordinaryAdmission);
+            const next = {
+                ...mutated,
+                messages: retained.messages,
+                replayReceipts: retained.replayReceipts,
+            };
+            const addedReplayReceipt = mutated.replayReceipts.length > state.replayReceipts.length;
+            const bytesWithoutAddedReceipt = addedReplayReceipt
+                ? encodedStateBytes({ ...next, replayReceipts: next.replayReceipts.slice(0, -1) })
+                : undefined;
+            const changed = JSON.stringify(next) !== JSON.stringify(state);
+            const nextOrdinaryBytes = ordinaryAdmissionEncodedBytes(next);
+            if (ordinaryAdmission &&
+                changed &&
+                nextOrdinaryBytes > MAX_ORDINARY_MAILBOX_BYTES &&
+                nextOrdinaryBytes > previousOrdinaryBytes) {
+                throw new Error(addedReplayReceipt
+                    ? "Worker agent mailbox replay receipt storage exhausted its mandatory control byte reserve."
+                    : "Worker agent mailbox passive control storage exhausted its mandatory control byte reserve.");
+            }
+            const nextReplayEvidenceSlots = projectedReplayEvidenceSlots(next);
+            if (nextReplayEvidenceSlots > MAX_MAILBOX_REPLAY_RECEIPTS) {
+                throw new Error("Worker agent mailbox exceeds its projected replay evidence bound.");
+            }
+            if (replayEvidenceAdmission &&
+                nextReplayEvidenceSlots > MAX_REPLAY_EVIDENCE_SLOTS &&
+                nextReplayEvidenceSlots > previousReplayEvidenceSlots) {
+                throw new Error(`Worker agent mailbox replay evidence capacity reached its ${MAX_REPLAY_EVIDENCE_SLOTS} slot limit.`);
             }
-            if (JSON.stringify(next) !== JSON.stringify(state))
+            assertWorkerAgentMailboxBounds(next.messages.length, next.replayReceipts.length, state.replayReceipts.length, encodedStateBytes(next), bytesWithoutAddedReceipt);
+            if (changed)
                 writeFileAtomicSync(this.file, `${JSON.stringify(next)}\n`, { mode: 0o600 });
         });
     }