maka-agent 0.2.0-dev.3.20260830 → 0.2.0-dev.31.20260913

package/node_modules/@maka/runtime-host/dist/server/message-coordinator.js

@@ -16,14 +16,19 @@
  * specific language governing permissions and limitations
  * under the License.
  */
-import { randomUUID } from 'node:crypto';
+import { createHash, randomUUID } from 'node:crypto';
 import { isDeepStrictEqual } from 'node:util';
 import { aggregateMessageContents, messageContentDigest, messageContentsEqual, normalizeMessageContent, } from '@maka/core/events';
 import { RuntimeMessageAuthorityInvariantError, } from '@maka/runtime/message-authority';
-import { normalizeRootTurnAdmissionPayload, submittedTurnIntentsEqual, } from '@maka/storage/execution-stores';
+import { normalizeRootTurnAdmissionPayload, rootTurnAdmissionRecordFits, submittedTurnIntentsEqual, } from '@maka/storage/execution-stores';
 import { MESSAGE_QUEUE_MAX_ENTRIES, MESSAGE_QUEUE_PROJECTION_MAX_BYTES, MESSAGE_OPERATION_RESULT_MAX_BYTES, MESSAGE_OPERATION_SPECS, } from '../protocol/index.js';
 import { worstCaseFailedTurnSnapshot } from './canonical-turn-snapshot.js';
 import { worstCaseMessageQueueProjection } from './message-queue-capacity.js';
+const EMPTY_SKILL_INVOCATION = {
+    loaded: [],
+    failed: [],
+    receipts: [],
+};
 /**
  * How many times a submit re-runs admission after its preflight snapshot went
  * stale. Steering consumption (pull/ack/nack) happens outside the admission
@@ -105,42 +110,131 @@ export class HostMessageCoordinator {
     async queryMessageExecutions(input) {
         const resolutions = [];
         for (const messageId of input.messageIds) {
-            const receipt = await this.#durableProof.readRootTurnSourceMessageReceipt(input.sessionId, messageId);
-            if (receipt?.admission.sessionId === input.sessionId &&
-                receipt.sourceMessage.messageId === messageId) {
-                // A root source receipt is the latest durable ownership proof and
-                // therefore outranks the steering location from which a Message may
-                // have been folded into this successor.
-                resolutions.push({
-                    messageId,
-                    state: 'owned',
-                    turnId: receipt.admission.turnId,
-                    runId: receipt.admission.runId,
+            const disposition = await this.#resolveMessageExecution(input.sessionId, messageId);
+            if (disposition.kind === 'owned_root' || disposition.kind === 'shared_turn') {
+                // This read projects current execution, including safe-boundary
+                // continuations. The Message's durable admission ownership is unchanged.
+                const latest = await this.#root.readLatestRootTurnLineage({
+                    sessionId: input.sessionId,
+                    turnId: disposition.turnId,
+                    runId: disposition.runId,
                 });
-                continue;
-            }
-            const steering = await this.#durableProof.readImmutableSteeringMessageProof(input.sessionId, messageId);
-            if (steering?.event.sessionId === input.sessionId &&
-                steering.event.refs?.providerEventId === messageId) {
                 resolutions.push({
                     messageId,
                     state: 'owned',
-                    turnId: steering.event.turnId,
-                    runId: steering.event.runId,
+                    turnId: latest.turnId,
+                    runId: latest.runId,
                 });
                 continue;
             }
-            if (await this.#admissions.hasCancelledMessageAdmission(input.sessionId, messageId)) {
+            if (disposition.kind === 'cancelled') {
                 resolutions.push({ messageId, state: 'cancelled' });
                 continue;
             }
-            const pending = await this.#admissions.readMessageAdmission(input.sessionId, messageId);
-            if (pending?.sessionId === input.sessionId && pending.messageId === messageId) {
+            if (disposition.kind === 'pending') {
                 resolutions.push({ messageId, state: 'pending' });
             }
         }
         return success({ resolutions });
     }
+    /**
+     * Cancels exactly one durable pending Message, or returns the Turn that has
+     * already consumed it. This is the target Session's ordinary Message
+     * authority; WorkHub never edits the queue or admission tables directly.
+     *
+     * The claim identity is required: the cancellation tombstone it writes is the
+     * only proof that distinguishes this caller's own cancellation from one that
+     * had already happened, which is what makes a crash between cancelling and
+     * recording the outcome recoverable.
+     */
+    cancelMessageIfPending(sessionId, messageId, cancellationClaimId) {
+        return this.#sessionAdmission.run(sessionId, async () => {
+            const disposition = await this.#resolveMessageExecution(sessionId, messageId);
+            if (disposition.kind === 'cancelled') {
+                const outcome = await this.#admissions.claimMessageAdmissionCancellation(sessionId, messageId, cancellationClaimId);
+                return outcome === 'same_claim'
+                    ? { kind: 'cancelled_pending' }
+                    : { kind: 'cancelled' };
+            }
+            if (disposition.kind !== 'pending')
+                return disposition;
+            const state = this.#sessions.get(sessionId);
+            const inFlight = state && [...state.inFlight.values()].some((entry) => entry.messageId === messageId);
+            if (inFlight)
+                return { kind: 'recovering' };
+            const steeringIndex = state?.steering.findIndex((entry) => entry.messageId === messageId) ?? -1;
+            const followupIndex = state?.followup.findIndex((entry) => entry.messageId === messageId) ?? -1;
+            if (state?.transition &&
+                state.transition.entries.some((entry) => entry.messageId === messageId)) {
+                return { kind: 'recovering' };
+            }
+            const claimOutcome = await this.#admissions.claimMessageAdmissionCancellation(sessionId, messageId, cancellationClaimId);
+            if (state && steeringIndex >= 0) {
+                const [entry] = state.steering.splice(steeringIndex, 1);
+                if (entry)
+                    this.#releaseEntry(entry);
+                this.#mutated(state);
+                this.#maybeReclaim(sessionId, state);
+            }
+            else if (state && followupIndex >= 0) {
+                const [entry] = state.followup.splice(followupIndex, 1);
+                if (entry)
+                    this.#releaseEntry(entry);
+                this.#mutated(state);
+                this.#maybeReclaim(sessionId, state);
+            }
+            else {
+                this.#onProjectionChanged(sessionId);
+            }
+            return claimOutcome === 'already_cancelled'
+                ? { kind: 'cancelled' }
+                : { kind: 'cancelled_pending' };
+        });
+    }
+    readMessageExecutionDisposition(sessionId, messageId) {
+        return this.#sessionAdmission.run(sessionId, () => this.#resolveMessageExecution(sessionId, messageId));
+    }
+    readMessageExecutionDispositionAdmitted(sessionId, messageId, admission) {
+        return this.#sessionAdmission.runAdmitted(sessionId, admission, () => this.#resolveMessageExecution(sessionId, messageId));
+    }
+    async #resolveMessageExecution(sessionId, messageId) {
+        const receipt = await this.#durableProof.readRootTurnSourceMessageReceipt(sessionId, messageId);
+        if (receipt?.admission.sessionId === sessionId &&
+            receipt.sourceMessage.messageId === messageId) {
+            // Only a single-source admission proves that this Message created the
+            // root. Recovery may fold several steering Messages into one successor;
+            // every source in that batch shares the Turn and none may stop it alone.
+            if (receipt.admission.sourceMessages.length !== 1 ||
+                receipt.admission.userMessageId === null) {
+                return {
+                    kind: 'shared_turn',
+                    turnId: receipt.admission.turnId,
+                    runId: receipt.admission.runId,
+                };
+            }
+            return {
+                kind: 'owned_root',
+                turnId: receipt.admission.turnId,
+                runId: receipt.admission.runId,
+            };
+        }
+        const steering = await this.#durableProof.readImmutableSteeringMessageProof(sessionId, messageId);
+        if (steering?.event.sessionId === sessionId &&
+            steering.event.refs?.providerEventId === messageId) {
+            return {
+                kind: 'shared_turn',
+                turnId: steering.event.turnId,
+                runId: steering.event.runId,
+            };
+        }
+        if (await this.#admissions.hasCancelledMessageAdmission(sessionId, messageId)) {
+            return { kind: 'cancelled' };
+        }
+        const pending = await this.#admissions.readMessageAdmission(sessionId, messageId);
+        return pending?.sessionId === sessionId && pending.messageId === messageId
+            ? { kind: 'pending' }
+            : { kind: 'recovering' };
+    }
     retireSessions(sessionIds) {
         for (const sessionId of new Set(sessionIds)) {
             const state = this.#sessions.get(sessionId);
@@ -152,11 +246,16 @@ export class HostMessageCoordinator {
     }
     bindRun(identity) {
         const state = this.#state(identity.sessionId);
-        const exactPreStartStop = state.stopFence !== undefined && sameRun(state.stopFence.identity, identity);
+        const exactPreStartStop = state.stopFence !== undefined &&
+            state.reservedRoot !== undefined &&
+            sameRun(state.stopFence.identity, state.reservedRoot);
         if (state.phase !== 'open' && !exactPreStartStop) {
             throw new RuntimeMessageAuthorityInvariantError('Message Run bound while admission was closed');
         }
-        if (!state.reservedRoot || !sameRun(state.reservedRoot, identity) || state.run) {
+        if (!state.reservedRoot ||
+            state.reservedRoot.turnId !== identity.turnId ||
+            state.reservedRoot.expectedRunId !== identity.runId ||
+            state.run) {
             throw new RuntimeMessageAuthorityInvariantError(`Message Run ${identity.runId} was not the exact reserved root identity`);
         }
         const run = { ...identity, generation: state.generation, released: false };
@@ -179,9 +278,66 @@ export class HostMessageCoordinator {
         if (state.run || state.transition) {
             throw new RuntimeMessageAuthorityInvariantError('Cannot reserve a root Turn during live ownership');
         }
-        state.reservedRoot = { ...identity };
+        state.reservedRoot = { ...identity, expectedRunId: identity.runId };
         state.phase = 'open';
     }
+    /** Change physical ownership, not the logical queue generation or Stop identity. */
+    async advanceHandoffRun(identity, successorRunId, admission) {
+        await this.#sessionAdmission.runAdmitted(identity.sessionId, admission, async () => {
+            const logical = await this.#durableProof.readLogicalExecution(identity);
+            const state = this.#requireState(identity.sessionId);
+            if (!logical?.pendingHandoff ||
+                logical.pendingHandoff.successorRunId !== successorRunId ||
+                !state.reservedRoot ||
+                !sameRun(state.reservedRoot, identity) ||
+                state.transition ||
+                (state.phase !== 'open' && !state.stopFence) ||
+                state.inFlight.size !== 0 ||
+                (state.run
+                    ? !state.run.released || state.run.runId !== logical.tip.runId
+                    : state.reservedRoot.expectedRunId !== identity.runId)) {
+                throw new RuntimeMessageAuthorityInvariantError('Physical handoff lacks a sealed released root owner');
+            }
+            state.run = undefined;
+            state.reservedRoot.expectedRunId = successorRunId;
+        });
+    }
+    async #readDetachableHandoff(identity) {
+        const logical = await this.#durableProof.readLogicalExecution(identity);
+        const state = this.#requireState(identity.sessionId);
+        if (state.stopFence || state.pendingInterrupts.size !== 0)
+            return undefined;
+        if (!logical?.pendingHandoff ||
+            !state.reservedRoot ||
+            !sameRun(state.reservedRoot, identity) ||
+            !state.run?.released ||
+            state.run.runId !== logical.tip.runId ||
+            state.inFlight.size !== 0 ||
+            state.transition) {
+            throw new RuntimeMessageAuthorityInvariantError('Handoff cannot detach unsettled Message ownership');
+        }
+        return state;
+    }
+    async handoffResidencies(identity, admission) {
+        return this.#sessionAdmission.runAdmitted(identity.sessionId, admission, async () => {
+            const state = await this.#readDetachableHandoff(identity);
+            return state && allLiveEntries(state).map((entry) => entry.residency);
+        });
+    }
+    async detachHandoffRoot(identity, admission) {
+        await this.#sessionAdmission.runAdmitted(identity.sessionId, admission, async () => {
+            const state = await this.#readDetachableHandoff(identity);
+            if (!state)
+                throw new RuntimeMessageAuthorityInvariantError('Stop took ownership before handoff detach');
+            // Confirmed admissions remain durable for the next Host. Only local leases
+            // and handles retire; do not write cancellation receipts or a queue fence.
+            this.#retractQueued(state);
+            state.run = undefined;
+            state.reservedRoot = undefined;
+            state.phase = 'closed';
+            this.#maybeReclaim(identity.sessionId, state);
+        });
+    }
     abandonRootReservation(identity) {
         const state = this.#requireState(identity.sessionId);
         if (!state.reservedRoot || !sameRun(state.reservedRoot, identity) || state.run) {
@@ -202,7 +358,8 @@ export class HostMessageCoordinator {
         if (!state.reservedRoot ||
             !sameRun(state.reservedRoot, identity) ||
             !run ||
-            !sameRun(run, identity) ||
+            run.turnId !== identity.turnId ||
+            run.runId !== state.reservedRoot.expectedRunId ||
             !run.released) {
             throw new RuntimeMessageAuthorityInvariantError('Terminal transition requires a released exact root owner');
         }
@@ -250,7 +407,7 @@ export class HostMessageCoordinator {
         state.generation += 1;
         for (const entry of allLiveEntries(state))
             entry.generation = state.generation;
-        state.reservedRoot = { ...identity };
+        state.reservedRoot = { ...identity, expectedRunId: identity.runId };
         state.phase = 'open';
         this.#mutated(state);
     }
@@ -293,6 +450,7 @@ export class HostMessageCoordinator {
         const provenRootMessages = [];
         const provenSteeringMessages = [];
         const admissions = await this.#admissions.listMessageAdmissions(input.sessionId);
+        let logicalRunIds;
         for (const messageId of new Set(input.messageIds)) {
             messageIds.add(messageId);
             provenRootMessages.push(await this.#readProvenRootMessage(input, messageId));
@@ -302,7 +460,13 @@ export class HostMessageCoordinator {
                 continue;
             }
             const proof = await this.#durableProof.readImmutableSteeringMessageProof(input.sessionId, admission.messageId);
-            if (proof?.event.turnId === input.turnId && proof.event.runId === input.runId) {
+            if (proof?.event.turnId === input.turnId &&
+                proof.event.runId !== input.runId &&
+                !logicalRunIds) {
+                logicalRunIds = (await this.#durableProof.readLogicalExecution(input))?.runIds ?? [];
+            }
+            if (proof?.event.turnId === input.turnId &&
+                (proof.event.runId === input.runId || logicalRunIds?.includes(proof.event.runId))) {
                 messageIds.add(admission.messageId);
                 provenSteeringMessages.push({
                     messageId: admission.messageId,
@@ -407,6 +571,8 @@ export class HostMessageCoordinator {
                     ? { submittedIntent: recoveryBatch[0].submittedIntent }
                     : {}),
             }, admissionLease);
+            if ('deferred' in started)
+                return;
             if ('error' in started) {
                 throw new RuntimeMessageAuthorityInvariantError(`Durable Message recovery failed: ${started.error}`);
             }
@@ -445,6 +611,8 @@ export class HostMessageCoordinator {
                 content: submittedProjectionContent(admission.content),
                 modelContent: admission.content,
                 submittedContentDigest: admission.submittedContentDigest,
+                submittedPlacement: admission.submittedPlacement,
+                skillInvocation: admission.skillInvocation,
                 placement: admission.placement,
                 disposition: admission.disposition,
                 generation: state.generation,
@@ -505,7 +673,7 @@ export class HostMessageCoordinator {
             if (isCurrentEpoch) {
                 const receipt = await this.#readCompletedSubmit(input.sessionId, input.messageId);
                 if (receipt) {
-                    return samePayload(receipt.payload, payload)
+                    return samePayload(receipt.payloadIdentity, completedPayloadIdentity('submit', payload))
                         ? success(receipt.result)
                         : failure('operation_conflict', 'Message identity has a different payload');
                 }
@@ -526,6 +694,7 @@ export class HostMessageCoordinator {
             // (#pull/#ack/#nack), so a submit's preflight snapshot can go stale while
             // it awaits. That is transient: re-read the queue and re-run admission
             // instead of surfacing a spurious session_busy to the client.
+            let preparedForRoot;
             for (let attempt = 0;; attempt++) {
                 const header = await this.#root.readSessionHeader(input.sessionId);
                 if (this.#failStopped) {
@@ -542,6 +711,9 @@ export class HostMessageCoordinator {
                 if (this.#failStopped) {
                     return failure('host_draining', 'Runtime Host message authority has failed');
                 }
+                if (header.activeTurnOnly && rootState.kind !== 'active') {
+                    return failure('operation_unavailable', 'No active Turn can accept queued messages');
+                }
                 if (rootState.kind === 'idle') {
                     const existingState = this.#sessions.get(input.sessionId);
                     if (existingState && hasLiveMessageState(existingState)) {
@@ -552,6 +724,7 @@ export class HostMessageCoordinator {
                         messageId: input.messageId,
                         content: payload.content,
                         submittedContentDigest: messageContentDigest(payload.content),
+                        submittedPlacement: input.placement,
                         ...(intent ? { submittedIntent: intent } : {}),
                         placement: input.placement,
                         disposition: 'turn_started',
@@ -567,16 +740,20 @@ export class HostMessageCoordinator {
                     const runId = pendingAdmission?.runId ?? this.#createId();
                     const started = await this.#root.startFromMessage({
                         sessionId: input.sessionId,
-                        content: payload.content,
+                        content: pendingAdmission?.content ?? payload.content,
                         sourceMessage,
                         initiatingConnectionId,
                         turnId,
                         runId,
-                        ...(payload.skillIds.length > 0 ? { skillIds: payload.skillIds } : {}),
+                        ...(pendingAdmission
+                            ? { preparedSkillInvocation: pendingAdmission.skillInvocation }
+                            : payload.skillIds.length > 0
+                                ? { skillIds: payload.skillIds }
+                                : {}),
                         ...(payload.turnOrchestration
                             ? { turnOrchestration: payload.turnOrchestration }
                             : {}),
-                    }, admission, async (canonicalContent) => {
+                    }, admission, async (canonicalContent, skillInvocation) => {
                         await this.#admissions.commitMessageAdmission({
                             sessionId: input.sessionId,
                             turnId,
@@ -588,6 +765,7 @@ export class HostMessageCoordinator {
                             placement: 'current_turn',
                             disposition: 'steering',
                             ...(intent ? { submittedIntent: intent } : {}),
+                            skillInvocation,
                             admittedAt: pendingAdmission?.admittedAt ?? Date.now(),
                         });
                     });
@@ -609,7 +787,7 @@ export class HostMessageCoordinator {
                     const result = {
                         disposition: 'turn_started',
                         turnId: started.turnId,
-                        ...(started.skillInvocation ? { skillInvocation: started.skillInvocation } : {}),
+                        skillInvocation: started.skillInvocation ?? EMPTY_SKILL_INVOCATION,
                     };
                     return success(result);
                 }
@@ -626,19 +804,44 @@ export class HostMessageCoordinator {
                 if (!state.reservedRoot || !sameRun(state.reservedRoot, rootState)) {
                     throw new RuntimeMessageAuthorityInvariantError('Root state does not match message reservation');
                 }
-                if (allLiveEntries(state).length >= MESSAGE_QUEUE_MAX_ENTRIES) {
-                    return failure('session_busy', 'Message queue capacity is full');
+                const existingEntry = allLiveEntries(state).find((entry) => entry.messageId === input.messageId);
+                if (existingEntry) {
+                    const existingAdmission = await this.#admissions.readMessageAdmission(input.sessionId, input.messageId);
+                    if (!existingAdmission ||
+                        existingAdmission.submittedContentDigest !== messageContentDigest(payload.content) ||
+                        existingAdmission.submittedPlacement !== input.placement) {
+                        return failure('operation_conflict', 'Message admission has a different payload');
+                    }
+                    const result = {
+                        disposition: existingEntry.disposition,
+                        queueRevision: state.revision,
+                        skillInvocation: existingEntry.skillInvocation,
+                    };
+                    this.#rememberCompletedOperation('submit', input.sessionId, input.messageId, payload, result);
+                    return success(result);
                 }
                 const disposition = input.placement === 'current_turn' ? 'steering' : 'followup';
-                const prepared = await this.#root.prepareMessage({
-                    sessionId: input.sessionId,
-                    turnId: rootState.turnId,
-                    content: payload.content,
-                    placement: input.placement,
-                });
+                const prepared = preparedForRoot && sameRun(preparedForRoot.identity, rootState)
+                    ? preparedForRoot.outcome
+                    : await this.#root.prepareMessage({
+                        sessionId: input.sessionId,
+                        turnId: rootState.turnId,
+                        content: payload.content,
+                        placement: input.placement,
+                    });
+                preparedForRoot = { identity: rootState, outcome: prepared };
                 if (prepared.kind === 'rejected') {
+                    if (prepared.skillInvocation) {
+                        return success({
+                            disposition: 'blocked',
+                            skillInvocation: prepared.skillInvocation,
+                        });
+                    }
                     return failure('operation_conflict', prepared.error);
                 }
+                if (allLiveEntries(state).length >= MESSAGE_QUEUE_MAX_ENTRIES) {
+                    return failure('session_busy', 'Message queue capacity is full');
+                }
                 const candidateRevision = state.revision;
                 const candidateGeneration = state.generation;
                 const entryId = this.#createId();
@@ -678,6 +881,8 @@ export class HostMessageCoordinator {
                     messageId: input.messageId,
                     content: prepared.content,
                     submittedContentDigest: messageContentDigest(payload.content),
+                    submittedPlacement: input.placement,
+                    skillInvocation: prepared.skillInvocation,
                     placement: input.placement,
                     disposition,
                 };
@@ -687,7 +892,7 @@ export class HostMessageCoordinator {
                     prospectiveSteering.push(candidateSource);
                 else
                     prospectiveFollowup.push(candidateSource);
-                if (!successorAdmissionsFit(prospectiveSteering, prospectiveFollowup)) {
+                if (!successorAdmissionsFit(input.sessionId, rootState.turnId, prospectiveSteering, prospectiveFollowup)) {
                     return failure('session_busy', 'Message queue cannot form a durable follow-up Turn');
                 }
                 if (state.phase !== 'open' ||
@@ -700,7 +905,11 @@ export class HostMessageCoordinator {
                     }
                     continue;
                 }
-                const result = { disposition, queueRevision: candidateRevision + 1 };
+                const result = {
+                    disposition,
+                    queueRevision: candidateRevision + 1,
+                    skillInvocation: prepared.skillInvocation,
+                };
                 const messageAdmission = {
                     sessionId: input.sessionId,
                     turnId: rootState.turnId,
@@ -711,6 +920,7 @@ export class HostMessageCoordinator {
                     submittedPlacement: input.placement,
                     placement: input.placement,
                     disposition,
+                    skillInvocation: prepared.skillInvocation,
                     admittedAt: Date.now(),
                 };
                 await this.#admissions.commitMessageAdmission(messageAdmission);
@@ -724,6 +934,8 @@ export class HostMessageCoordinator {
                     content: payload.content,
                     modelContent: prepared.content,
                     submittedContentDigest: messageAdmission.submittedContentDigest,
+                    submittedPlacement: messageAdmission.submittedPlacement,
+                    skillInvocation: messageAdmission.skillInvocation,
                     placement: input.placement,
                     disposition,
                     generation: state.generation,
@@ -852,7 +1064,7 @@ export class HostMessageCoordinator {
             }
             const receipt = await this.#readCompletedQueuedMutation(options);
             if (receipt) {
-                return samePayload(receipt.payload, options.input)
+                return samePayload(receipt.payloadIdentity, completedPayloadIdentity(options.operationKind, options.input))
                     ? success(receipt.result)
                     : failure('operation_conflict', `${options.verb} identity has a different payload`);
             }
@@ -865,7 +1077,7 @@ export class HostMessageCoordinator {
             return undefined;
         try {
             return {
-                payload: options.spec.decodeInput(receipt.payload),
+                payloadIdentity: receipt.payloadIdentity,
                 result: options.spec.decodeOutput(receipt.result),
             };
         }
@@ -954,7 +1166,7 @@ export class HostMessageCoordinator {
         const prospectiveFollowup = state.followup
             .filter((queued) => queued !== entry)
             .map(sourceFromEntry);
-        if (!successorAdmissionsFit(prospectiveSteering, prospectiveFollowup)) {
+        if (!successorAdmissionsFit(input.sessionId, state.reservedRoot.turnId, prospectiveSteering, prospectiveFollowup)) {
             return failure('session_busy', 'Promoted Message exceeds steering admission capacity');
         }
         await this.#admissions.updateMessageAdmission({
@@ -964,9 +1176,10 @@ export class HostMessageCoordinator {
             messageId: entry.messageId,
             content: entry.modelContent,
             submittedContentDigest: entry.submittedContentDigest,
-            submittedPlacement: 'next_turn',
+            submittedPlacement: entry.submittedPlacement,
             placement: 'current_turn',
             disposition: 'steering',
+            skillInvocation: entry.skillInvocation,
             admittedAt: entry.admittedAt,
         });
         state.followup.splice(index, 1);
@@ -1034,11 +1247,12 @@ export class HostMessageCoordinator {
                 ...sourceFromEntry(entry),
                 content: modelContent,
                 submittedContentDigest: messageContentDigest(content),
+                skillInvocation: prepared.skillInvocation,
             }
             : sourceFromEntry(entry);
         const steeringSources = [...state.inFlight.values(), ...state.steering].map(updatedSource);
         const followupSources = state.followup.map(updatedSource);
-        if (!successorAdmissionsFit(steeringSources, followupSources)) {
+        if (!successorAdmissionsFit(input.sessionId, state.reservedRoot.turnId, steeringSources, followupSources)) {
             return failure('session_busy', 'Message queue mutation exceeds root admission capacity');
         }
         if (!(await this.#preflightSessionSnapshot(input.sessionId, { queue: updatedProjection }))) {
@@ -1059,11 +1273,13 @@ export class HostMessageCoordinator {
             submittedPlacement: admission?.submittedPlacement ?? queued.entry.placement,
             placement: queued.entry.placement,
             disposition: queued.entry.disposition,
+            skillInvocation: prepared.skillInvocation,
             admittedAt: queued.entry.admittedAt,
         });
         queued.entry.content = content;
         queued.entry.modelContent = modelContent;
         queued.entry.submittedContentDigest = messageContentDigest(content);
+        queued.entry.skillInvocation = prepared.skillInvocation;
         this.#mutated(state);
         const result = { queueRevision: state.revision };
         this.#rememberCompletedOperation('update_entry', input.sessionId, input.updateId, input, result);
@@ -1082,7 +1298,8 @@ export class HostMessageCoordinator {
         if (state.transition) {
             return failure('operation_conflict', 'Message queue is draining into the next Turn');
         }
-        const current = state.followup;
+        const steering = state.steering.some((entry) => entry.entryId === input.entryIds[0]);
+        const current = steering ? state.steering : state.followup;
         if (input.entryIds.length !== current.length) {
             return failure('operation_conflict', 'Message queue changed since the reorder was issued');
         }
@@ -1093,11 +1310,15 @@ export class HostMessageCoordinator {
             if (!entry) {
                 return failure('operation_conflict', 'Message queue changed since the reorder was issued');
             }
+            byId.delete(entryId);
             reordered.push(entry);
         }
         if (reordered.some((entry, index) => current[index] !== entry)) {
-            await this.#admissions.reorderMessageAdmissions(input.sessionId, reordered.map((entry) => entry.messageId));
-            state.followup = reordered;
+            await this.#admissions.reorderMessageAdmissions(input.sessionId, reordered.map((entry) => entry.messageId), steering ? 'steering' : 'followup');
+            if (steering)
+                state.steering = reordered;
+            else
+                state.followup = reordered;
             this.#mutated(state);
         }
         const result = { queueRevision: state.revision };
@@ -1113,7 +1334,7 @@ export class HostMessageCoordinator {
         }
         const completed = await this.#readCompletedInterrupt(input.sessionId, input.interruptId);
         if (completed) {
-            return samePayload(completed.payload, input)
+            return samePayload(completed.payloadIdentity, input)
                 ? completed.result
                 : failure('operation_conflict', 'Interrupt identity has a different payload');
         }
@@ -1257,10 +1478,18 @@ export class HostMessageCoordinator {
             if (!sameSourcePayload(receipt, payload)) {
                 return failure('operation_conflict', 'Durable message receipt has a different payload');
             }
+            const skillInvocation = source.skillInvocation ?? receipt.admission.skillInvocation ?? EMPTY_SKILL_INVOCATION;
             if (source.disposition === 'turn_started') {
-                return success({ disposition: 'turn_started', turnId: receipt.admission.turnId });
+                return success({
+                    disposition: 'turn_started',
+                    turnId: receipt.admission.turnId,
+                    skillInvocation,
+                });
             }
-            return failure('outcome_unknown', 'Durable message proof does not include the original queue revision');
+            return success({
+                disposition: source.disposition,
+                skillInvocation,
+            });
         }
         const steeringProof = await this.#durableProof.readImmutableSteeringMessageProof(input.sessionId, input.messageId);
         const event = steeringProof?.event;
@@ -1283,7 +1512,7 @@ export class HostMessageCoordinator {
             return undefined;
         try {
             return {
-                payload: canonicalSubmitPayload(MESSAGE_OPERATION_SPECS['turn.message.submit'].decodeInput(receipt.payload)),
+                payloadIdentity: receipt.payloadIdentity,
                 result: MESSAGE_OPERATION_SPECS['turn.message.submit'].decodeOutput(receipt.result),
             };
         }
@@ -1297,7 +1526,7 @@ export class HostMessageCoordinator {
             return undefined;
         try {
             return {
-                payload: MESSAGE_OPERATION_SPECS['turn.interrupt'].decodeInput(receipt.payload),
+                payloadIdentity: receipt.payloadIdentity,
                 result: decodeCompletedInterruptOutcome(receipt.result),
             };
         }
@@ -1307,7 +1536,10 @@ export class HostMessageCoordinator {
     }
     #rememberCompletedOperation(operation, sessionId, operationId, payload, result) {
         const key = queuedMutationKey(operation, sessionId, operationId);
-        const receipt = { payload: structuredClone(payload), result: structuredClone(result) };
+        const receipt = {
+            payloadIdentity: structuredClone(completedPayloadIdentity(operation, payload)),
+            result: structuredClone(result),
+        };
         const committed = this.#completedOperations.get(key);
         if (committed && !isDeepStrictEqual(committed, receipt)) {
             throw new RuntimeMessageAuthorityInvariantError('Message operation replay identity has an ambiguous outcome');
@@ -1334,7 +1566,18 @@ export class HostMessageCoordinator {
             // The coordinator remains fail-stopped even if the Host drain signal itself fails.
         }
     }
-    #pull(run) {
+    async #pull(run) {
+        // A provider boundary must observe steering admission and queue mutations,
+        // not mistake an unfinished durable write for an empty queue.
+        for (;;) {
+            const pending = [
+                ...[...this.#pendingSubmits.values()].filter(({ payload }) => payload.sessionId === run.sessionId && payload.placement === 'current_turn'),
+                ...[...this.#pendingQueuedMutations.values()].filter(({ payload }) => payload.sessionId === run.sessionId),
+            ];
+            if (pending.length === 0)
+                break;
+            await Promise.all(pending.map(({ result }) => result));
+        }
         this.#assertRun(run);
         const state = this.#requireState(run.sessionId);
         if (state.phase !== 'open' || run.generation !== state.generation)
@@ -1632,7 +1875,7 @@ function sameSourcePayload(receipt, input) {
         (durableDigest
             ? durableDigest === messageContentDigest(input.content)
             : messageContentsEqual(source.content, input.content)) &&
-        source.placement === input.placement &&
+        (source.submittedPlacement ?? source.placement) === input.placement &&
         submittedTurnIntentsEqual(source.submittedIntent, submittedTurnIntent(input)));
 }
 function sourceFromEntry(entry) {
@@ -1640,6 +1883,8 @@ function sourceFromEntry(entry) {
         messageId: entry.messageId,
         content: normalizeMessageContent(entry.modelContent),
         submittedContentDigest: entry.submittedContentDigest,
+        submittedPlacement: entry.submittedPlacement,
+        skillInvocation: entry.skillInvocation,
         placement: entry.placement,
         disposition: entry.disposition,
     };
@@ -1649,7 +1894,9 @@ function pendingMessageSource(admission) {
         messageId: admission.messageId,
         content: normalizeMessageContent(admission.content),
         submittedContentDigest: admission.submittedContentDigest,
+        submittedPlacement: admission.submittedPlacement,
         ...(admission.submittedIntent ? { submittedIntent: admission.submittedIntent } : {}),
+        skillInvocation: admission.skillInvocation,
         placement: admission.placement,
         disposition: admission.disposition,
     };
@@ -1741,6 +1988,19 @@ function fitsEncodedByteLimit(value, maxBytes) {
 function isEntityId(value) {
     return /^[A-Za-z0-9_-]{1,128}$/.test(value);
 }
+// Epoch-long replay needs the original result and request identity, not historical message bodies.
+function completedPayloadIdentity(operation, payload) {
+    if (operation === 'submit') {
+        const { content, ...identity } = payload;
+        return { ...identity, contentDigest: messageContentDigest(content) };
+    }
+    if (operation === 'update_entry') {
+        const { text, ...identity } = payload;
+        // UTF-16 preserves distinct JS strings even when they contain unpaired surrogates.
+        return { ...identity, textDigest: createHash('sha256').update(text, 'utf16le').digest('hex') };
+    }
+    return payload;
+}
 function canonicalSubmitPayload(input) {
     return {
         originHostEpoch: input.originHostEpoch,
@@ -1834,19 +2094,32 @@ function nextRecoveredSuccessorItems(pending) {
 function hasNativeSteeringRootIdentity(admission) {
     return admission.disposition === 'steering' && admission.submittedPlacement === 'current_turn';
 }
-function rootAdmissionPayloadFits(sources) {
+function rootAdmissionPayloadFits(sessionId, previousTurnId, sources) {
     try {
         const content = aggregateMessageContent(sources.map((source) => source.content));
-        normalizeRootTurnAdmissionPayload(content, sources);
-        return true;
+        const worstCaseId = 'i'.repeat(128);
+        return rootTurnAdmissionRecordFits({
+            sessionId,
+            turnId: worstCaseId,
+            proposedRunId: worstCaseId,
+            proposedUserMessageId: sources.length === 1 ? worstCaseId : null,
+            execution: {
+                kind: 'external_message',
+                inputDigest: `sha256:${'f'.repeat(64)}`,
+            },
+            previousRootTurnId: previousTurnId,
+            normalizedInput: content,
+            sourceMessages: sources,
+            admittedAt: Number.MAX_SAFE_INTEGER,
+        });
     }
     catch {
         return false;
     }
 }
-function successorAdmissionsFit(steering, followup) {
-    return ((steering.length === 0 || rootAdmissionPayloadFits(steering)) &&
-        followup.every((source) => rootAdmissionPayloadFits([source])));
+function successorAdmissionsFit(sessionId, previousTurnId, steering, followup) {
+    return ((steering.length === 0 || rootAdmissionPayloadFits(sessionId, previousTurnId, steering)) &&
+        followup.every((source) => rootAdmissionPayloadFits(sessionId, previousTurnId, [source])));
 }
 function interruptResultFits(projection, identity) {
     const retracted = [...projection.steering, ...projection.followup]