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

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

@@ -18,18 +18,21 @@
  */
 import { createHash, randomUUID } from 'node:crypto';
 import { isDeepStrictEqual } from 'node:util';
+import { readLogicalRuntimeExecution, readLogicalRuntimeExecutionForRun, } from '@maka/core/runtime-logical-execution';
+import { runtimeHandoffPause } from '@maka/core/runtime-handoff';
 import { INLINE_REFERENCE_MAX_COUNT, messageContentDigest, messageContentsEqual, normalizeMessageContent, } from '@maka/core/events';
-import { isWorkHubCoordinationSessionId } from '@maka/core/session';
+import { WORKHUB_COORDINATION_SESSION_ID, isWorkHubCoordinationSessionId, } from '@maka/core/session';
 import { resolveEffectiveOrchestration } from '@maka/core/orchestration';
 import { decodeSkillInvocationResult, } from '@maka/core/skill-invocation';
 import { agentGraphIdForRootSession } from '@maka/runtime/stream-graph-coordinator';
 import { RuntimeHostedRootConflictError, RuntimeHostedRootUnavailableError, RuntimeMessageAuthorityInvariantError, } from '@maka/runtime/message-authority';
-import { RuntimeInteractionAdmissionRejectedError, RuntimeInteractionFailStopError, RuntimeInteractionInvariantError, } from '@maka/runtime/interaction-authority';
-import { RuntimeRegenerateTurnError } from '@maka/runtime/session-manager';
+import { isShutdownCancelledInteractionAdmission, RuntimeInteractionAdmissionRejectedError, RuntimeInteractionFailStopError, RuntimeInteractionInvariantError, } from '@maka/runtime/interaction-authority';
+import { normalizeStopSessionSource, RuntimeRegenerateTurnError, } from '@maka/runtime/session-manager';
 import { RuntimeOwnerCleanupError } from '@maka/runtime/runtime-kernel';
 import { parseSkillInvocationTokens, } from '@maka/runtime/skill-invocation';
 import { skillInvocationInlineReferences } from '@maka/runtime/skill-invocation-receipt';
 import { authenticateExecutionStoresWriter, isSessionNotFoundError, normalizeRootTurnAdmissionPayload, } from '@maka/storage/execution-stores';
+import { hostedExecutionRunProfile } from './hosted-execution-tool-profile.js';
 import { runtimeHostExecutionUnavailableReason, runtimeHostExternalTurnUnavailableReason, runtimeHostSafeBoundaryContinuationUnavailableReason, WORKHUB_COORDINATION_EXECUTION_UNAVAILABLE_REASON, } from './host-session-availability.js';
 import { completedHostedExecutionAdmission } from './hosted-execution-authority.js';
 import { HostedExecutionProjectionReader } from './hosted-execution-projection.js';
@@ -51,18 +54,22 @@ export class RootTurnCoordinator {
     assertScheduledTaskRecoveryAdmission;
     agentGraphEpochs;
     nameSessionFromRootMessage;
+    directoryHostId;
+    prepareWorkHubRoutingDecision;
     handlers = {
         'turn.resume.query': (input, context) => this.queryTurnResume(input, context),
         'turn.resume.start': (input, context) => this.startTurnResume(input, context),
     };
     #executions = new HostedExecutionRegistry();
     #admissions;
+    #handoffHold;
+    #cancelHandoff;
     #recoveryPlansBySession = new Map();
     stores;
     executionProjection;
     attachmentValidator;
     prepareSkillInvocation;
-    constructor(manager, stores, sessionAdmission, rootAdmissionOwner, interactions, messages, continuity, acquireRecoveryResidency, requestHostDrain, clientCapabilities, resolveExecutionObserver, assertScheduledTaskRecoveryAdmission, attachmentValidator, prepareSkillInvocation, agentGraphEpochs, nameSessionFromRootMessage) {
+    constructor(manager, stores, sessionAdmission, rootAdmissionOwner, interactions, messages, continuity, acquireRecoveryResidency, requestHostDrain, clientCapabilities, resolveExecutionObserver, assertScheduledTaskRecoveryAdmission, attachmentValidator, prepareSkillInvocation, agentGraphEpochs, nameSessionFromRootMessage, directoryHostId, prepareWorkHubRoutingDecision) {
         this.manager = manager;
         this.sessionAdmission = sessionAdmission;
         this.rootAdmissionOwner = rootAdmissionOwner;
@@ -76,6 +83,8 @@ export class RootTurnCoordinator {
         this.assertScheduledTaskRecoveryAdmission = assertScheduledTaskRecoveryAdmission;
         this.agentGraphEpochs = agentGraphEpochs;
         this.nameSessionFromRootMessage = nameSessionFromRootMessage;
+        this.directoryHostId = directoryHostId;
+        this.prepareWorkHubRoutingDecision = prepareWorkHubRoutingDecision;
         this.stores = authenticateExecutionStoresWriter(stores, 'interactive');
         this.executionProjection = new HostedExecutionProjectionReader(this.stores);
         this.#admissions = new HostedExecutionAdmissionRegistry((sessionId) => this.#executions.has(sessionId));
@@ -98,75 +107,101 @@ export class RootTurnCoordinator {
     }
     async recover() {
         for (const [sessionId, plan] of this.#recoveryPlansBySession) {
-            for (const admission of plan.admissions) {
-                const run = await this.readRunIfPresent(sessionId, admission.runId);
-                if (!run)
-                    continue;
-                await this.assertRunMatchesDurableExecution(run, admission.turnId, admission.execution);
-                const snapshot = await this.readCanonicalSnapshot(sessionId, admission.turnId, admission.runId, run);
-                if (isTerminalSnapshot(snapshot)) {
-                    if (admission.sourceMessages.length > 0) {
-                        await this.messages.materializeMessageHandoffsForRun({
-                            sessionId,
-                            turnId: admission.turnId,
-                            runId: admission.runId,
-                            messageIds: admission.sourceMessages.map((source) => source.messageId),
-                        });
-                    }
-                }
-                else {
-                    if (admission.execution.kind !== 'safe_boundary_continuation') {
-                        throw new Error(`Startup recovery left Turn ${admission.turnId} non-terminal`);
-                    }
-                    this.parkContinuationAdmission(admission);
-                }
-            }
-            const admission = plan.rootReplayAdmission;
-            if (!admission)
-                continue;
-            // Session recovery may have materialized this Run after the replay plan was prepared.
-            if (await this.readRunIfPresent(sessionId, admission.runId))
+            if (plan.rootReplayAdmission &&
+                !(await this.bindRecoveryCapabilities(sessionId, plan.rootReplayAdmission.execution)))
                 continue;
-            const input = activationInputForAdmission(admission);
-            const disposition = await this.sessionAdmission.run(sessionId, async (lease) => {
-                if (admission.execution.kind === 'safe_boundary_continuation') {
-                    const header = await this.stores.sessionStore.readHeaderSnapshot(sessionId);
-                    if (runtimeHostSafeBoundaryContinuationUnavailableReason(header)) {
-                        this.parkContinuationAdmission(admission);
-                        return undefined;
+            try {
+                for (const admission of plan.admissions) {
+                    const run = await this.readRunIfPresent(sessionId, admission.runId);
+                    if (!run)
+                        continue;
+                    await this.assertRunMatchesDurableExecution(run, admission.turnId, admission.execution);
+                    const snapshot = await this.readCanonicalSnapshot(sessionId, admission.turnId, admission.runId, run);
+                    if (isTerminalSnapshot(snapshot)) {
+                        if (admission.sourceMessages.length > 0) {
+                            await this.messages.materializeMessageHandoffsForRun({
+                                sessionId,
+                                turnId: admission.turnId,
+                                runId: admission.runId,
+                                messageIds: admission.sourceMessages.map((source) => source.messageId),
+                            });
+                        }
                     }
-                }
-                const continuation = admission.execution.kind === 'safe_boundary_continuation'
-                    ? await this.reconstructAdmittedContinuation(admission)
-                    : undefined;
-                if (continuation?.disposition === 'parked') {
-                    if (continuation.plan.reason === 'safety_check_failed' ||
-                        continuation.plan.reason === 'resume_feature_disabled' ||
-                        continuation.plan.reason === 'continuation_authority_unavailable' ||
-                        continuation.plan.reason === 'safety_observation_unavailable') {
+                    else {
+                        if (plan.rootReplayAdmission === admission)
+                            continue;
+                        if (admission.execution.kind !== 'safe_boundary_continuation') {
+                            throw new Error(`Startup recovery left Turn ${admission.turnId} non-terminal`);
+                        }
                         this.parkContinuationAdmission(admission);
-                        return undefined;
                     }
-                    throw new Error(`Unable to recover admitted Turn ${admission.turnId}: ${continuation.plan.reason}`);
                 }
-                await this.messages.handoffRootSources({
-                    sessionId,
-                    turnId: admission.turnId,
-                    runId: admission.runId,
-                    messageIds: admission.sourceMessages.map((source) => source.messageId),
+                const admission = plan.rootReplayAdmission;
+                if (!admission)
+                    continue;
+                // Session recovery may have materialized this Run after the replay plan was prepared.
+                const existingRun = await this.readRunIfPresent(sessionId, admission.runId);
+                const pendingHandoff = existingRun &&
+                    (await readLogicalRuntimeExecution(this.stores.runtimeEventStore, admission, existingRun))
+                        ?.pendingHandoff;
+                if (existingRun && !pendingHandoff)
+                    continue;
+                const input = activationInputForAdmission(admission);
+                const disposition = await this.sessionAdmission.run(sessionId, async (lease) => {
+                    if (admission.execution.kind === 'safe_boundary_continuation') {
+                        const header = await this.stores.sessionStore.readHeaderSnapshot(sessionId);
+                        if (runtimeHostSafeBoundaryContinuationUnavailableReason(header)) {
+                            this.parkContinuationAdmission(admission);
+                            return undefined;
+                        }
+                    }
+                    const continuation = admission.execution.kind === 'safe_boundary_continuation' && !pendingHandoff
+                        ? await this.reconstructAdmittedContinuation(admission)
+                        : undefined;
+                    if (continuation?.disposition === 'parked') {
+                        if (continuation.plan.reason === 'safety_check_failed' ||
+                            continuation.plan.reason === 'resume_feature_disabled' ||
+                            continuation.plan.reason === 'continuation_authority_unavailable' ||
+                            continuation.plan.reason === 'safety_observation_unavailable') {
+                            this.parkContinuationAdmission(admission);
+                            return undefined;
+                        }
+                        throw new Error(`Unable to recover admitted Turn ${admission.turnId}: ${continuation.plan.reason}`);
+                    }
+                    await this.messages.handoffRootSources({
+                        sessionId,
+                        turnId: admission.turnId,
+                        runId: admission.runId,
+                        messageIds: admission.sourceMessages.map((source) => source.messageId),
+                    });
+                    return this.prepareAdmittedTurn(input, admission, this.acquireRecoveryResidency, lease, undefined, undefined, undefined, continuation?.continuation);
                 });
-                return this.prepareAdmittedTurn(input, admission, this.acquireRecoveryResidency, lease, undefined, undefined, undefined, continuation?.continuation);
-            });
-            if (!disposition)
-                continue;
-            const outcome = await this.resolveStartDisposition(input, disposition);
-            if (!outcome.ok) {
-                throw new Error(`Unable to recover admitted Turn ${admission.turnId}: ${outcome.error.code}`);
+                if (!disposition)
+                    continue;
+                const outcome = await this.resolveStartDisposition(input, disposition);
+                if (!outcome.ok) {
+                    throw new Error(`Unable to recover admitted Turn ${admission.turnId}: ${outcome.error.code}`);
+                }
+            }
+            finally {
+                this.#recoveryPlansBySession.delete(sessionId);
             }
         }
-        this.#recoveryPlansBySession.clear();
+    }
+    async bindRecoveryCapabilities(sessionId, execution) {
+        const header = await this.stores.sessionStore.readHeaderSnapshot(sessionId);
+        if (header.toolProfile !== 'workhub-coordination-v2')
+            return true;
+        // Older admissions without authenticated provider evidence stay pending.
+        // Neither registration order nor a tool name can establish Desktop ownership.
+        if (execution.kind !== 'workhub_coordination' ||
+            !execution.capabilityBinding ||
+            !this.clientCapabilities)
+            return false;
+        return this.clientCapabilities.bindRecoveredSession(sessionId, execution.capabilityBinding, hostedExecutionRunProfile(header.toolProfile).toolNames.filter((name) => name.startsWith('mcp__')));
     }
     async close() {
+        this.#cancelHandoff?.();
         this.beginDrain();
         await this.#admissions.waitForSettledAdmissions();
         const errors = [];
@@ -189,6 +224,15 @@ export class RootTurnCoordinator {
     }
     async readSessionHeader(sessionId) {
         if (isWorkHubCoordinationSessionId(sessionId)) {
+            const active = this.#executions.get(sessionId);
+            if (active?.descriptor.kind === 'workhub_coordination' &&
+                !active.descriptor.operation &&
+                !active.stopRequested) {
+                const header = await this.stores.sessionStore.readHeaderSnapshot(sessionId);
+                if (header.toolProfile === 'workhub-coordination-v2') {
+                    return { isArchived: header.isArchived, activeTurnOnly: true };
+                }
+            }
             return {
                 isArchived: false,
                 unavailableReason: WORKHUB_COORDINATION_EXECUTION_UNAVAILABLE_REASON,
@@ -209,6 +253,10 @@ export class RootTurnCoordinator {
             throw error;
         }
     }
+    /** Called under Session admission before changing an execution's authority ceiling. */
+    isSessionExecutionIdle(sessionId) {
+        return (!this.#recoveryPlansBySession.has(sessionId) && this.readRootState(sessionId).kind === 'idle');
+    }
     readRootState(sessionId) {
         const active = this.#executions.get(sessionId);
         if (active) {
@@ -219,7 +267,30 @@ export class RootTurnCoordinator {
                 runId: active.runId,
             };
         }
-        return this.#admissions.has(sessionId) ? { kind: 'reserved' } : { kind: 'idle' };
+        return this.#handoffHold ||
+            this.#admissions.has(sessionId) ||
+            this.#recoveryPlansBySession.get(sessionId)?.rootReplayAdmission
+            ? { kind: 'reserved' }
+            : { kind: 'idle' };
+    }
+    /** Returns the newest Host-admitted continuation descended from one root execution. */
+    async readLatestRootTurnLineage(identity) {
+        const origin = await this.stores.agentRunStore.readRootTurnAdmission(identity.sessionId, identity.turnId);
+        if (!origin || origin.runId !== identity.runId) {
+            throw new RuntimeMessageAuthorityInvariantError(`Root execution ${identity.turnId}/${identity.runId} has no durable admission`);
+        }
+        let latest = origin;
+        while (true) {
+            const run = await this.readRunIfPresent(latest.sessionId, latest.runId);
+            const physical = run?.terminalEvent && runtimeHandoffPause(run.terminalEvent)
+                ? (await readLogicalRuntimeExecution(this.stores.runtimeEventStore, latest, run))?.tip
+                : run;
+            const continuation = await this.stores.agentRunStore.readRootTurnContinuationAdmission(identity.sessionId, latest.turnId, physical?.runId ?? latest.runId);
+            if (!continuation)
+                break;
+            latest = continuation;
+        }
+        return { sessionId: latest.sessionId, turnId: latest.turnId, runId: latest.runId };
     }
     startHostedExternalTransition(input, context) {
         return this.startInteractiveRootMessage({
@@ -232,12 +303,16 @@ export class RootTurnCoordinator {
         }, context);
     }
     reserveRootTurn(sessionId) {
+        if (this.#handoffHold || this.#recoveryPlansBySession.get(sessionId)?.rootReplayAdmission)
+            return undefined;
         return this.#admissions.reserve(sessionId);
     }
     parkContinuationAdmission(admission) {
         this.#admissions.park(admission);
     }
     takeParkedContinuationReservation(admission) {
+        if (this.#handoffHold)
+            return undefined;
         return this.#admissions.takeParked(admission);
     }
     clearParkedContinuationAdmission(admission) {
@@ -255,6 +330,163 @@ export class RootTurnCoordinator {
     beginDrain() {
         this.#admissions.beginDrain();
     }
+    async prepareHandoff(hostEpoch, signal) {
+        if (this.#handoffHold || this.#admissions.isDraining || signal.aborted)
+            return undefined;
+        const hold = deferred();
+        this.#handoffHold = hold;
+        const held = new Map();
+        let sealed = false;
+        let detached = false;
+        const releaseHold = () => {
+            if (this.#handoffHold === hold) {
+                this.#handoffHold = undefined;
+                this.#cancelHandoff = undefined;
+            }
+            hold.resolve();
+            signal.removeEventListener('abort', cancel);
+        };
+        const cancel = () => {
+            if (detached)
+                return;
+            sealed = false;
+            for (const [active, { request, attachment }] of held) {
+                request.cancel();
+                attachment.arrived.resolve();
+                attachment.decision.resolve('resume');
+                if (active.handoff === attachment)
+                    active.handoff = undefined;
+            }
+            releaseHold();
+        };
+        this.#cancelHandoff = cancel;
+        signal.addEventListener('abort', cancel, { once: true });
+        try {
+            await waitForHostedExecutionIdleOrAbort(this.#admissions.waitForSettledAdmissions(), signal);
+            // Natural completion can hand a queued follow-up to a fresh root while
+            // gates converge. Bound that convergence; never chase an endless queue.
+            for (let pass = 0; pass < 3; pass += 1) {
+                for (const [, active] of this.#executions.entries()) {
+                    if (held.has(active))
+                        continue;
+                    await waitForHostedExecutionIdleOrAbort(active.startSettled.promise, signal);
+                    if (this.#executions.get(active.sessionId) !== active)
+                        continue;
+                    const request = this.manager.requestRunHandoff(active.sessionId, active.continuation?.runId ?? active.runId, {
+                        protocol: 'runtime_handoff_pause_v1',
+                        hostEpoch,
+                        handoffId: randomUUID(),
+                        rootRunId: active.runId,
+                        successorRunId: randomUUID(),
+                        successorInvocationId: randomUUID(),
+                        claimId: randomUUID(),
+                    }, signal);
+                    if (!request) {
+                        cancel();
+                        return undefined;
+                    }
+                    const attachment = {
+                        decision: valueDeferred(),
+                        arrived: deferred(),
+                    };
+                    active.handoff = attachment;
+                    held.set(active, { request, attachment });
+                }
+                for (const [active, item] of held) {
+                    if (await waitForAbortableValue(item.request.ready, signal))
+                        continue;
+                    const snapshot = await this.readCanonicalSnapshot(active.sessionId, active.turnId, active.runId);
+                    if (!isTerminalSnapshot(snapshot)) {
+                        cancel();
+                        return undefined;
+                    }
+                    item.attachment.decision.resolve('resume');
+                    if (active.handoff === item.attachment)
+                        active.handoff = undefined;
+                    await waitForHostedExecutionIdleOrAbort(active.done, signal);
+                    held.delete(active);
+                }
+                if ([...this.#executions.entries()].every(([, active]) => held.has(active)))
+                    break;
+            }
+            if (signal.aborted ||
+                [...this.#executions.entries()].some(([, active]) => !held.has(active))) {
+                cancel();
+                return undefined;
+            }
+            return {
+                executions: [...held.keys()].map(({ sessionId, turnId, runId }) => ({
+                    sessionId,
+                    turnId,
+                    runId,
+                })),
+                seal: async () => {
+                    if (signal.aborted || this.#handoffHold !== hold || detached)
+                        return false;
+                    if (sealed)
+                        return true;
+                    for (const [active, { request }] of held) {
+                        if (this.#executions.get(active.sessionId) !== active || !request.commit()) {
+                            cancel();
+                            return false;
+                        }
+                    }
+                    try {
+                        const results = await Promise.all([...held.values()].map(({ request }) => request.sealed));
+                        sealed = !signal.aborted && this.#handoffHold === hold && results.every(Boolean);
+                        if (sealed) {
+                            await Promise.all([...held].map(([active, { attachment }]) => Promise.race([
+                                attachment.arrived.promise,
+                                active.done.then(() => {
+                                    throw new Error('Sealed execution ended before its attachment handoff');
+                                }),
+                            ])));
+                        }
+                    }
+                    catch (error) {
+                        cancel();
+                        throw error;
+                    }
+                    if (!sealed)
+                        cancel();
+                    return sealed;
+                },
+                residencies: async () => {
+                    if (!sealed || signal.aborted || this.#handoffHold !== hold || detached)
+                        return undefined;
+                    const residencies = [];
+                    for (const [active, { attachment }] of held) {
+                        if (this.#executions.get(active.sessionId) !== active ||
+                            active.handoff !== attachment ||
+                            active.stopRequested)
+                            return undefined;
+                        const messages = await this.sessionAdmission.run(active.sessionId, (lease) => this.messages.handoffResidencies(active, lease));
+                        if (!messages)
+                            return undefined;
+                        residencies.push(active.residency, ...messages);
+                    }
+                    return residencies;
+                },
+                detach: async () => {
+                    if (!sealed || signal.aborted || this.#handoffHold !== hold || detached) {
+                        throw new Error('Cannot detach a handoff without all durable seals');
+                    }
+                    detached = true;
+                    for (const { attachment } of held.values())
+                        attachment.decision.resolve('detach');
+                    await Promise.all([...held.keys()].map((active) => active.done));
+                    releaseHold();
+                },
+                cancel,
+            };
+        }
+        catch (error) {
+            cancel();
+            if (signal.aborted)
+                return undefined;
+            throw error;
+        }
+    }
     async runExclusiveSessionOperation(input, operation) {
         const { sessionId, abortSignal } = input;
         let reservation;
@@ -270,7 +502,7 @@ export class RootTurnCoordinator {
             }
             const active = this.#executions.get(sessionId);
             const pending = this.#admissions.get(sessionId);
-            const whenIdle = active?.done ?? pending?.whenIdle.promise;
+            const whenIdle = active?.done ?? pending?.whenIdle.promise ?? this.#handoffHold?.promise;
             if (whenIdle) {
                 await waitForHostedExecutionIdleOrAbort(whenIdle, abortSignal);
             }
@@ -319,6 +551,8 @@ export class RootTurnCoordinator {
                 reason: 'Runtime Host execution authority is draining.',
             };
         }
+        if (this.#handoffHold)
+            return { kind: 'busy', whenIdle: this.#handoffHold.promise };
         const active = this.#executions.get(sessionId);
         if (active) {
             return {
@@ -368,7 +602,10 @@ export class RootTurnCoordinator {
         if (isWorkHubCoordinationSessionId(input.sessionId)) {
             return Promise.reject(new RuntimeHostedRootUnavailableError(input.sessionId, WORKHUB_COORDINATION_EXECUTION_UNAVAILABLE_REASON));
         }
-        return this.runCommand(async () => {
+        // Admission is active work even while queued behind a Session gate. Its
+        // residency overlaps the execution residency until admission settles.
+        const residency = this.acquireRecoveryResidency();
+        const admission = this.runCommand(async () => {
             const activeAtEntry = this.#executions.has(input.sessionId);
             let reservation = preparedReservation ?? (activeAtEntry ? undefined : this.reserveRootTurn(input.sessionId));
             if (preparedReservation && this.#admissions.get(input.sessionId) !== preparedReservation) {
@@ -477,6 +714,7 @@ export class RootTurnCoordinator {
                 throw error.cause;
             throw error;
         });
+        return admission.finally(() => residency.release());
     }
     lookup(sessionId, turnId) {
         return this.runCommand(async () => {
@@ -499,6 +737,7 @@ export class RootTurnCoordinator {
     async requestStop(input) {
         await this.stopRoot(input.execution, {
             ...(input.source ? { source: input.source } : {}),
+            ...(input.workHubActionId !== undefined ? { workHubActionId: input.workHubActionId } : {}),
             ...(input.mode ? { mode: input.mode } : {}),
         });
         return await this.read(input.execution);
@@ -510,9 +749,12 @@ export class RootTurnCoordinator {
         return this.#executions.subscribe(listener);
     }
     whenIdle(sessionId) {
-        return (this.#executions.get(sessionId)?.done ?? this.#admissions.get(sessionId)?.whenIdle.promise);
+        return (this.#executions.get(sessionId)?.done ??
+            this.#admissions.get(sessionId)?.whenIdle.promise ??
+            this.#handoffHold?.promise);
     }
     stopRoot(identity, input = {}) {
+        normalizeStopSessionSource(input.source, input.workHubActionId);
         return this.runCommand(async () => {
             const declared = await this.sessionAdmission.run(identity.sessionId, (lease) => this.declareStopFence(identity, () => this.messages.commitStopFence(identity), lease, input));
             await declared?.deliverStop();
@@ -530,6 +772,7 @@ export class RootTurnCoordinator {
         });
     }
     stopSession(sessionId, input = {}) {
+        normalizeStopSessionSource(input.source, input.workHubActionId);
         return this.runCommand(async () => {
             const declared = await this.sessionAdmission.run(sessionId, (lease) => {
                 const active = this.#executions.get(sessionId);
@@ -594,7 +837,8 @@ export class RootTurnCoordinator {
         return this.runCommand(async () => {
             const content = normalizeMessageContent(input.content);
             if (input.sourceMessage.disposition !== 'turn_started' ||
-                !messageContentsEqual(input.sourceMessage.content, content)) {
+                (!input.preparedSkillInvocation &&
+                    !messageContentsEqual(input.sourceMessage.content, content))) {
                 throw new RuntimeMessageAuthorityInvariantError('Idle Message start lost its canonical turn_started source');
             }
             if (this.#executions.has(input.sessionId)) {
@@ -612,9 +856,19 @@ export class RootTurnCoordinator {
                 const runId = input.runId ?? randomUUID();
                 const skillIds = input.skillIds ?? [];
                 const hasSkillInvocation = skillIds.length > 0 || parseSkillInvocationTokens(content.text).length > 0;
-                const prepared = hasSkillInvocation
-                    ? await this.prepareHostedSkillInvocationContent(input.sessionId, turnId, content, skillIds, input.initiatingConnectionId)
-                    : { kind: 'ready', content };
+                const prepared = input.preparedSkillInvocation
+                    ? {
+                        kind: 'ready',
+                        content,
+                        skillInvocation: input.preparedSkillInvocation,
+                    }
+                    : hasSkillInvocation
+                        ? await this.prepareHostedSkillInvocationContent(input.sessionId, turnId, content, skillIds, input.initiatingConnectionId)
+                        : {
+                            kind: 'ready',
+                            content,
+                            skillInvocation: { loaded: [], failed: [], receipts: [] },
+                        };
                 if (prepared.kind === 'rejected') {
                     // Skill resolution is the only rejection a client can act on, so it
                     // travels back as structured feedback instead of an opaque error.
@@ -626,7 +880,12 @@ export class RootTurnCoordinator {
                             : prepared.outcome.error.message,
                     };
                 }
-                const canonicalContent = preflightRootMessageContent(prepared.content);
+                const skillInvocation = prepared.skillInvocation ?? {
+                    loaded: [],
+                    failed: [],
+                    receipts: [],
+                };
+                const canonicalContent = preflightRootMessageContent(this.validateDirectoryReferences(input.sessionId, prepared.content));
                 if (!canonicalContent.ok)
                     return { error: 'Prepared message content exceeds durable limits' };
                 const binding = prepared.commitCapabilityBinding
@@ -638,7 +897,7 @@ export class RootTurnCoordinator {
                     return { error: 'Root Turn reservation is no longer current' };
                 }
                 await this.prepareFreshAgentGraphEpoch(header, input.turnOrchestration);
-                await commitAdmission(canonicalContent.content);
+                await commitAdmission(canonicalContent.content, skillInvocation);
                 const admitted = await this.rootAdmissionOwner.admitRootTurn({
                     sessionId: input.sessionId,
                     turnId,
@@ -646,15 +905,16 @@ export class RootTurnCoordinator {
                     proposedUserMessageId: input.sourceMessage.messageId,
                     execution: {
                         kind: 'external_message',
-                        inputDigest: messageContentDigest(content),
+                        inputDigest: input.sourceMessage.submittedContentDigest ?? messageContentDigest(content),
                     },
                     normalizedInput: canonicalContent.content,
                     ...(input.turnOrchestration ? { turnOrchestration: input.turnOrchestration } : {}),
-                    ...(prepared.skillInvocation ? { skillInvocation: prepared.skillInvocation } : {}),
+                    skillInvocation,
                     sourceMessages: [
                         {
                             ...input.sourceMessage,
                             content: normalizeMessageContent(canonicalContent.content),
+                            skillInvocation,
                         },
                     ],
                     admittedAt: Date.now(),
@@ -679,7 +939,7 @@ export class RootTurnCoordinator {
                 }
                 return {
                     turnId,
-                    ...(prepared.skillInvocation ? { skillInvocation: prepared.skillInvocation } : {}),
+                    skillInvocation,
                 };
             }
             finally {
@@ -693,14 +953,27 @@ export class RootTurnCoordinator {
                 return { error: 'A root Turn is still active' };
             }
             const header = await this.stores.sessionStore.readHeaderSnapshot(input.sessionId);
-            const unavailableReason = runtimeHostExternalTurnUnavailableReason(header);
+            const turnId = input.rootIdentity?.turnId ?? randomUUID();
+            const previous = this.rootAdmissionOwner.latestAdmission(input.sessionId)?.execution;
+            let execution = {
+                kind: isWorkHubCoordinationSessionId(header.id)
+                    ? 'workhub_coordination'
+                    : 'external_message',
+                inputDigest: messageContentDigest(input.submittedContent),
+                ...(previous?.kind === 'workhub_coordination' && previous.capabilityBinding
+                    ? { capabilityBinding: previous.capabilityBinding }
+                    : {}),
+            };
+            if (!(await this.bindRecoveryCapabilities(input.sessionId, execution)))
+                return { deferred: true };
+            execution = await this.prepareFreshWorkHubExecution(header, turnId, input.content, execution);
+            const unavailableReason = runtimeHostExecutionUnavailableReason(header, execution);
             if (unavailableReason)
                 return { error: unavailableReason };
             const reservation = this.reserveRootTurn(input.sessionId);
             if (!reservation)
                 return { error: 'Another root Turn is being admitted' };
             try {
-                const turnId = input.rootIdentity?.turnId ?? randomUUID();
                 // The recovered Message asked for this mode before the Host stopped;
                 // admitting without it would run a different Turn than was requested.
                 const turnOrchestration = input.submittedIntent?.turnOrchestration;
@@ -710,10 +983,7 @@ export class RootTurnCoordinator {
                     turnId,
                     proposedRunId: input.rootIdentity?.runId ?? randomUUID(),
                     proposedUserMessageId: input.sources.length === 1 ? input.sources[0].messageId : null,
-                    execution: {
-                        kind: 'external_message',
-                        inputDigest: messageContentDigest(input.submittedContent),
-                    },
+                    execution,
                     normalizedInput: input.content,
                     ...(turnOrchestration ? { turnOrchestration } : {}),
                     sourceMessages: input.sources,
@@ -740,19 +1010,54 @@ export class RootTurnCoordinator {
             }
         });
     }
+    async prepareFreshWorkHubExecution(header, turnId, content, execution, inputClosedSignal) {
+        if (execution.kind !== 'workhub_coordination' || !this.prepareWorkHubRoutingDecision) {
+            return execution;
+        }
+        return {
+            ...execution,
+            routingDecision: await this.prepareWorkHubRoutingDecision({
+                header,
+                turnId,
+                content,
+                ...(inputClosedSignal ? { inputClosedSignal } : {}),
+            }),
+        };
+    }
     prepareMessage(input) {
         return this.runCommand(async () => {
             const content = normalizeMessageContent(input.content);
             if (parseSkillInvocationTokens(content.text).length === 0) {
-                return { kind: 'ready', content };
+                return {
+                    kind: 'ready',
+                    content: this.validateDirectoryReferences(input.sessionId, content),
+                    skillInvocation: { loaded: [], failed: [], receipts: [] },
+                };
             }
-            const prepare = () => this.prepareSkillInvocationContent(input.sessionId, input.turnId, content, []);
+            const prepare = async () => {
+                const prepared = await this.prepareSkillInvocationContent(input.sessionId, input.turnId, content, []);
+                return prepared.kind === 'ready'
+                    ? {
+                        ...prepared,
+                        content: this.validateDirectoryReferences(input.sessionId, prepared.content),
+                    }
+                    : prepared;
+            };
             if (input.placement === 'current_turn')
                 return prepare();
             const preview = await this.previewCapabilityBinding(input.sessionId, '', prepare);
             return preview.ok ? preview.value : { kind: 'rejected', error: preview.message };
         });
     }
+    validateDirectoryReferences(sessionId, content) {
+        if (!content.directoryReferences?.length)
+            return content;
+        if (!this.directoryHostId ||
+            content.directoryReferences.some((reference) => reference.hostId !== this.directoryHostId)) {
+            throw new RuntimeHostedRootUnavailableError(sessionId, 'Directory references belong to a different Runtime Host');
+        }
+        return content;
+    }
     claimStop(input, commitQueueFence, admission) {
         return this.runCommand(async () => {
             const disposition = await this.prepareStopDisposition(input, commitQueueFence, admission);
@@ -850,15 +1155,102 @@ export class RootTurnCoordinator {
         if (!isWorkHubCoordinationSessionId(request.sessionId)) {
             return Promise.resolve(operationUnavailable('WorkHub Coordination execution requires its reserved Session'));
         }
+        if ((request.execution.operation === 'action') !== (request.operation !== undefined)) {
+            return Promise.resolve(operationUnavailable('Coordination execution mode does not match its runner'));
+        }
         return this.startRootMessage(request, context);
     }
-    /**
-     * Whether a durable root Turn already owns this identity. WorkHub also writes
-     * Coordination Turns outside this coordinator, and must not append a second
-     * triplet into a Turn this admission ledger already owns.
-     */
-    async hasRootTurnAdmission(sessionId, turnId) {
-        return (await this.stores.agentRunStore.readRootTurnAdmission(sessionId, turnId)) !== undefined;
+    async runWorkHubCoordinationOperation(request, context) {
+        if (request.execution.operation !== 'action' || !request.operation) {
+            return operationUnavailable('Coordination action requires a Host operation');
+        }
+        let turnId = request.turnId;
+        let recoveredReceipt;
+        // A retry preserves the action identity, but never reopens a terminal Run.
+        // The existing admission chain and terminal facts identify prior attempts.
+        for (;;) {
+            const admission = await this.stores.agentRunStore.readRootTurnAdmission(request.sessionId, turnId);
+            if (!admission)
+                break;
+            if (!rootExecutionMatches(admission.execution, request.execution))
+                return operationConflict('Coordination action identity belongs to different content');
+            const run = await this.readRunIfPresent(request.sessionId, admission.runId);
+            if (!run)
+                break;
+            const snapshot = await this.readCanonicalSnapshot(request.sessionId, turnId, admission.runId, run);
+            if (!isTerminalSnapshot(snapshot) || snapshot.status === 'completed')
+                break;
+            // A crash after the receipt does not erase a completed Host effect.
+            const events = await this.stores.runtimeEventStore.readImmutableRuntimeEvents(request.sessionId, admission.runId);
+            recoveredReceipt ??= events.find((event) => event.actions?.coordination)?.actions
+                ?.coordination;
+            turnId = `whretry_${createHash('sha256').update(admission.runId).digest('hex').slice(0, 48)}`;
+        }
+        const receiptToReplay = recoveredReceipt;
+        const started = await this.startWorkHubCoordinationMessage({
+            ...request,
+            turnId,
+            ...(receiptToReplay ? { operation: async () => receiptToReplay } : {}),
+        }, context);
+        if (!started.ok)
+            return started;
+        const active = this.#executions.get(request.sessionId);
+        if (active?.turnId === turnId)
+            await active.done;
+        const snapshot = await this.readCanonicalSnapshot(request.sessionId, turnId, started.result.runId);
+        if (snapshot.status !== 'completed')
+            return operationUnavailable('Coordination operation did not complete');
+        const events = await this.stores.runtimeEventStore.readImmutableRuntimeEvents(request.sessionId, started.result.runId);
+        const receipt = events.find((event) => event.actions?.coordination)?.actions?.coordination;
+        return receipt
+            ? { ok: true, result: receipt }
+            : operationUnavailable('Coordination receipt is unavailable');
+    }
+    coordinationOperation(request, admission) {
+        if (request.execution.kind !== 'workhub_coordination' ||
+            !('operation' in request) ||
+            !request.operation)
+            return undefined;
+        const execute = request.operation;
+        const content = requireHostedExecutionMessageContent(admission);
+        return {
+            sessionId: admission.sessionId,
+            turnId: admission.turnId,
+            runId: admission.runId,
+            userMessageId: admission.userMessageId,
+            execution: admission.execution,
+            content,
+            start: ({ runId, userMessageId, onRunStarted }) => this.manager.runCoordinationOperation(admission.sessionId, { turnId: admission.turnId, ...content }, { runId, userMessageId, onRunStarted }, () => execute(admission.turnId)),
+        };
+    }
+    /** Accepts a model action against the exact live WorkHub root and its durable user input. */
+    async readActiveWorkHubRequest(turnId) {
+        return (await this.readActiveWorkHubRoutingRequest(turnId))?.content;
+    }
+    /** Reads both user authority and the advisory routing decision of the exact live WorkHub Turn. */
+    readActiveWorkHubRoutingRequest(turnId) {
+        const sessionId = WORKHUB_COORDINATION_SESSION_ID;
+        return this.sessionAdmission.run(sessionId, async () => {
+            const active = this.#executions.get(sessionId);
+            if (!active || active.turnId !== turnId)
+                return undefined;
+            const [admission, header] = await Promise.all([
+                this.stores.agentRunStore.readRootTurnAdmission(sessionId, turnId),
+                this.stores.sessionStore.readHeaderSnapshot(sessionId),
+            ]);
+            if (this.#executions.get(sessionId) !== active ||
+                admission?.runId !== active.runId ||
+                admission.execution.kind !== 'workhub_coordination' ||
+                header.toolProfile !== 'workhub-coordination-v2')
+                return undefined;
+            return {
+                runId: active.runId,
+                content: requireHostedExecutionMessageContent(admission),
+                ...(admission.execution.routingDecision
+                    ? { decision: admission.execution.routingDecision }
+                    : {}),
+            };
+        });
     }
     startRootMessage(request, context) {
         return this.runCommand(async () => {
@@ -875,7 +1267,7 @@ export class RootTurnCoordinator {
                     if (existing.execution.kind !== request.execution.kind) {
                         return completedStart(operationConflict('Turn identity belongs to a different execution kind'));
                     }
-                    if (!isDeepStrictEqual(existing.execution, request.execution)) {
+                    if (!rootExecutionMatches(existing.execution, request.execution)) {
                         return completedStart(operationConflict('Turn identity belongs to a different execution payload'));
                     }
                     let content;
@@ -901,7 +1293,7 @@ export class RootTurnCoordinator {
                             return completedStart({ ok: true, result: snapshot });
                         }
                     }
-                    return this.prepareAdmittedTurn(activationInputForAdmission(existing), existing, context.acquireResidency, lease, undefined, undefined, reservation);
+                    return this.prepareAdmittedTurn(activationInputForAdmission(existing), existing, context.acquireResidency, lease, undefined, this.coordinationOperation(request, existing), reservation);
                 }
                 reservation ??= this.reserveRootTurn(request.sessionId);
                 if (!reservation) {
@@ -936,7 +1328,7 @@ export class RootTurnCoordinator {
                 const prepared = await this.prepareRootMessageContent(request, lease);
                 if (prepared.kind === 'rejected')
                     return completedStart(prepared.outcome);
-                const canonicalContent = preflightRootMessageContent(prepared.content);
+                const canonicalContent = preflightRootMessageContent(this.validateDirectoryReferences(request.sessionId, prepared.content));
                 if (!canonicalContent.ok)
                     return completedStart(canonicalContent.outcome);
                 const attachments = canonicalContent.content.attachments ?? [];
@@ -946,14 +1338,30 @@ export class RootTurnCoordinator {
                 const attachmentError = await this.attachmentValidator?.validateTurnAttachments(request.sessionId, attachments);
                 if (attachmentError)
                     return completedStart(operationConflict(attachmentError));
-                const binding = request.execution.kind === 'workhub_coordination'
-                    ? undefined
-                    : prepared.commitCapabilityBinding
-                        ? await prepared.commitCapabilityBinding()
-                        : await this.clientCapabilities?.bindSession(request.sessionId, context.connectionId);
+                const isWorkHubV2 = request.execution.kind === 'workhub_coordination' &&
+                    header.toolProfile === 'workhub-coordination-v2';
+                const workHubBinding = isWorkHubV2
+                    ? await this.clientCapabilities?.bindSession(request.sessionId, context.connectionId, hostedExecutionRunProfile(header.toolProfile).toolNames.filter((name) => name.startsWith('mcp__')))
+                    : undefined;
+                const binding = isWorkHubV2
+                    ? workHubBinding
+                    : request.execution.kind === 'workhub_coordination' &&
+                        header.toolProfile === 'workhub-coordination-v1'
+                        ? undefined
+                        : prepared.commitCapabilityBinding
+                            ? await prepared.commitCapabilityBinding()
+                            : await this.clientCapabilities?.bindSession(request.sessionId, context.connectionId);
                 if (binding && !binding.ok) {
                     return completedStart(operationConflict(binding.message));
                 }
+                const capabilityBinding = workHubBinding?.ok ? workHubBinding.capabilityBinding : undefined;
+                if (isWorkHubV2 && !capabilityBinding) {
+                    return completedStart(operationUnavailable('WorkHub Desktop capability binding is unavailable'));
+                }
+                const freshExecution = await this.prepareFreshWorkHubExecution(header, request.turnId, canonicalContent.content, {
+                    ...request.execution,
+                    ...(capabilityBinding ? { capabilityBinding } : {}),
+                }, context.inputClosedSignal);
                 if (!this.beginRootAdmission(reservation)) {
                     return completedStart(sessionBusy('Root Turn reservation is no longer current'));
                 }
@@ -970,7 +1378,7 @@ export class RootTurnCoordinator {
                     // Turn kinds do not carry a user message and retain their own
                     // generated admission identity.
                     proposedUserMessageId: request.execution.kind === 'external_message' ? request.turnId : randomUUID(),
-                    execution: request.execution,
+                    execution: freshExecution,
                     normalizedInput: canonicalContent.content,
                     ...(request.turnOrchestration ? { turnOrchestration: request.turnOrchestration } : {}),
                     ...(prepared.skillInvocation ? { skillInvocation: prepared.skillInvocation } : {}),
@@ -986,7 +1394,7 @@ export class RootTurnCoordinator {
                 if (!rootMessageAdmissionMatches(admitted.admission, request, canonicalContent.content, context.turnAdmissionAuthorization)) {
                     return completedStart(operationConflict('Turn identity was already admitted with a different payload'));
                 }
-                return this.prepareAdmittedTurn(activationInputForAdmission(admitted.admission), admitted.admission, context.acquireResidency, lease, undefined, undefined, reservation);
+                return this.prepareAdmittedTurn(activationInputForAdmission(admitted.admission), admitted.admission, context.acquireResidency, lease, undefined, this.coordinationOperation(request, admitted.admission), reservation);
             });
             const disposition = await admissionTask.finally(() => {
                 if (reservation)
@@ -1248,6 +1656,12 @@ export class RootTurnCoordinator {
                     sourceMessages: [],
                     admittedAt: Date.now(),
                 });
+                if (admitted.kind === 'conflict') {
+                    return {
+                        kind: 'complete',
+                        outcome: operationConflict('This root execution already has a different continuation Turn'),
+                    };
+                }
                 if (admitted.admission.runId !== continuation.runId ||
                     !isDeepStrictEqual(admitted.admission.execution, execution)) {
                     throw new RuntimeMessageAuthorityInvariantError('Safe-boundary continuation admission changed identity');
@@ -1266,9 +1680,19 @@ export class RootTurnCoordinator {
         });
     }
     async planTurnResume(input) {
-        const plan = input.sourceRunId
+        let sourceRunId = input.sourceRunId;
+        if (sourceRunId) {
+            const run = await this.readRunIfPresent(input.sessionId, sourceRunId);
+            if (run?.terminalEvent && runtimeHandoffPause(run.terminalEvent)) {
+                const logical = await readLogicalRuntimeExecutionForRun(this.stores.runtimeEventStore, run);
+                // Queries may name the stable public root. The returned plan and the
+                // subsequent start must still bind the exact physical source/high-water.
+                sourceRunId = logical?.tip.runId ?? sourceRunId;
+            }
+        }
+        const plan = sourceRunId
             ? await this.manager.planAuthoritativeSafeBoundaryContinuation(input.sessionId, {
-                sourceRunId: input.sourceRunId,
+                sourceRunId,
                 ...(input.expectedRuntimeEventHighWater !== undefined
                     ? {
                         expectedRuntimeEventHighWater: input.expectedRuntimeEventHighWater,
@@ -1327,9 +1751,9 @@ export class RootTurnCoordinator {
         }
         const fence = commitQueueFence();
         await this.messages.cancelMessages(input.sessionId, fence.retracted.map((message) => message.messageId));
-        await this.interactions.claimRunClosure(input, 'turn_stopped', admission);
+        await this.interactions.claimRunClosure({ ...input, runId: active.continuation?.runId ?? active.runId }, 'turn_stopped', admission);
         const shouldDeliverStop = !active.stopRequested;
-        active.stopRequested = true;
+        active.stopRequested = stopInput;
         return {
             active,
             deliverStop: () => shouldDeliverStop
@@ -1354,7 +1778,7 @@ export class RootTurnCoordinator {
             if (active?.turnId === input.turnId && active.runId === input.runId) {
                 const fence = commitQueueFence();
                 await this.messages.cancelMessages(input.sessionId, fence.retracted.map((message) => message.messageId));
-                active.stopRequested = true;
+                active.stopRequested ??= { source: 'stop_button' };
                 return { kind: 'await_terminal', active };
             }
             return { kind: 'complete', outcome: { ok: true, result: snapshot } };
@@ -1377,9 +1801,9 @@ export class RootTurnCoordinator {
         }
         const fence = commitQueueFence();
         await this.messages.cancelMessages(input.sessionId, fence.retracted.map((message) => message.messageId));
-        await this.interactions.claimRunClosure(input, 'turn_stopped', admissionLease);
+        await this.interactions.claimRunClosure({ ...input, runId: active.continuation?.runId ?? active.runId }, 'turn_stopped', admissionLease);
         const shouldRequestStop = !active.stopRequested;
-        active.stopRequested = true;
+        active.stopRequested ??= { source: 'stop_button' };
         return shouldRequestStop
             ? { kind: 'request_stop', active }
             : { kind: 'await_terminal', active };
@@ -1420,7 +1844,19 @@ export class RootTurnCoordinator {
             }
             if (active)
                 return completedStart(sessionBusy('Session already has an active root Turn'));
-            throw new Error('Admitted non-terminal Turn has no active Runtime Host execution');
+            const logical = await readLogicalRuntimeExecution(this.stores.runtimeEventStore, admission, existingRun);
+            if (!logical?.pendingHandoff) {
+                throw new Error('Admitted non-terminal Turn has no active Runtime Host execution');
+            }
+            const plan = await this.manager.planAuthoritativeSafeBoundaryContinuation(input.sessionId, {
+                sourceRunId: logical.tip.runId,
+                purpose: 'handoff',
+            });
+            if (!plan.continuation) {
+                this.parkContinuationAdmission(admission);
+                return completedStart(operationUnavailable(`Sealed handoff cannot resume: ${plan.rejectionReasons.join(', ')}`));
+            }
+            continuation = plan.continuation;
         }
         const active = this.#executions.get(input.sessionId);
         const currentReservation = this.#admissions.get(input.sessionId);
@@ -1453,6 +1889,9 @@ export class RootTurnCoordinator {
         try {
             this.messages.reserveRootTurn(messageIdentity);
             messageReserved = true;
+            if (continuation?.handoffRootRunId !== undefined) {
+                await this.messages.advanceHandoffRun(messageIdentity, continuation.runId, admissionLease);
+            }
             await this.continuity.holdTerminalPublication(input.sessionId, input.turnId, runId, admissionLease);
         }
         catch (error) {
@@ -1483,7 +1922,7 @@ export class RootTurnCoordinator {
             startSettled,
             done: Promise.resolve(),
             residency,
-            stopRequested: false,
+            stopRequested: undefined,
             messageTransitionCommitted: false,
         };
         if (replacing && this.#executions.get(input.sessionId) !== replacing) {
@@ -1496,7 +1935,7 @@ export class RootTurnCoordinator {
             }
         }
         this.#executions.activate(entry, replacing);
-        entry.done = this.drainTurn(input, entry, startSettled);
+        entry.done = this.sessionAdmission.detach(() => this.drainTurn(input, entry, startSettled));
         void entry.done.catch(() => undefined);
         if (rootReservation) {
             this.#admissions.activated(rootReservation, entry.done);
@@ -1549,6 +1988,7 @@ export class RootTurnCoordinator {
     }
     async drainTurn(input, active, startSettled) {
         let terminalTransitionStarted = false;
+        let detached = false;
         try {
             const messageOrigin = hostedExecutionMessageOrigin(active.descriptor);
             const onRunStarted = async () => {
@@ -1556,46 +1996,80 @@ export class RootTurnCoordinator {
                 await this.continuity.refreshCanonical(input.sessionId);
                 startSettled.resolve();
             };
-            const stream = active.execution
-                ? active.execution.start({
-                    runId: active.runId,
-                    userMessageId: active.userMessageId,
-                    onRunStarted: async () => {
-                        await onRunStarted();
-                        await active.execution?.onReady?.();
-                    },
+            let stream = active.continuation
+                ? this.manager.resumeSafeBoundaryContinuation(active.continuation, {
+                    onRunStarted,
+                    stopBeforeDispatch: () => active.stopRequested,
                 })
-                : active.descriptor.kind === 'context_compact'
-                    ? this.manager.compactSession(input.sessionId, {
-                        turnId: input.turnId,
-                        hostedRoot: {
-                            runId: active.runId,
-                            onRunStarted,
+                : active.execution
+                    ? active.execution.start({
+                        runId: active.runId,
+                        userMessageId: active.userMessageId,
+                        onRunStarted: async () => {
+                            await onRunStarted();
+                            await active.execution?.onReady?.();
                         },
                     })
-                    : active.continuation
-                        ? this.manager.resumeSafeBoundaryContinuation(active.continuation, {
-                            onRunStarted,
+                    : active.descriptor.kind === 'context_compact'
+                        ? this.manager.compactSession(input.sessionId, {
+                            turnId: input.turnId,
+                            hostedRoot: {
+                                runId: active.runId,
+                                onRunStarted,
+                            },
                         })
-                        : this.startRootMessageTurn(input, active, normalizeMessageContent(requireRootMessageContent(input)), messageOrigin, onRunStarted);
-            for await (const event of stream) {
-                if (active.execution?.onEvent) {
-                    try {
-                        active.execution.onEvent(event);
+                        : active.continuation
+                            ? this.manager.resumeSafeBoundaryContinuation(active.continuation, {
+                                onRunStarted,
+                            })
+                            : this.startRootMessageTurn(input, active, normalizeMessageContent(requireRootMessageContent(input)), messageOrigin, onRunStarted);
+            for (;;) {
+                for await (const event of stream) {
+                    if (active.execution?.onEvent) {
+                        try {
+                            active.execution.onEvent(event);
+                        }
+                        catch {
+                            // Presentation observers do not participate in execution authority.
+                        }
                     }
-                    catch {
-                        // Presentation observers do not participate in execution authority.
+                    if (isRuntimeSessionForwardedEvent(event)) {
+                        await this.continuity.acceptRuntimeEvent(input.sessionId, active.runId, event);
+                    }
+                    else if (isInteractionAnswerAck(event)) {
+                        await this.continuity.refreshCanonical(input.sessionId);
+                    }
+                    else if (event.type === 'user_question_request' || event.type === 'form_request') {
+                        this.continuity.enqueueCanonicalRefresh(input.sessionId);
                     }
                 }
-                if (isRuntimeSessionForwardedEvent(event)) {
-                    await this.continuity.acceptRuntimeEvent(input.sessionId, active.runId, event);
-                }
-                else if (isInteractionAnswerAck(event)) {
-                    await this.continuity.refreshCanonical(input.sessionId);
-                }
-                else if (event.type === 'user_question_request') {
-                    this.continuity.enqueueCanonicalRefresh(input.sessionId);
+                const logical = await readLogicalRuntimeExecution(this.stores.runtimeEventStore, active);
+                if (!logical?.pendingHandoff)
+                    break;
+                const handoff = active.handoff;
+                handoff?.arrived.resolve();
+                if (handoff && (await handoff.decision.promise) === 'detach') {
+                    await this.sessionAdmission.run(input.sessionId, (lease) => this.messages.detachHandoffRoot(active, lease));
+                    detached = true;
+                    return;
                 }
+                await this.sessionAdmission.run(input.sessionId, async (lease) => {
+                    if (this.#executions.get(input.sessionId) !== active) {
+                        throw new RuntimeMessageAuthorityInvariantError('Sealed handoff lost its original root owner');
+                    }
+                    const plan = await this.manager.planAuthoritativeSafeBoundaryContinuation(input.sessionId, {
+                        sourceRunId: logical.tip.runId,
+                        purpose: 'handoff',
+                    });
+                    if (!plan.continuation)
+                        throw new Error(`Sealed handoff cannot resume: ${plan.rejectionReasons.join(', ')}`);
+                    await this.messages.advanceHandoffRun(active, plan.continuation.runId, lease);
+                    active.continuation = plan.continuation;
+                });
+                stream = this.manager.resumeSafeBoundaryContinuation(active.continuation, {
+                    onRunStarted,
+                    stopBeforeDispatch: () => active.stopRequested,
+                });
             }
             const snapshot = await this.readCanonicalSnapshot(input.sessionId, input.turnId, active.runId);
             await this.assertCompletedExecutionIdentity(input, active);
@@ -1638,7 +2112,7 @@ export class RootTurnCoordinator {
                                 ((!active.stopRequested &&
                                     snapshot.status === 'failed' &&
                                     isContainableRunFailure(error)) ||
-                                    (active.stopRequested &&
+                                    (Boolean(active.stopRequested) &&
                                         snapshot.status === 'cancelled' &&
                                         isStoppedInteractionAdmission(error)));
                     }
@@ -1656,36 +2130,43 @@ export class RootTurnCoordinator {
                 reason: errorMessage(commandFailure),
             });
             startSettled.reject(commandFailure);
-            this.requestHostDrain();
+            if (!isShutdownCancelledInteractionAdmission(commandFailure))
+                this.requestHostDrain();
             throw commandFailure;
         }
         finally {
-            this.observeExecutionCompletion(active, {
-                kind: 'authority_error',
-                execution: active,
-                reason: 'Runtime root Turn ended without a canonical completion.',
-            });
-            await active.observationSettled?.catch(() => this.requestHostDrain());
-            let releaseRootOwnership = active.messageTransitionCommitted;
-            if (!active.messageTransitionCommitted) {
-                try {
-                    this.messages.abandonRootReservation({
-                        sessionId: input.sessionId,
-                        turnId: active.turnId,
-                        runId: active.runId,
-                    });
-                    releaseRootOwnership = true;
-                }
-                catch {
-                    this.requestHostDrain();
-                }
-            }
-            if (releaseRootOwnership) {
+            if (detached) {
                 this.#executions.release(active);
                 active.residency.release();
             }
-            active.completion.resolve(active.observedCompletion);
-            this.#executions.publish(active);
+            else {
+                this.observeExecutionCompletion(active, {
+                    kind: 'authority_error',
+                    execution: active,
+                    reason: 'Runtime root Turn ended without a canonical completion.',
+                });
+                await active.observationSettled?.catch(() => this.requestHostDrain());
+                let releaseRootOwnership = active.messageTransitionCommitted;
+                if (!active.messageTransitionCommitted) {
+                    try {
+                        this.messages.abandonRootReservation({
+                            sessionId: input.sessionId,
+                            turnId: active.turnId,
+                            runId: active.runId,
+                        });
+                        releaseRootOwnership = true;
+                    }
+                    catch {
+                        this.requestHostDrain();
+                    }
+                }
+                if (releaseRootOwnership) {
+                    this.#executions.release(active);
+                    active.residency.release();
+                }
+                active.completion.resolve(active.observedCompletion);
+                this.#executions.publish(active);
+            }
         }
     }
     async materializeAdmittedMessageSources(active) {
@@ -1724,7 +2205,7 @@ export class RootTurnCoordinator {
                 turnId: active.turnId,
                 runId: active.runId,
             };
-            await this.interactions.assertTerminalFence(identity, lease);
+            await this.interactions.assertTerminalFence({ ...identity, runId: active.continuation?.runId ?? active.runId }, lease);
             const batch = this.messages.beginTerminalTransition(identity);
             await this.continuity.publishTerminalProjection(sessionId, active.turnId, active.runId, lease);
             if (batch.sources.length === 0) {
@@ -1744,15 +2225,22 @@ export class RootTurnCoordinator {
         const turnId = randomUUID();
         const header = await this.stores.sessionStore.readHeaderSnapshot(batch.sessionId);
         await this.prepareFreshAgentGraphEpoch(header);
+        const execution = await this.prepareFreshWorkHubExecution(header, turnId, batch.content, {
+            kind: previous.descriptor.kind === 'workhub_coordination'
+                ? 'workhub_coordination'
+                : 'external_message',
+            inputDigest: messageContentDigest(batch.submittedContent),
+            ...(previous.descriptor.kind === 'workhub_coordination' &&
+                previous.descriptor.capabilityBinding
+                ? { capabilityBinding: previous.descriptor.capabilityBinding }
+                : {}),
+        });
         const admitted = await this.rootAdmissionOwner.admitRootTurn({
             sessionId: batch.sessionId,
             turnId,
             proposedRunId: randomUUID(),
             proposedUserMessageId: batch.sources.length === 1 ? batch.sources[0].messageId : null,
-            execution: {
-                kind: 'external_message',
-                inputDigest: messageContentDigest(batch.submittedContent),
-            },
+            execution,
             normalizedInput: batch.content,
             sourceMessages: batch.sources,
             admittedAt: Date.now(),
@@ -1805,7 +2293,8 @@ export class RootTurnCoordinator {
         if (admission.execution.kind === 'context_compact')
             return undefined;
         const mode = admission.execution.kind === 'safe_boundary_continuation'
-            ? ((await this.stores.agentRunStore.readRun(admission.sessionId, admission.execution.sourceRunId)).orchestrationMode ??
+            ? ((await this.readRunIfPresent(admission.sessionId, admission.execution.sourceRunId))
+                ?.opening.configuration.orchestrationMode ??
                 resolveEffectiveOrchestration(session.orchestrationMode, undefined).mode)
             : resolveEffectiveOrchestration(session.orchestrationMode, admission.turnOrchestration)
                 .mode;
@@ -1840,13 +2329,18 @@ export class RootTurnCoordinator {
         catch (error) {
             if (!(error instanceof RuntimeHostedRootConflictError) &&
                 !(error instanceof RuntimeHostedRootUnavailableError) &&
-                !(error instanceof HostedRootAdmissionGateError)) {
+                !(error instanceof HostedRootAdmissionGateError) &&
+                !isShutdownCancelledInteractionAdmission(error)) {
                 this.requestHostDrain();
             }
             throw error;
         }
     }
 }
+async function waitForAbortableValue(value, signal) {
+    await waitForHostedExecutionIdleOrAbort(value.then(() => undefined), signal);
+    return value;
+}
 class HostedRootAdmissionGateError extends Error {
     cause;
     name = 'HostedRootAdmissionGateError';
@@ -1879,8 +2373,27 @@ function throwHostedStopError(sessionId, outcome) {
             throw new RuntimeHostedRootUnavailableError(sessionId, outcome.error.message);
     }
 }
+/** Compare the request identity separately from its Host-selected capability binding. */
+function rootExecutionMatches(stored, incoming) {
+    if (stored.kind === 'workhub_coordination' && incoming.kind === 'workhub_coordination') {
+        const { capabilityBinding: _storedBinding, routingDecision: _storedDecision, ...storedIdentity } = stored;
+        const { capabilityBinding: _incomingBinding, routingDecision: _incomingDecision, actionId, ...incomingIdentity } = incoming;
+        if (incoming.routingDecision === undefined) {
+            return isDeepStrictEqual(storedIdentity, {
+                ...incomingIdentity,
+                ...(stored.actionId === undefined ? {} : { actionId }),
+            });
+        }
+        return isDeepStrictEqual({ ...storedIdentity, routingDecision: stored.routingDecision }, {
+            ...incomingIdentity,
+            ...(actionId === undefined ? {} : { actionId }),
+            routingDecision: incoming.routingDecision,
+        });
+    }
+    return isDeepStrictEqual(stored, incoming);
+}
 function rootMessageAdmissionMatches(admission, request, content, authorization) {
-    return (isDeepStrictEqual(admission.execution, request.execution) &&
+    return (rootExecutionMatches(admission.execution, request.execution) &&
         (request.execution.kind === 'external_message' && request.execution.inputDigest
             ? true
             : messageContentsEqual(requireHostedExecutionMessageContent(admission), content)) &&
@@ -2111,17 +2624,6 @@ function isTerminalSnapshot(snapshot) {
         snapshot.status === 'failed' ||
         snapshot.status === 'cancelled');
 }
-function isShutdownCancelledInteractionAdmission(error) {
-    // Drain can reach a running question admission before the Turn's stop fence
-    // closes its Interaction Run, so this expected cancellation is direct.
-    if (error instanceof RuntimeInteractionAdmissionRejectedError &&
-        error.reason === 'authority_draining') {
-        return true;
-    }
-    return (error instanceof RuntimeInteractionFailStopError &&
-        error.authorityFailure instanceof RuntimeInteractionAdmissionRejectedError &&
-        error.authorityFailure.reason === 'authority_draining');
-}
 function isContainableRunFailure(error) {
     return (error instanceof Error &&
         !(error instanceof RuntimeOwnerCleanupError) &&
@@ -2152,7 +2654,7 @@ function isRuntimeSessionForwardedEvent(event) {
         event.type === 'provider_retry');
 }
 function isInteractionAnswerAck(event) {
-    return event.type === 'user_question_answer_ack';
+    return event.type === 'user_question_answer_ack' || event.type === 'form_answer_ack';
 }
 function completedStart(outcome) {
     return { kind: 'complete', outcome };