@spine-event-engine/server 2.0.0-snapshot.24 → 2.0.0-snapshot.26

package/dist/repository/repository.js

@@ -11,21 +11,18 @@
  * or implied. See the License for the specific language governing permissions and limitations under
  * the License.
  */
-import { createHash, randomUUID } from "node:crypto";
 import { clone, create, equals, ScalarType, toBinary, } from "@bufbuild/protobuf";
-import { AnySchema, FileDescriptorProtoSchema, Int32ValueSchema, Int64ValueSchema, StringValueSchema, } from "@bufbuild/protobuf/wkt";
-import { ValidationException, RejectionThrowable, Validate, TypeUrls, AnyMessages, Identifiers, StringifierRegistry, Time, } from "@spine-event-engine/core";
+import { AnySchema, Int32ValueSchema, Int64ValueSchema, StringValueSchema, TimestampSchema, } from "@bufbuild/protobuf/wkt";
+import { ValidationException, RejectionThrowable, Validate, TypeUrls, AnyPacker, Identifiers, StringifierRegistry, Time, } from "@spine-event-engine/core";
 import { CommandContextSchema, ActorContextSchema, CommandIdSchema, CommandSchema, EventContextSchema, EventIdSchema, EventSchema, MessageIdSchema, TenantIdSchema, RejectionEventContextSchema, VersionSchema, EntityOption_Kind, } from "@spine-event-engine/proto";
 import * as EntityLog from "@spine-event-engine/proto/generated/spine/system/server/entity_log_events_pb.js";
 import { EntityTypeNameSchema } from "@spine-event-engine/proto/generated/spine/system/server/entity_type_pb.js";
 import { EntityRecordSchema, } from "@spine-event-engine/proto/generated/spine/server/entity/entity_pb.js";
 import { EventStore, StorageQueryPolicy, } from "@spine-event-engine/storage";
-import { TenantBoundary } from "@spine-event-engine/storage/provider";
+import { TenantBoundary, eventStoreAccess, StoragePreparations, } from "@spine-event-engine/storage/provider";
 import { EntityCommitStorageFactories } from "@spine-event-engine/storage/provider";
 import { AgentHistoryStorageFactories, } from "@spine-event-engine/storage/provider";
-import { AgentExecutionStorageFactories, } from "@spine-event-engine/storage/provider";
-import { AgentHistoryEntrySchema, AgentInvocationTerminatedSchema, AgentModelSelectionChangedSchema as SelectionChangedSchema, AiModelKind, AiDiagnosticIdSchema, ModelRefSchema, ToolEffect, ConversationIdSchema, } from "@spine-event-engine/proto/agent";
-import { AgentInvocationKeySchema, AgentExecutionStartSchema, AgentExecutionCompletionSchema, AgentInvocationBoundsSchema, AgentInvocationStatus, AgentOutgoingCommandSchema, AgentSignalKeySchema, AgentSavedDispatchTargetSchema as SavedTargetSchema, AgentSavedRepositoryFamily, AgentSavedTargetKind, } from "@spine-event-engine/proto/generated/spine/server/agent/execution_record_pb.js";
+import { AgentHistoryEntrySchema, AgentInvocationTerminatedSchema, AgentModelSelectionChangedSchema as SelectionChangedSchema, AiModelKind, ModelRefSchema, ModelPreferenceSchema, ConversationRecordSchema, ConversationIdSchema, AgentHistoryCursorSchema, } from "@spine-event-engine/proto/agent";
 import { registryOptions } from "@spine-event-engine/ai/spi/runtime";
 import { CommandValidationError } from "../bus/command-errors.js";
 import { SignalPublisher } from "../runtime/signal-publisher.js";
@@ -35,21 +32,20 @@ import { CommandRoutingInternals, } from "./command-routing.js";
 import { EventRoutingInternals } from "./event-routing.js";
 import { StateUpdateRoutingInternals, } from "./state-update-routing.js";
 import { RoutingDeclarations } from "./routing-declarations.js";
+import { snapshotTrustedReader, } from "@spine-event-engine/core/spi/trusted-reader";
+import { Code, ConnectError } from "@connectrpc/connect";
 import { EventDispatcherOriginSchemas } from "../bus/event-dispatcher-origin-schemas.js";
-import { SavedDispatcherBindings, } from "../bus/saved-dispatcher-binding.js";
-import { Delivery } from "../delivery/delivery.js";
 import { receptionObservation } from "../delivery/reception-observation.js";
-import { commitFenced } from "./commit-fence.js";
-import { AgentHistoryReads } from "../agent/agent-history.js";
-import { AgentReadRuntime } from "../agent/agent-read-runtime.js";
-import { AgentAdmission } from "../agent/agent-admission.js";
-import { AgentRevisions } from "../agent/agent-revisions.js";
-import { AgentExecutionSession } from "../agent/agent-execution-session.js";
-import { AgentExecutionFault } from "../agent/agent-execution-fault.js";
+import { commitFenced, withDeliveryCommitFence } from "./commit-fence.js";
+import { AgentHistoryReads, } from "../agent/agent-history.js";
+import { AgentLiveAiRuntime } from "../agent/agent-live-ai-runtime.js";
+import { AgentLiveAudit } from "../agent/agent-live-audit.js";
+import { AgentLiveBudget } from "../agent/agent-live-budget.js";
+import { AgentLiveReadRuntime } from "../agent/agent-live-read-runtime.js";
+import { AgentLiveInteractionEvents } from "../agent/agent-live-interaction-events.js";
+import { AgentLiveFault } from "../agent/agent-live-fault.js";
+import { AgentDeliveryScope } from "../delivery/agent-delivery-scope.js";
 import { AgentModelSelection } from "../agent/agent-model-selection.js";
-import { AgentAiRuntime, AgentUncertainAttemptError } from "../agent/agent-ai-runtime.js";
-import { AgentInteractionEvents } from "../agent/agent-interaction-events.js";
-import { AgentInteractionAudit } from "../agent/agent-interaction-audit.js";
 import { AgentAiBindings } from "../agent/agent-ai-binding.js";
 import { InboxTargets } from "../delivery/inbox.js";
 import { ShardIndex } from "../delivery/shard-index.js";
@@ -150,12 +146,13 @@ export class Repository {
         return this.#metadata.schema;
     }
     /**
-     * Sets whether future state-history rows are appended for this repository.
+     * Sets state-history storage for future acquisitions. Admitted stores retain
+     * the setting captured when they began, and prior configurations stay reusable.
      *
      * This JVM-parity switch is for controlled administration/testing, not
      * routine request-time behavior. It never deletes or reconstructs history.
      *
-     * @param enabled Whether later successful stores append state-history rows.
+     * @param enabled Whether newly admitted stores append state-history rows.
      */
     setStateHistoryEnabled(enabled) {
         if (typeof enabled !== "boolean") {
@@ -165,12 +162,6 @@ export class Repository {
         if (configuration.stateHistory === enabled)
             return;
         configuration.stateHistory = enabled;
-        const handles = repositoryEntityHandles.get(this);
-        if (handles !== undefined) {
-            for (const handle of handles.values())
-                handle.close();
-            handles.clear();
-        }
     }
     /**
      * Returns descriptor metadata for this repository's Entity state.
@@ -216,19 +207,6 @@ export class Repository {
     agentHistory(id, scope) {
         return RepositoryAgentReads.history(this, id, scope);
     }
-    /**
-     * Reads the exact recorded phase for one accepted Command or Event.
-     * The trusted application must authorize the caller before using this read.
-     *
-     * @param this Registered Agent repository.
-     * @param id Typed Agent identifier.
-     * @param source Original Command or Event ID.
-     * @param scope Explicit tenant boundary; pass `{}` in a single-tenant Bounded Context.
-     * @returns Recorded phase, or `undefined` when no invocation was recorded.
-     */
-    agentExecution(id, source, scope) {
-        return RepositoryAgentReads.execution(this, id, source, scope);
-    }
     /**
      * Routes a command to one entity ID without invoking a handler.
      *
@@ -282,7 +260,14 @@ const RepositoryAgentReads = {
             : validated;
         const tenant = scope.tenantId === undefined ? undefined : RepositoryTenants.require(scope.tenantId);
         const context = RepositoryTenants.storageContextForTenant(runtime.context, tenant);
-        return { runtime, context, id: copiedId };
+        const readSide = {
+            ...(scope.actorContext === undefined
+                ? {}
+                : { actorContext: clone(ActorContextSchema, scope.actorContext) }),
+            ...(scope.reader === undefined ? {} : snapshotTrustedReader(scope.reader)),
+            ...(scope.signal === undefined ? {} : { signal: scope.signal }),
+        };
+        return { runtime, context, id: copiedId, readSide };
     },
     /**
      * Returns a detached public history request before provider access.
@@ -293,7 +278,9 @@ const RepositoryAgentReads = {
     request(request) {
         return {
             pageSize: request.pageSize,
-            ...(request.cursor === undefined ? {} : { cursor: request.cursor }),
+            ...(request.cursor === undefined
+                ? {}
+                : { cursor: clone(AgentHistoryCursorSchema, request.cursor) }),
         };
     },
     /**
@@ -337,28 +324,95 @@ const RepositoryAgentReads = {
      * @returns Detached history entries and opaque continuation.
      */
     async historyPage(repository, captured, view, request) {
+        this.checkCanceled(captured.readSide.signal);
         if (repositoryRuntimes.get(repository) !== captured.runtime)
             throw new Error("Agent read requires an active repository.");
+        await captured.runtime.onAdmit(captured.context.tenantId);
+        this.checkCanceled(captured.readSide.signal);
+        const page = await RepositoryStorage.track(repository, () => this.loadHistoryPage(repository, captured, view, request));
+        this.checkCanceled(captured.readSide.signal);
+        return page;
+    },
+    /**
+     * Rejects canceled public history reads even when no policy callback runs.
+     * @param signal Current caller cancellation, if supplied.
+     */
+    checkCanceled(signal) {
+        if (signal?.aborted)
+            throw new ConnectError("Read canceled.", Code.Canceled);
+    },
+    /**
+     * Reads a retained Agent page and transforms only its outward domain values.
+     *
+     * @param repository Registered Agent repository.
+     * @param captured Stable Entity, tenant, and reader facts.
+     * @param view Indexed history category.
+     * @param request Detached page request.
+     * @returns Visible entries and original continuation.
+     */
+    async loadHistoryPage(repository, captured, view, request) {
         const input = RepositoryStorage.entityStorageInput(repository, captured.context);
-        const history = AgentHistoryStorageFactories.create(captured.runtime.storageFactory, {
-            context: captured.context,
-            stateType: repository.stateSchema.typeName,
-            id: { key: input.id.key },
-        });
-        try {
-            const page = await AgentHistoryReads.readBound({
-                storage: history,
-                entityId: captured.id,
-                scope: repositoryAccess.agentHistoryScope(captured.context, input, captured.id),
-            }, view, request);
-            return {
-                items: page.items,
-                ...(page.nextCursor === undefined ? {} : { nextCursor: page.nextCursor }),
-            };
-        }
-        finally {
-            history.close();
-        }
+        const history = RepositoryStorage.openRepositoryAgentHistory(repository, captured.runtime.storageFactory, input);
+        const page = await AgentHistoryReads.readBound({
+            storage: history,
+            entityId: captured.id,
+            scope: repositoryAccess.agentHistoryScope(captured.context, input, captured.id),
+        }, view, request);
+        return this.visibleHistory(captured.runtime.stand, page, captured.id, view, request, captured.context.tenantId, captured.readSide);
+    },
+    /**
+     * Transforms returned Agent domain roots while retaining the original page cursor.
+     *
+     * @param stand Producing context's read policy.
+     * @param page Captured history page before outward transformation.
+     * @param entityId Agent identifier used for this call.
+     * @param view Requested history category.
+     * @param request Original page request.
+     * @param tenantId Effective tenant of this Agent.
+     * @param readSide Trusted in-process caller facts captured with the reader.
+     * @returns Visible entries with the provider's original continuation.
+     */
+    async visibleHistory(stand, page, entityId, view, request, tenantId, readSide = {}) {
+        const facts = {
+            operation: { kind: "history", history: { source: "agent", entityId, view, request } },
+            ...(tenantId === undefined ? {} : { effectiveTenant: tenantId }),
+            ...readSide,
+        };
+        const items = [];
+        for (const entry of page.items) {
+            const visible = await this.visibleEntry(stand, entry, facts);
+            if (visible !== undefined)
+                items.push(visible);
+        }
+        return { items, ...(page.nextCursor === undefined ? {} : { nextCursor: page.nextCursor }) };
+    },
+    /**
+     * Transforms one retained Agent entry without changing its wrapper or cursor.
+     *
+     * @param stand Producing context's outward read policy.
+     * @param entry Captured indexed history entry.
+     * @param facts Actual read operation and trusted invocation facts.
+     * @returns Visible entry, or undefined when policy removed its root.
+     */
+    async visibleEntry(stand, entry, facts) {
+        const item = entry.item;
+        let visible;
+        if (item.case === "conversationRecord") {
+            const value = await standAccess.filterState(stand, ConversationRecordSchema, item.value, facts);
+            if (value !== null)
+                visible = { case: "conversationRecord", value };
+        }
+        else if (item.case === "systemEvent" || item.case === "domainEvent") {
+            const value = await standAccess.filterEvent(stand, item.value, facts);
+            if (value !== null)
+                visible =
+                    item.case === "systemEvent"
+                        ? { case: "systemEvent", value }
+                        : { case: "domainEvent", value };
+        }
+        return visible === undefined
+            ? undefined
+            : create(AgentHistoryEntrySchema, { ...entry, item: visible });
     },
     /**
      * Returns one typed category from the full Proto history oneof.
@@ -379,76 +433,6 @@ const RepositoryAgentReads = {
             ...(page.nextCursor === undefined ? {} : { nextCursor: page.nextCursor }),
         };
     },
-    /**
-     * Reads the exact saved invocation and exposes only its phase.
-     *
-     * @param repository Registered Agent repository.
-     * @param id Typed Agent identifier.
-     * @param source Original Command or Event ID.
-     * @param scope Explicit tenant selection.
-     * @returns Current phase, or `undefined` for no saved invocation.
-     */
-    async execution(repository, id, source, scope) {
-        const captured = this.capture(repository, id, scope);
-        const sourceSignal = this.source(source);
-        const input = RepositoryStorage.entityStorageInput(repository, captured.context);
-        const key = create(AgentInvocationKeySchema, {
-            scope: { stateType: repository.stateSchema.typeName, agentKey: input.id.key(captured.id) },
-            sourceSignal,
-        });
-        if (repositoryRuntimes.get(repository) !== captured.runtime)
-            throw new Error("Agent read requires an active repository.");
-        const storage = AgentExecutionStorageFactories.create(captured.runtime.storageFactory, {
-            entity: input,
-            stateType: repository.stateSchema.typeName,
-        });
-        try {
-            const record = await storage.read(key);
-            return record === undefined ? undefined : this.status(record.status);
-        }
-        finally {
-            storage.close();
-        }
-    },
-    /**
-     * Copies an original signal identifier into the private execution key.
-     *
-     * @param source Original Command or Event ID.
-     * @returns Typed private source key.
-     */
-    source(source) {
-        if (source.$typeName === CommandIdSchema.typeName && source.uuid.length > 0)
-            return create(AgentSignalKeySchema, {
-                id: { case: "command", value: clone(CommandIdSchema, source) },
-            });
-        if (source.$typeName === EventIdSchema.typeName && source.value.length > 0)
-            return create(AgentSignalKeySchema, {
-                id: { case: "event", value: clone(EventIdSchema, source) },
-            });
-        throw new TypeError("Agent execution requires an original CommandId or EventId.");
-    },
-    /**
-     * Returns the public status for a private execution phase.
-     *
-     * @param status Saved private phase.
-     * @returns Public phase string.
-     */
-    status(status) {
-        switch (status) {
-            case AgentInvocationStatus.AGENT_INVOCATION_ACCEPTED:
-                return "accepted";
-            case AgentInvocationStatus.AGENT_INVOCATION_ACTIVE:
-                return "active";
-            case AgentInvocationStatus.AGENT_INVOCATION_COMPLETED_PENDING_COMMANDS:
-                return "completed-pending-commands";
-            case AgentInvocationStatus.AGENT_INVOCATION_COMPLETED:
-                return "completed";
-            case AgentInvocationStatus.AGENT_INVOCATION_TERMINATED:
-                return "terminated";
-            default:
-                throw new Error("Agent execution provider returned an unsupported phase.");
-        }
-    },
 };
 const repositorySnapshots = new WeakMap();
 const repositoryCreators = new WeakMap();
@@ -459,11 +443,10 @@ const repositoryEntityInboxTargets = new WeakMap();
 const repositoryProjectionInboxTargets = new WeakMap();
 const repositoryProjectionDirect = new WeakMap();
 const repositoryRuntimes = new WeakMap();
-const repositoryEntityHandles = new WeakMap();
+const repositoryStorageLifetimes = new WeakMap();
 const entityStateHistoryCaches = new WeakMap();
 const repositoryHistoryConfigurations = new WeakMap();
 const repositoryAiConfigurations = new WeakMap();
-const repositoryAgentCodeRevisions = new WeakMap();
 const repositoryDispatchGuards = new WeakMap();
 /**
  * Installs repository routing, history, and callback state after identity validation.
@@ -493,7 +476,7 @@ const RepositoryRegistration = {
         RepositoryRegistration.installTargets(repository, routing);
     },
     /**
-     * Captures Agent capability and code revisions during repository registration.
+     * Captures Agent capability policy during repository registration.
      *
      * @typeParam EntityType Concrete generated Entity constructor.
      * @param repository Registered Entity repository for this operation.
@@ -505,8 +488,6 @@ const RepositoryRegistration = {
             return;
         if (options.ai !== undefined)
             repositoryAiConfigurations.set(repository, options.ai);
-        if (options.agentCodeRevision !== undefined)
-            repositoryAgentCodeRevisions.set(repository, options.agentCodeRevision);
     },
     /**
      * Registers durable Entity and direct Projection delivery targets.
@@ -555,6 +536,24 @@ export const repositoryAccess = Object.freeze({
         }
         return RepositoryIdentity.cloneRepositorySnapshot(snapshot);
     },
+    /**
+     * Prepares actual Entity and Agent families from the captured repository definition.
+     * @param repository Registered repository model.
+     * @param context Complete selected storage scope.
+     * @param factory Configured provider factory.
+     * @param mode Creation or compatibility inspection.
+     * @returns Completion after all required physical families are ready.
+     */
+    async prepareStorage(repository, context, factory, mode) {
+        const input = RepositoryStorage.entityStorageInput(repository, context);
+        const preparation = StoragePreparations.for(factory);
+        if (repository.entityFamily !== "agent") {
+            await preparation.prepareEntity(input, mode);
+            return;
+        }
+        await preparation.prepareAgentCommit(input, mode);
+        await preparation.prepareAgentHistory({ context, stateType: input.sourceType.typeName, id: { key: input.id.key } }, mode);
+    },
     /**
      * Reads schemas for Events this repository can emit.
      *
@@ -568,32 +567,12 @@ export const repositoryAccess = Object.freeze({
         }
         return schemas;
     },
-    producedCommandSchemas(repository) {
-        const routing = repositoryRoutings.get(repository);
-        if (routing === undefined)
-            throw new TypeError("Produced Command schemas require a Repository instance.");
-        return routing.producedCommandSchemas;
-    },
+    /**
+     * Returns the AI registry configured for this repository, if present.
+     */
     agentConfiguration(repository) {
         const ai = repositoryAiConfigurations.get(repository);
-        const codeRevision = repositoryAgentCodeRevisions.get(repository);
-        return {
-            ...(ai === undefined ? {} : { ai }),
-            ...(codeRevision === undefined ? {} : { codeRevision }),
-        };
-    },
-    runAcceptedAgent(repository, tenantId, key, signal) {
-        return AgentExecutionRunner.run(repository, tenantId, key, signal);
-    },
-    pendingAcceptedAgents(repository, tenantId, after, count) {
-        const runtime = repositoryRuntimes.get(repository);
-        if (runtime === undefined || repository.entityFamily !== "agent")
-            throw new Error("Agent pending discovery requires a registered Agent repository.");
-        const input = RepositoryStorage.entityStorageInput(repository, RepositoryTenants.storageContextForTenant(runtime.context, tenantId));
-        const storage = RepositoryStorage.openRepositoryEntityStorage(repository, runtime.storageFactory, input);
-        if (storage.agentExecution === undefined)
-            throw new Error("Agent pending discovery requires execution storage.");
-        return storage.agentExecution.pending({ count, ...(after === undefined ? {} : { after }) });
+        return ai === undefined ? {} : { ai };
     },
     /**
      * Opens a scoped provider read without restoring an application Entity.
@@ -612,19 +591,17 @@ export const repositoryAccess = Object.freeze({
         if (runtime === undefined)
             throw new Error("Agent history requires an active repository.");
         const context = RepositoryTenants.storageContextForTenant(runtime.context, tenantId);
+        await runtime.onAdmit(context.tenantId);
         const input = RepositoryStorage.entityStorageInput(repository, context);
-        const history = AgentHistoryStorageFactories.create(runtime.storageFactory, {
-            context,
-            stateType: repository.stateSchema.typeName,
-            id: { key: input.id.key },
-        });
-        try {
-            return await history.read({ entityId, view, ...read });
-        }
-        finally {
-            history.close();
-        }
+        return RepositoryStorage.track(repository, () => RepositoryStorage.openRepositoryAgentHistory(repository, runtime.storageFactory, input).read({
+            entityId,
+            view,
+            ...read,
+        }));
     },
+    /**
+     * Reads one tenant-admitted Agent history page through retained history storage.
+     */
     async agentHistoryPage(repository, entityId, request, tenantId) {
         if (repository.entityFamily !== "agent")
             throw new TypeError("Agent history requires an Agent repository.");
@@ -632,25 +609,19 @@ export const repositoryAccess = Object.freeze({
         if (runtime === undefined)
             throw new Error("Agent history requires an active repository.");
         const context = RepositoryTenants.storageContextForTenant(runtime.context, tenantId);
+        await runtime.onAdmit(context.tenantId);
         const input = RepositoryStorage.entityStorageInput(repository, context);
-        const history = AgentHistoryStorageFactories.create(runtime.storageFactory, {
-            context,
-            stateType: repository.stateSchema.typeName,
-            id: { key: input.id.key },
-        });
-        try {
-            return await AgentHistoryReads.readBound({
+        return RepositoryStorage.track(repository, () => {
+            const history = RepositoryStorage.openRepositoryAgentHistory(repository, runtime.storageFactory, input);
+            return AgentHistoryReads.readBound({
                 storage: history,
                 entityId,
                 scope: this.agentHistoryScope(context, input, entityId),
             }, { kind: "full" }, request);
-        }
-        finally {
-            history.close();
-        }
+        });
     },
     /**
-     * Computes the opaque cursor scope for a registered Agent history read.
+     * Returns the opaque cursor scope for a registered Agent history read.
      */
     agentHistoryScope(context, input, entityId) {
         return {
@@ -759,6 +730,7 @@ export const repositoryAccess = Object.freeze({
      */
     bindRuntime(repository, runtime) {
         repositoryRuntimes.set(repository, Object.freeze(runtime));
+        repositoryStorageLifetimes.set(repository, RepositoryStorage.newLifetime());
     },
     /**
      * Removes runtime dispatch state and closes tracked storage handles.
@@ -768,12 +740,18 @@ export const repositoryAccess = Object.freeze({
     clearRuntime(repository) {
         repositoryRuntimes.delete(repository);
         repositoryDispatchGuards.delete(repository);
-        const handles = repositoryEntityHandles.get(repository);
-        if (handles !== undefined) {
-            for (const handle of handles.values())
-                handle.close();
-            handles.clear();
-        }
+        return RepositoryStorage.closeRuntime(repository);
+    },
+    /**
+     * Closes idle repository storage during synchronous assembly rollback.
+     *
+     * @param repository Repository to detach.
+     */
+    clearRuntimeIdle(repository) {
+        RepositoryStorage.assertIdle(repository);
+        repositoryRuntimes.delete(repository);
+        repositoryDispatchGuards.delete(repository);
+        RepositoryStorage.closeRuntimeIdle(repository);
     },
 });
 const inboxDedupMs = 30_000;
@@ -931,14 +909,12 @@ class RepositoryReadScope {
             throw new Error("Repository read access has finished.");
         if (query.schema !== this.#repository.stateSchema)
             throw new TypeError("Repository query must select the receiving Entity state schema.");
+        await this.#runtime.onAdmit(this.#context.tenantId);
         const plan = RepositoryReadPredicates.plan(query.buildPlan());
-        const storage = RepositoryStorage.openReadEntityStorage(this.#runtime.storageFactory, RepositoryStorage.entityStorageInput(this.#repository, this.#context));
-        try {
-            return await storage.current.query(plan);
-        }
-        finally {
-            storage.close();
-        }
+        return RepositoryStorage.track(this.#repository, () => {
+            const storage = RepositoryStorage.repositoryReadEntityStorage(this.#repository, this.#runtime.storageFactory, RepositoryStorage.entityStorageInput(this.#repository, this.#context));
+            return storage.current.query(plan);
+        });
     }
 }
 /**
@@ -1046,7 +1022,20 @@ class AggregateExecutionSupport {
             ? {}
             : { tenantId: this.#storageContext.tenantId });
         const entity = this.#instantiateAggregate(entityId, current);
-        RepositoryHistoryInternals.bindEntityHistory(entity, storage, entityId, this.#repository.stateSchema);
+        RepositoryHistoryInternals.bindEntityHistory(this.#repository, entity, storage, entityId, this.#repository.stateSchema, this.#storageContext.tenantId);
+        return this.#loadedAggregate(entityId, current, entity, storage, storageInput);
+    }
+    /**
+     * Returns one restored Aggregate with its captured storage configuration.
+     *
+     * @param entityId Aggregate identifier.
+     * @param current Stored Aggregate snapshot, if present.
+     * @param entity Restored Aggregate instance.
+     * @param storage Retained Entity storage.
+     * @param storageInput Captured storage configuration.
+     * @returns Loaded Aggregate for command execution.
+     */
+    #loadedAggregate(entityId, current, entity, storage, storageInput) {
         return Object.freeze({
             commits: storage.commits,
             current: current === undefined
@@ -1135,9 +1124,7 @@ class AggregateExecutionSupport {
             entity: loaded.storageInput,
             entityId,
             next: record,
-            ...(RepositoryStorage.historyConfiguration(this.#repository).stateHistory
-                ? { states: [record] }
-                : {}),
+            ...(loaded.storageInput.stateHistory ? { states: [record] } : {}),
             diagnostics: diagnostics.map((event) => clone(EventSchema, event)),
             events,
         });
@@ -1273,7 +1260,7 @@ class AggregateCommandExecution {
         this.#publishCommandDispatch(intake.route.entityId);
         let produced;
         try {
-            produced = await this.#invokeAssignee(loaded.entity, intake.assignee.handler, intake.message, EntityInvocation.commandHandlerContext(this.#command));
+            produced = await this.#invokeAssignee(loaded.entity, intake.assignee.handler, intake.message, EntityInvocation.commandHandlerContext(this.#command), this.#command.context?.actorContext);
         }
         catch (error) {
             return this.#postAssigneeRejection(intake, error);
@@ -1330,26 +1317,45 @@ class AggregateCommandExecution {
      * @param handler Assignee declaration to invoke.
      * @param message Decoded Command message.
      * @param context Copied Command context for the handler.
+     * @param actorContext Actor metadata of the Command signal.
      * @returns The handler's raw result after a successful commit.
      */
-    async #invokeAssignee(entity, handler, message, context) {
-        transactionalEntityAccess.start(entity);
+    async #invokeAssignee(entity, handler, message, context, actorContext) {
+        const releaseActor = entityHistoryAccess.bindActor(entity, actorContext);
+        let started = false;
         try {
-            const produced = await EntityInvocation.invokeEntityMethod(entity, handler.methodName, message, handler.parameterCount, context);
-            const signals = this.#support.normalizeProducedSignals(produced);
-            if (signals.length === 0)
-                throw new Error("Repository aggregate command handlers must return at least one event.");
-            RepositoryHandlers.requireDeclaredOutputs(handler, signals);
-            const commit = await commitFenced(entity, (current) => transactionalEntityAccess.commit(current, true));
-            if (commit.status === "rejected") {
-                throw new TransitionValidationError(commit.validation.error);
-            }
-            return produced;
+            transactionalEntityAccess.start(entity);
+            started = true;
+            return await this.#invokeAndCommitAssignee(entity, handler, message, context);
         }
         catch (error) {
-            transactionalEntityAccess.rollback(entity);
+            if (started)
+                transactionalEntityAccess.rollback(entity);
             throw error;
         }
+        finally {
+            releaseActor();
+        }
+    }
+    /**
+     * Checks a declared Aggregate result and commits its accepted transition.
+     *
+     * @param entity Current Aggregate draft.
+     * @param handler Declared Command handler.
+     * @param message Decoded domain Command.
+     * @param context Detached signal context supplied to the handler.
+     * @returns Raw handler result after commit.
+     */
+    async #invokeAndCommitAssignee(entity, handler, message, context) {
+        const produced = await EntityInvocation.invokeEntityMethod(entity, handler.methodName, message, handler.parameterCount, context);
+        const signals = this.#support.normalizeProducedSignals(produced);
+        if (signals.length === 0)
+            throw receptionObservation.recordPostHandlerFailure(new Error("Repository aggregate command handlers must return at least one event."));
+        RepositoryHandlers.requireDeclaredOutputs(handler, signals);
+        const commit = await commitFenced(entity, (current) => transactionalEntityAccess.commit(current, true));
+        if (commit.status === "rejected")
+            throw EntityInvocation.rejectedTransition(commit.validation.error);
+        return produced;
     }
     /**
      * Binds each produced result to the target and pre-dispatch version.
@@ -1394,7 +1400,7 @@ class AggregateCommandExecution {
         }
         return create(EventSchema, {
             id: metadata.id,
-            message: AnyMessages.pack(schema, message),
+            message: RepositorySignals.packProduced(schema, message),
             context: metadata.context,
         });
     }
@@ -1524,16 +1530,23 @@ class AggregateEventExecution {
     async #invokeHandlers(entityId, loaded, intake) {
         const eventContext = EntityInvocation.eventHandlerContext(this.#event);
         const events = [];
-        transactionalEntityAccess.start(loaded.entity);
+        const releaseActor = entityHistoryAccess.bindActor(loaded.entity, this.#runtime.signalMetadata.originFromEvent(this.#event).actorContext);
+        let started = false;
         try {
+            transactionalEntityAccess.start(loaded.entity);
+            started = true;
             await this.#invokeReactors(entityId, loaded, intake, eventContext, events);
             await this.#commitEntity(loaded.entity, events.length > 0);
             return Object.freeze(events);
         }
         catch (error) {
-            transactionalEntityAccess.rollback(loaded.entity);
+            if (started)
+                transactionalEntityAccess.rollback(loaded.entity);
             throw error;
         }
+        finally {
+            releaseActor();
+        }
     }
     /**
      * Invokes each reactor, checks its declared output, and collects bound Events.
@@ -1564,7 +1577,7 @@ class AggregateEventExecution {
     async #commitEntity(entity, producedEvents) {
         const commit = await commitFenced(entity, (current) => transactionalEntityAccess.commit(current, producedEvents));
         if (commit.status === "rejected")
-            throw new TransitionValidationError(commit.validation.error);
+            throw EntityInvocation.rejectedTransition(commit.validation.error);
     }
     /**
      * Binds reactor results using the pre-dispatch Aggregate version.
@@ -1597,7 +1610,7 @@ class AggregateEventExecution {
         });
         return create(EventSchema, {
             id: metadata.id,
-            message: AnyMessages.pack(schema, signal),
+            message: RepositorySignals.packProduced(schema, signal),
             context: RepositorySignals.eventContextWithProducer(metadata.context, this.#repository, entityId, version),
         });
     }
@@ -1805,9 +1818,7 @@ class ProjectionEventExecution {
             entity: loaded.storageInput,
             entityId,
             next: record,
-            ...(RepositoryStorage.historyConfiguration(this.#repository).stateHistory
-                ? { states: [record] }
-                : {}),
+            ...(loaded.storageInput.stateHistory ? { states: [record] } : {}),
         });
     }
     /**
@@ -1839,20 +1850,26 @@ class ProjectionEventExecution {
      * @returns Completion after the subscriber transaction commits.
      */
     async #invokeSubscribers(entity, subscribers, packedMessage) {
-        transactionalEntityAccess.start(entity);
+        const releaseActor = entityHistoryAccess.bindActor(entity, this.#runtime.signalMetadata.originFromEvent(this.#event).actorContext);
+        let started = false;
         try {
+            transactionalEntityAccess.start(entity);
+            started = true;
             for (const subscriber of subscribers) {
                 await this.#invokeSubscriber(entity, subscriber, packedMessage);
             }
             const commit = await commitFenced(entity, (current) => transactionalEntityAccess.commit(current));
-            if (commit.status === "rejected") {
-                throw new TransitionValidationError(commit.validation.error);
-            }
+            if (commit.status === "rejected")
+                throw EntityInvocation.rejectedTransition(commit.validation.error);
         }
         catch (error) {
-            transactionalEntityAccess.rollback(entity);
+            if (started)
+                transactionalEntityAccess.rollback(entity);
             throw error;
         }
+        finally {
+            releaseActor();
+        }
     }
     /**
      * Invokes one Event subscriber and checks its raw return value.
@@ -1867,7 +1884,7 @@ class ProjectionEventExecution {
         const context = EntityInvocation.eventHandlerContext(this.#event);
         const result = await EntityInvocation.invokeEntityMethod(entity, subscriber.handler.methodName, message, subscriber.handler.parameterCount, context);
         if (result !== undefined)
-            throw new Error(`Projection subscriber "${subscriber.handler.methodName}" must not return signals.`);
+            throw receptionObservation.recordPostHandlerFailure(new Error(`Projection subscriber "${subscriber.handler.methodName}" must not return signals.`));
     }
     /**
      * Invokes state subscribers in one Entity transaction.
@@ -1878,22 +1895,40 @@ class ProjectionEventExecution {
      * @returns Completion after the subscriber transaction commits.
      */
     async #invokeStateSubscribers(entity, subscribers, state) {
-        transactionalEntityAccess.start(entity);
+        const releaseActor = entityHistoryAccess.bindActor(entity, this.#runtime.signalMetadata.originFromEvent(this.#event).actorContext);
+        let started = false;
         try {
-            for (const subscriber of subscribers) {
-                const context = EntityInvocation.eventHandlerContext(this.#event);
-                const result = await EntityInvocation.invokeEntityMethod(entity, subscriber.handler.methodName, state, subscriber.handler.parameterCount, context);
-                if (result !== undefined)
-                    throw new Error(`Projection subscriber "${subscriber.handler.methodName}" must not return signals.`);
-            }
+            transactionalEntityAccess.start(entity);
+            started = true;
+            await this.#runStateSubscribers(entity, subscribers, state);
             const commit = await commitFenced(entity, (current) => transactionalEntityAccess.commit(current));
             if (commit.status === "rejected")
-                throw new TransitionValidationError(commit.validation.error);
+                throw EntityInvocation.rejectedTransition(commit.validation.error);
         }
         catch (error) {
-            transactionalEntityAccess.rollback(entity);
+            if (started)
+                transactionalEntityAccess.rollback(entity);
             throw error;
         }
+        finally {
+            releaseActor();
+        }
+    }
+    /**
+     * Delivers one state update to each declared Projection subscriber.
+     *
+     * @param entity Projection currently in its transaction.
+     * @param subscribers Subscribers selected for the source state.
+     * @param state Decoded source Entity state.
+     * @returns Completion after all subscribers accept the state.
+     */
+    async #runStateSubscribers(entity, subscribers, state) {
+        for (const subscriber of subscribers) {
+            const context = EntityInvocation.eventHandlerContext(this.#event);
+            const result = await EntityInvocation.invokeEntityMethod(entity, subscriber.handler.methodName, state, subscriber.handler.parameterCount, context);
+            if (result !== undefined)
+                throw receptionObservation.recordPostHandlerFailure(new Error(`Projection subscriber "${subscriber.handler.methodName}" must not return signals.`));
+        }
     }
     /**
      * Restores or creates a Projection and binds its storage history.
@@ -1972,7 +2007,11 @@ const ProcessManagerQueries = Object.freeze({
      * @returns Detached Projection state snapshots.
      */
     async load(stand, registeredSchema, plan, destination, query, schema) {
-        const results = await QueryReader.read(stand, registeredSchema, plan, destination, 10_000, query);
+        const results = await QueryReader.read(stand, registeredSchema, plan, destination, 10_000, query, {
+            operation: { kind: "query", query },
+            ...(query.context === undefined ? {} : { actorContext: query.context }),
+            ...(destination === undefined ? {} : { effectiveTenant: destination }),
+        });
         return Object.freeze(results.map((result) => clone(schema, result.state)));
     },
 });
@@ -2034,13 +2073,7 @@ class ProcessManagerExecutionSupport {
         const priorNumber = loaded.current?.version?.number ?? 0;
         if (version.number === priorNumber) {
             await this.#appendUnchangedDiagnostics(loaded, diagnostics);
-            const store = new EventStore(this.#runtime.context, this.#runtime.storageFactory);
-            try {
-                await store.appendAll(producedEvents);
-            }
-            finally {
-                store.close();
-            }
+            await RepositoryStorage.eventStore(this.#repository, this.#runtime).appendAll(producedEvents);
             await this.#appendAgentEvents(loaded, producedEvents);
             return true;
         }
@@ -2127,7 +2160,7 @@ class ProcessManagerExecutionSupport {
             entity: loaded.storageInput,
             entityId,
             next: record,
-            ...(history.stateHistory ? { states: [record] } : {}),
+            ...(loaded.storageInput.stateHistory ? { states: [record] } : {}),
             ...(history.processManagerEventHistory
                 ? { diagnostics: diagnostics.map((event) => clone(EventSchema, event)) }
                 : {}),
@@ -2150,1268 +2183,706 @@ class ProcessManagerExecutionSupport {
     }
 }
 /**
- * Advances admitted Agent work only under a provider claim and exact record fence.
+ * Binds normal outgoing Agent signals from one live turn.
  */
-const AgentExecutionRunner = {
+const AgentLiveOutputs = {
     /**
-     * Processes one accepted Agent transition under its provider claim.
+     * Stores only committed domain Events in the Agent's emitted history.
      *
-     * @param repository Registered Agent repository.
-     * @param tenantId Tenant selected for this invocation.
-     * @param key Exact accepted invocation key.
-     * @param signal Cancellation signal for the current accepted execution.
-     * @returns When the fenced repository operation completes.
+     * @param outputs Prepared outgoing domain signals.
+     * @returns Committed domain Event rows for Agent history.
      */
-    async run(repository, tenantId, key, signal) {
-        if (signal?.aborted)
-            return;
-        const runtime = repositoryRuntimes.get(repository);
-        if (runtime?.ai === undefined || repository.entityFamily !== "agent")
-            throw new Error("Agent execution requires a bound Agent repository and AI registry.");
-        const input = RepositoryStorage.entityStorageInput(repository, RepositoryTenants.storageContextForTenant(runtime.context, tenantId));
-        const storage = RepositoryStorage.openRepositoryEntityStorage(repository, runtime.storageFactory, input);
-        const executions = storage.agentExecution;
-        if (executions === undefined)
-            throw new Error("Agent execution storage is required.");
-        const token = randomUUID();
-        const claimed = await executions.claim(key, token, addMillis(Time.currentTime(), 30_000));
-        if (claimed === undefined)
-            return;
-        const session = new AgentExecutionSession(executions, claimed.record, token, claimed.preferences);
-        await this.runClaimed(repository, runtime, tenantId, session, signal);
+    emittedHistory(outputs) {
+        return outputs.flatMap((output) => {
+            if (output.case !== "event" || output.value.context?.rejection !== undefined)
+                return [];
+            const event = output.value;
+            const occurredAt = event.context?.timestamp;
+            if (occurredAt === undefined)
+                throw new Error("Agent emitted Event requires its original timestamp.");
+            return [
+                create(AgentHistoryEntrySchema, {
+                    occurredAt,
+                    item: { case: "domainEvent", value: event },
+                }),
+            ];
+        });
     },
     /**
-     * Updates and releases one exact claim while its saved work advances.
+     * Binds one declared result using its generated Event or Command role.
      *
      * @param repository Registered Entity repository for this operation.
      * @param runtime Bounded Context storage and publication services.
-     * @param tenantId Tenant selected for this accepted signal.
-     * @param session Fenced Agent execution session.
-     * @param signal Cancellation signal for the current accepted execution.
-     * @returns When the fenced repository operation completes.
+     * @param routing Registered generated handler routing metadata.
+     * @param source Original accepted source signal.
+     * @param entityId Typed recipient Entity identifier.
+     * @param version Entity version associated with the signal.
+     * @param signal Original domain signal or execution cancellation signal.
+     * @returns Typed outgoing signal with its original envelope.
      */
-    async runClaimed(repository, runtime, tenantId, session, signal) {
-        const abort = () => {
-            session.stop();
-        };
-        signal?.addEventListener("abort", abort, { once: true });
-        if (signal?.aborted)
-            abort();
-        const renewal = setInterval(() => {
-            // spine-log-boundary: server.agent_lease_renewal
-            void session.renew(addMillis(Time.currentTime(), 30_000)).catch(() => undefined);
-        }, 10_000);
-        try {
-            if (session.signal.aborted)
-                return;
-            await this.advanceClaimed(repository, runtime, tenantId, session);
-        }
-        catch (error) {
-            if (signal?.aborted)
-                return;
-            await this.handleRunFailure(repository, runtime, tenantId, session, error);
-        }
-        finally {
-            clearInterval(renewal);
-            signal?.removeEventListener("abort", abort);
-            session.stop();
-        }
+    bindOutput(repository, runtime, routing, source, entityId, version, signal) {
+        const typeName = EntityInvocation.messageTypeName(signal);
+        const eventSchema = routing.producedEventSchemas.find((entry) => entry.typeName === typeName);
+        if (eventSchema !== undefined)
+            return this.bindEventOutput(repository, runtime, source, entityId, version, signal, eventSchema);
+        const schema = routing.producedCommandSchemas.find((entry) => entry.typeName === typeName);
+        if (schema === undefined)
+            throw new Error(`Agent cannot emit undeclared signal "${typeName}".`);
+        return this.bindCommandOutput(runtime, source, signal, schema);
     },
     /**
-     * Handles transient failures while giving expired work a final audit.
+     * Creates the original domain Event envelope and producer context.
      *
      * @param repository Registered Entity repository for this operation.
      * @param runtime Bounded Context storage and publication services.
-     * @param tenantId Tenant selected for this accepted signal.
-     * @param session Fenced Agent execution session.
-     * @param error Failure raised while processing this accepted signal.
-     * @returns When the fenced repository operation completes.
+     * @param source Original accepted source signal.
+     * @param entityId Typed recipient Entity identifier.
+     * @param version Entity version associated with the signal.
+     * @param signal Original domain signal or execution cancellation signal.
+     * @param schema Generated message descriptor for the signal.
+     * @returns Typed original Event envelope for one normal EventBus handoff.
      */
-    async handleRunFailure(repository, runtime, tenantId, session, error) {
-        if (session.record().status ===
-            AgentInvocationStatus.AGENT_INVOCATION_COMPLETED_PENDING_COMMANDS ||
-            session.record().status === AgentInvocationStatus.AGENT_INVOCATION_COMPLETED)
-            throw error;
-        if (error instanceof AgentUncertainAttemptError) {
-            const reason = this.hasUnresolvedToolWrite(session.record())
-                ? "TOOL_OUTCOME_UNKNOWN"
-                : "MODEL_OUTCOME_UNKNOWN";
-            return this.terminate(repository, runtime, tenantId, session, reason);
-        }
-        if (error instanceof AgentExecutionFault) {
-            if (session.signal.aborted)
-                throw error;
-            return this.terminate(repository, runtime, tenantId, session, error.reason);
-        }
-        if (this.deadlineExpired(session.record()))
-            return this.terminate(repository, runtime, tenantId, session, "DEADLINE_EXCEEDED");
-        throw error;
+    bindEventOutput(repository, runtime, source, entityId, version, signal, schema) {
+        const metadata = source.case === "command"
+            ? runtime.signalMetadata.eventFromCommand(source.value, { version: version.number })
+            : runtime.signalMetadata.eventFromEvent(source.value, { version: version.number });
+        const event = create(EventSchema, {
+            id: metadata.id,
+            message: RepositorySignals.packValidated(schema, signal),
+            context: RepositorySignals.eventContextWithProducer(metadata.context, repository, entityId, version),
+        });
+        return { case: "event", value: event };
     },
     /**
-     * Processes one claimed record according to its saved completion or request state.
+     * Creates the original Command envelope from its accepted origin.
      *
-     * @param repository Registered Entity repository for this operation.
      * @param runtime Bounded Context storage and publication services.
-     * @param tenantId Tenant selected for this accepted signal.
-     * @param session Fenced Agent execution session.
-     * @returns When the fenced repository operation completes.
-     */
-    async advanceClaimed(repository, runtime, tenantId, session) {
-        if (this.hasUnresolvedPhysicalRequest(session.record()))
-            return this.terminate(repository, runtime, tenantId, session, this.hasUnresolvedToolWrite(session.record())
-                ? "TOOL_OUTCOME_UNKNOWN"
-                : "MODEL_OUTCOME_UNKNOWN");
-        if (session.record().status === AgentInvocationStatus.AGENT_INVOCATION_COMPLETED_PENDING_COMMANDS)
-            return this.deliverCommands(runtime, session);
-        if (this.deadlineExpired(session.record()))
-            return this.terminate(repository, runtime, tenantId, session, "DEADLINE_EXCEEDED");
-        return this.execute(repository, runtime, tenantId, session);
-    },
-    /**
-     * Tests the original saved deadline without granting recovery fresh time.
-     *
-     * @param record Durable Agent execution record.
-     * @returns Whether the checked condition holds.
+     * @param source Original accepted source signal.
+     * @param signal Original domain signal or execution cancellation signal.
+     * @param schema Generated message descriptor for the signal.
+     * @returns Typed original Command envelope for durable delivery.
      */
-    deadlineExpired(record) {
-        const deadline = record.started?.deadline;
-        return (deadline !== undefined &&
-            Time.currentTimeMillis() >=
-                Number(deadline.seconds) * 1_000 + Math.floor(deadline.nanos / 1_000_000));
+    bindCommandOutput(runtime, source, signal, schema) {
+        const metadata = source.case === "command"
+            ? runtime.signalMetadata.commandFromCommand(source.value)
+            : runtime.signalMetadata.commandFromEvent(source.value);
+        const command = create(CommandSchema, {
+            id: metadata.id,
+            message: RepositorySignals.packValidated(schema, signal),
+            context: metadata.context,
+        });
+        return { case: "command", value: command };
     },
+};
+/**
+ * Waits only for a current in-process handler invocation.
+ */
+const AgentLiveHandler = {
     /**
-     * Checks for a dispatched model reservation whose response was never saved.
+     * Awaits an application handler within its live deadline and current session.
      *
-     * @param record Durable Agent execution record.
-     * @returns Whether the checked condition holds.
+     * @typeParam Value Handler result.
+     * @param work Already-started generated handler invocation.
+     * @param signal Cancellation when live authority ends.
+     * @param deadlineEpochMs Live invocation deadline.
+     * @returns Handler result only while its session and deadline remain valid.
      */
-    hasUnresolvedPhysicalRequest(record) {
-        const model = record.journal.some((entry) => {
-            if (entry.evidence.case !== "attempt")
-                return false;
-            const attempt = entry.evidence.value;
-            return (attempt.transportReserved &&
-                attempt.response.case === undefined &&
-                !this.hasSavedOperationResult(record, attempt.operation?.value));
-        });
-        return model || this.hasUnresolvedToolWrite(record);
-    },
-    /**
-     * Checks for a dispatched write with no recorded tool result.
-     *
-     * @param record Durable Agent execution record.
-     * @returns Whether the checked condition holds.
-     */
-    hasUnresolvedToolWrite(record) {
-        return record.journal.some((entry) => {
-            if (entry.evidence.case !== "tool")
-                return false;
-            const tool = entry.evidence.value;
-            return (tool.request?.effect === ToolEffect.WRITE &&
-                tool.response === undefined &&
-                (tool.dispatched || tool.outcomeUnknown) &&
-                !this.hasSavedOperationResult(record, tool.operation?.value));
+    async awaitHandler(work, signal, deadlineEpochMs) {
+        let timer;
+        let abort = () => undefined;
+        const cutoff = new Promise((_resolve, reject) => {
+            abort = () => {
+                reject(new Error("Agent handler session ended."));
+            };
+            const tick = () => {
+                if (deadlineEpochMs === undefined)
+                    return;
+                const remaining = deadlineEpochMs - Time.currentTimeMillis();
+                if (remaining <= 0)
+                    reject(new Error("Agent handler deadline expired."));
+                else
+                    timer = setTimeout(tick, Math.min(remaining, 2_147_483_647));
+            };
+            signal.addEventListener("abort", abort, { once: true });
+            if (signal.aborted)
+                abort();
+            else
+                tick();
         });
+        try {
+            const result = await Promise.race([work, cutoff]);
+            if (signal.aborted ||
+                (deadlineEpochMs !== undefined && Time.currentTimeMillis() >= deadlineEpochMs))
+                throw new Error("Agent handler deadline or session ended.");
+            return result;
+        }
+        finally {
+            clearTimeout(timer);
+            signal.removeEventListener("abort", abort);
+        }
     },
-    /**
-     * Checks for a settled named result even when physical evidence is incomplete.
-     *
-     * @param record Durable Agent execution record.
-     * @param id Saved signal, operation, or Entity identifier.
-     * @returns Whether the checked condition holds.
-     */
-    hasSavedOperationResult(record, id) {
-        return record.journal.some((entry) => entry.evidence.case === "operation" &&
-            entry.evidence.value.operation?.value === id &&
-            entry.evidence.value.result.case !== undefined);
-    },
-    /**
-     * Records termination of an unreplayable physical request under the provider fence.
-     *
-     * @param repository Registered Entity repository for this operation.
-     * @param runtime Bounded Context storage and publication services.
-     * @param tenantId Tenant selected for this accepted signal.
-     * @param session Fenced Agent execution session.
-     * @param reason Safe terminal reason retained in Agent audit.
-     * @returns When the fenced repository operation completes.
-     */
-    async terminate(repository, runtime, tenantId, session, reason) {
-        const record = session.record();
-        const event = this.terminationEvent(repository, runtime, tenantId, record, reason);
-        const occurredAt = event.context?.timestamp;
-        if (occurredAt === undefined)
-            throw new Error("Agent termination Event requires Time.");
-        runtime.registerSystemEventSchema(AgentInvocationTerminatedSchema);
-        await session.update((next) => {
-            next.status = AgentInvocationStatus.AGENT_INVOCATION_TERMINATED;
-            next.terminalFailure = create(AiDiagnosticIdSchema, { value: randomUUID() });
-            return next;
-        }, [
-            create(AgentHistoryEntrySchema, {
-                occurredAt,
-                item: { case: "systemEvent", value: event },
-            }),
-        ]);
-        await runtime.publishAgentSystemEvent(event);
-    },
-    /**
-     * Builds one original termination envelope for a saved terminal reason.
-     *
-     * @param repository Registered Entity repository for this operation.
-     * @param runtime Bounded Context storage and publication services.
-     * @param tenantId Tenant selected for this accepted signal.
-     * @param record Durable Agent execution record.
-     * @param reason Safe terminal reason retained in Agent audit.
-     * @returns Original AgentInvocationTerminated System Event envelope.
-     */
-    terminationEvent(repository, runtime, tenantId, record, reason) {
-        const accepted = record.accepted;
-        if (accepted?.recipientId === undefined)
-            throw new Error("Agent termination requires the original typed recipient.");
-        const scope = AgentModelSelection.scope(accepted, repository.stateSchema, tenantId);
-        const unresolvedToolCalls = this.unresolvedToolCalls(record);
-        const payload = create(AgentInvocationTerminatedSchema, {
-            agent: scope.agent,
-            sourceSignal: scope.source,
-            reason,
-            unresolvedAttempts: this.unresolvedAttempts(record),
-            unresolvedToolCalls,
-            terminatedAt: Time.currentTime(),
+};
+/**
+ * Runs one receipt-admitted Agent signal without an execution record.
+ */
+class AgentLiveRunner {
+    repository;
+    runtime;
+    tenantId;
+    entityId;
+    invocation;
+    handlers;
+    signal;
+    checkSession;
+    #deadlineEpochMs;
+    #deadlineSampled = false;
+    /**
+     * Binds one original signal, resolved handlers, and the current repository runtime.
+     *
+     * @param checkSession Callback that validates the current execution session.
+     * @param entityId Typed Entity identifier.
+     * @param handlers Registered generated handlers.
+     * @param invocation Captured live Agent invocation.
+     * @param repository Repository configured for this Entity.
+     * @param runtime Current bounded-context runtime.
+     * @param signal Signal or cancellation signal for this operation.
+     * @param tenantId Captured tenant identifier.
+     */
+    constructor(repository, runtime, tenantId, entityId, invocation, handlers, signal, checkSession) {
+        this.repository = repository;
+        this.runtime = runtime;
+        this.tenantId = tenantId;
+        this.entityId = entityId;
+        this.invocation = invocation;
+        this.handlers = handlers;
+        this.signal = signal;
+        this.checkSession = checkSession;
+    }
+    /**
+     * Starts the serialized turn by loading current state and committed model preferences.
+     *
+     * @returns Completion after admitted Agent work finishes.
+     */
+    async run() {
+        if (this.signal.aborted)
+            return;
+        await this.checkSession();
+        await this.runtime.onAdmit(this.tenantId);
+        await RepositoryStorage.track(this.repository, async () => {
+            const loaded = await new ProcessManagerExecutionSupport(this.repository, this.runtime).load(this.entityId, this.tenantId === undefined ? {} : { tenantId: this.tenantId });
+            const expected = await loaded.commits.readAgentPreferences(this.entityId);
+            if (this.signal.aborted)
+                return;
+            const ai = this.runtime.ai;
+            if (ai === undefined)
+                throw new Error("Live Agent execution requires an AI registry.");
+            const preferences = expected?.map((entry) => clone(ModelPreferenceSchema, entry)) ?? [];
+            const audit = this.audit(loaded);
+            let selected;
+            try {
+                selected = await this.select(preferences);
+            }
+            catch (error) {
+                if (!(error instanceof AgentLiveFault) || error.reason !== "MODEL_USE_DENIED")
+                    throw error;
+                await this.recordModelDenial(audit, error);
+                throw error;
+            }
+            const budget = new AgentLiveBudget(this.limits(ai));
+            await this.dispatchStart(loaded);
+            const produced = await this.produce(loaded, selected, preferences, audit, budget);
+            this.signal.throwIfAborted();
+            await this.checkSession();
+            await this.complete(loaded, expected, preferences, produced);
         });
-        return AgentInteractionEvents.envelope(accepted, runtime.signalMetadata, accepted.recipientId, AgentInvocationTerminatedSchema, payload);
-    },
+    }
     /**
-     * Returns IDs only for physically reserved model requests without saved outcomes.
+     * Writes only definite pre-handler model-use denial with its original source.
      *
-     * @param record Durable execution journal.
-     * @returns Original attempt IDs for unresolved physical sends.
+     * @param audit Retained history audit for this invocation.
+     * @param denial Typed model-use denial to record.
+     * @returns Completion after the exact pre-handler denial is saved to Agent history.
      */
-    unresolvedAttempts(record) {
-        return record.journal.flatMap((entry) => {
-            if (entry.evidence.case !== "attempt")
-                return [];
-            const attempt = entry.evidence.value;
-            return attempt.transportReserved &&
-                attempt.response.case === undefined &&
-                !this.hasSavedOperationResult(record, attempt.operation?.value) &&
-                attempt.attempt !== undefined
-                ? [attempt.attempt]
-                : [];
+    async recordModelDenial(audit, denial) {
+        const agent = create(MessageIdSchema, {
+            id: this.invocation.recipientId,
+            typeUrl: TypeUrls.derive(this.repository.stateSchema),
         });
-    },
-    /**
-     * Returns exact IDs for dispatched write effects without saved results.
-     *
-     * @param record Durable Agent execution record.
-     * @returns Original ToolCall IDs for unresolved dispatched writes.
-     */
-    unresolvedToolCalls(record) {
-        return record.journal.flatMap((entry) => {
-            if (entry.evidence.case !== "tool")
-                return [];
-            const tool = entry.evidence.value;
-            return tool.request?.effect === ToolEffect.WRITE &&
-                tool.response === undefined &&
-                (tool.dispatched || tool.outcomeUnknown) &&
-                tool.request.call !== undefined
-                ? [tool.request.call]
-                : [];
+        const fact = create(AgentInvocationTerminatedSchema, {
+            agent,
+            sourceSignal: AgentLiveInteractionEvents.sourceRef(this.invocation),
+            reason: "MODEL_USE_DENIED",
+            terminatedAt: Time.currentTime(),
         });
-    },
-    /**
-     * Persists start facts, runs selected handlers, and conditionally completes a no-op.
-     *
-     * @param repository Agent registration.
-     * @param runtime Bound services.
-     * @param tenantId Complete tenant, when applicable.
-     * @param session Fenced Agent execution session.
-     * @returns When the fenced repository operation completes.
-     */
-    async execute(repository, runtime, tenantId, session) {
-        const accepted = session.record().accepted;
-        if (accepted?.key === undefined || accepted.recipientId === undefined)
-            throw new Error("Claimed Agent invocation lacks accepted source and recipient.");
-        const entityId = InboxMessages.targetEntityId(accepted.recipientId, repository.idField);
-        const support = new ProcessManagerExecutionSupport(repository, runtime);
-        const loaded = await support.load(entityId, tenantId === undefined ? {} : { tenantId });
-        const handlers = this.handlers(repository, accepted);
-        const configuration = repositoryAccess.agentConfiguration(repository);
-        if (runtime.ai === undefined)
-            throw new Error("Agent execution requires a bound AI registry.");
-        this.assertRevisions(repository, accepted, handlers, runtime.ai, configuration);
-        const record = session.record().started === undefined
-            ? await this.start(repository, runtime, session, loaded, entityId, tenantId)
-            : await this.selectMissingModels(repository, runtime, session, accepted, tenantId);
-        if (session.signal.aborted)
-            return;
-        const outputs = await this.completeExecution(repository, runtime, tenantId, session, loaded, accepted, handlers, entityId, record.started?.initialVersion ?? create(VersionSchema));
-        await this.deliverInitial(runtime, session, outputs);
-    },
-    /**
-     * Creates or rejects the draft before one conditional Entity completion.
-     *
-     * @param repository Registered Entity repository for this operation.
-     * @param runtime Bounded Context storage and publication services.
-     * @param tenantId Tenant selected for this accepted signal.
-     * @param session Fenced Agent execution session.
-     * @param loaded Loaded Entity and its repository storage state.
-     * @param accepted Durable original signal and saved handler bindings.
-     * @param handlers Generated handlers in their saved order.
-     * @param entityId Typed recipient Entity identifier.
-     * @param initialVersion Entity version before selected handlers run.
-     * @returns Record after conditional Entity and execution completion.
-     */
-    async completeExecution(repository, runtime, tenantId, session, loaded, accepted, handlers, entityId, initialVersion) {
-        const outputs = await this.outputsOrRejection(repository, runtime, tenantId, session, loaded.entity, accepted, handlers, entityId, initialVersion);
-        await this.complete(repository, runtime, tenantId, session, loaded, entityId, outputs);
-        return outputs;
-    },
+        await audit.saveDenial(fact, denial);
+    }
     /**
-     * Rejects a Command draft and persists only its declared rejection.
+     * Converts only a declared Command rejection into a normal outgoing Event.
      *
-     * @param repository Registered Entity repository for this operation.
-     * @param runtime Bounded Context storage and publication services.
-     * @param tenantId Tenant selected for this accepted signal.
-     * @param session Fenced Agent execution session.
-     * @param entity Loaded recipient Entity instance.
-     * @param accepted Durable original signal and saved handler bindings.
-     * @param handlers Generated handlers in their saved order.
-     * @param entityId Typed recipient Entity identifier.
-     * @param initialVersion Entity version before selected handlers run.
-     * @returns Prepared outgoing signals, or only the declared rejection.
+     * @param audit Retained history audit for this invocation.
+     * @param budget Invocation-wide resource budget.
+     * @param loaded Current Entity and retained storage for this turn.
+     * @param preferences Current or staged model preferences.
+     * @param selected Models or selection retained for this invocation.
+     * @returns The declared rejection Event, when a Command rejects.
      */
-    async outputsOrRejection(repository, runtime, tenantId, session, entity, accepted, handlers, entityId, initialVersion) {
+    async produce(loaded, selected, preferences, audit, budget) {
         try {
-            return await this.produceOutputs(repository, runtime, tenantId, session, entity, accepted, handlers, entityId, initialVersion);
+            return {
+                case: "produced",
+                values: await this.invoke(loaded, selected, preferences, audit, budget),
+            };
         }
         catch (error) {
-            if (!RejectionThrowable.is(error) || accepted.signal.case !== "command")
+            if (!RejectionThrowable.is(error) || this.invocation.source.case !== "command")
                 throw error;
-            const handler = handlers[0];
+            const handler = this.handlers[0];
             if (handler === undefined)
                 throw new Error("Agent rejection requires a Command assignee.");
             RepositorySignals.requireDeclaredRejection(handler.handler, error);
-            session.discardPreferenceChanges();
-            return [this.rejectionOutput(runtime, repository, accepted.signal.value, entityId, error)];
+            preferences.length = 0;
+            const output = RepositorySignals.rejectionEvent(this.runtime, this.repository, this.invocation.source.value, this.entityId, error);
+            return { case: "rejected", output: { case: "event", value: output } };
         }
-    },
-    /**
-     * Wraps the original rejection Event for one normal EventBus handoff.
-     *
-     * @param runtime Bounded Context storage and publication services.
-     * @param repository Registered Entity repository for this operation.
-     * @param command Original typed Command envelope.
-     * @param entityId Typed recipient Entity identifier.
-     * @param error Failure raised while processing this accepted signal.
-     * @returns Prepared original rejection Event for one normal EventBus handoff.
-     */
-    rejectionOutput(runtime, repository, command, entityId, error) {
-        return {
-            case: "event",
-            value: RepositorySignals.rejectionEvent(runtime, repository, command, entityId, error),
-        };
-    },
-    /**
-     * Restores handler results and binds their declared original output envelopes.
-     *
-     * @param repository Registered Entity repository for this operation.
-     * @param runtime Bounded Context storage and publication services.
-     * @param tenantId Tenant selected for this accepted signal.
-     * @param session Fenced Agent execution session.
-     * @param entity Loaded recipient Entity instance.
-     * @param accepted Durable original signal and saved handler bindings.
-     * @param handlers Generated handlers in their saved order.
-     * @param entityId Typed recipient Entity identifier.
-     * @param initialVersion Entity version before selected handlers run.
-     * @returns Prepared outgoing signals from accepted handler results.
-     */
-    async produceOutputs(repository, runtime, tenantId, session, entity, accepted, handlers, entityId, initialVersion) {
-        const produced = await this.invoke(repository, runtime, tenantId, session, entity, accepted, handlers);
-        return this.bindOutputs(repository, runtime, accepted, entityId, initialVersion, produced);
-    },
-    /**
-     * Commits changed state and the fenced execution record as one provider mutation.
-     *
-     * @param repository Agent registration.
-     * @param runtime Bounded Context Stand and provider services.
-     * @param tenantId Complete delivery tenant.
-     * @param session Serialized provider claim and current record.
-     * @param loaded Entity after handler transaction commit.
-     * @param entityId Original typed recipient.
-     * @param outputs Original emitted Event or Command envelopes.
-     * @returns Complete record after the atomic provider mutation.
-     */
-    async complete(repository, runtime, tenantId, session, loaded, entityId, outputs) {
-        await this.authorizePreferenceChanges(repository, runtime, tenantId, session);
-        const version = RepositoryEntities.repositoryVersion(loaded.entity);
-        const preferences = session.preferences();
-        const emitted = this.emittedHistory(outputs);
-        const preferenceEvents = this.preferenceEvents(repository, runtime, tenantId, session);
-        const historyEntries = [...emitted, ...this.preferenceHistory(preferenceEvents)];
-        const makeNext = (record) => this.completionFacts(record, version, outputs, preferences);
-        const completed = await this.commitCompletion(repository, runtime, tenantId, session, loaded, entityId, makeNext, historyEntries);
-        for (const event of preferenceEvents)
-            await runtime.publishAgentSystemEvent(event);
-        return completed;
-    },
+    }
     /**
-     * Checks effective staged model changes before any completion mutation.
+     * Finds each enabled model from the preference image loaded at turn start.
      *
-     * @param repository Agent registration and model policy.
-     * @param runtime Bounded Context and AI registry.
-     * @param tenantId Accepted tenant when applicable.
-     * @param session Fenced Agent execution and staged preferences.
-     * @returns When every effective change is authorized.
+     * @param preferences Current or staged model preferences.
+     * @returns The selected model image for the current Agent turn.
      */
-    async authorizePreferenceChanges(repository, runtime, tenantId, session) {
-        const policy = repositoryAccess.agentConfiguration(repository).ai;
-        if (policy?.authorizeSelection === undefined)
-            return;
-        const accepted = session.record().accepted;
-        if (runtime.ai === undefined || accepted === undefined)
-            throw new Error("Agent model preference requires accepted start facts.");
-        const deadlineMs = this.savedModelDeadline(session, "preference");
-        const scope = AgentModelSelection.scope(accepted, repository.stateSchema, tenantId);
-        for (const kind of [AiModelKind.GENERATION, AiModelKind.DECISION]) {
-            const previous = this.preferenceModel(session.initialPreferences(), kind);
-            const selected = this.preferenceModel(session.preferences(), kind);
-            if (previous === undefined && selected === undefined)
-                continue;
-            if (previous !== undefined &&
-                selected !== undefined &&
-                equals(ModelRefSchema, previous, selected))
+    async select(preferences) {
+        const ai = this.runtime.ai;
+        const configuration = repositoryAccess.agentConfiguration(this.repository).ai;
+        if (ai === undefined || configuration === undefined)
+            throw new Error("Live Agent execution requires registered model policy.");
+        const scope = AgentModelSelection.scopeLive(this.invocation, this.repository.stateSchema, this.runtime.signalMetadata, this.tenantId);
+        const selected = new Map();
+        for (const kind of ["generation", "decision"]) {
+            if (!configuration.models.some((model) => model.definition.kind === kind))
                 continue;
-            await AgentModelSelection.authorizeSelection(runtime.ai, policy, scope, selected, session.signal, deadlineMs);
+            await this.checkSession();
+            const value = await AgentModelSelection.selectLiveKind(ai, configuration, scope, preferences, this.signal, this.deadline(ai), kind, this.invocation.source.value.message);
+            selected.set(value.kind, value);
         }
-    },
-    /**
-     * Reads an optional saved model deadline and detects incomplete persisted bounds.
-     *
-     * @param session Fenced Agent execution session.
-     * @param context Selection or preference authorization context.
-     * @returns Saved absolute deadline, when configured.
-     */
-    savedModelDeadline(session, context) {
-        const record = session.record();
-        const deadline = record.started?.deadline;
-        if (deadline === undefined && record.started?.bounds?.deadlineMillis !== undefined)
-            throw new Error(`Agent model ${context} deadline was not saved.`);
-        return deadline === undefined
-            ? undefined
-            : Number(deadline.seconds) * 1_000 + Math.floor(deadline.nanos / 1_000_000);
-    },
-    /**
-     * Applies the same provider fence to preference events and Entity completion.
-     *
-     * @param repository Registered Entity repository for this operation.
-     * @param runtime Bounded Context storage and publication services.
-     * @param tenantId Tenant selected for this accepted signal.
-     * @param session Fenced Agent execution session.
-     * @param loaded Loaded Entity and its repository storage state.
-     * @param entityId Typed recipient Entity identifier.
-     * @param makeNext Callback constructing the next durable execution record.
-     * @param historyEntries Agent history rows included in the fenced mutation.
-     * @returns Saved execution record after conditional completion.
-     */
-    commitCompletion(repository, runtime, tenantId, session, loaded, entityId, makeNext, historyEntries) {
-        return RepositoryEntities.repositoryChanged(loaded.entity)
-            ? this.commitChanged(repository, runtime, tenantId, session, loaded, entityId, makeNext, historyEntries)
-            : session.complete(makeNext, historyEntries);
-    },
-    /**
-     * Wraps original preference Events as indexed Agent history entries.
-     *
-     * @param events Original Event envelopes retained for diagnostics.
-     * @returns Typed Agent history rows for saved preference changes.
-     */
-    preferenceHistory(events) {
-        return events.map((event) => {
-            const occurredAt = event.context?.timestamp;
-            if (occurredAt === undefined)
-                throw new Error("Agent preference Event requires Time.");
-            return create(AgentHistoryEntrySchema, {
-                occurredAt,
-                item: { case: "systemEvent", value: event },
-            });
-        });
-    },
-    /**
-     * Captures only effective preference changes committed by this signal.
-     *
-     * @param repository Registered Entity repository for this operation.
-     * @param runtime Bounded Context storage and publication services.
-     * @param tenantId Tenant selected for this accepted signal.
-     * @param session Fenced Agent execution session.
-     * @returns Original model-selection System Events.
-     */
-    preferenceEvents(repository, runtime, tenantId, session) {
-        const accepted = session.record().accepted;
-        if (accepted?.recipientId === undefined)
-            throw new Error("Agent preference requires accepted work.");
-        const scope = AgentModelSelection.scope(accepted, repository.stateSchema, tenantId);
-        return [AiModelKind.GENERATION, AiModelKind.DECISION].flatMap((kind) => {
-            const previous = this.preferenceModel(session.initialPreferences(), kind);
-            const selected = this.preferenceModel(session.preferences(), kind);
-            if (previous === undefined && selected === undefined)
-                return [];
-            if (previous !== undefined &&
-                selected !== undefined &&
-                equals(ModelRefSchema, previous, selected))
-                return [];
-            return [this.preferenceEvent(accepted, scope, kind, previous, selected, runtime)];
-        });
-    },
+        return selected;
+    }
     /**
-     * Builds one effective selection change with its original causal context.
+     * Captures the configured live invocation deadline.
      *
-     * @param accepted Durable original signal and saved handler bindings.
-     * @param scope Accepted actor, source, Bounded Context, and tenant.
-     * @param kind Generation or decision model kind.
-     * @param previous Previously selected model deployment.
-     * @param selected Newly selected model deployment.
-     * @param runtime Bounded Context storage and publication services.
-     * @returns Original model-selection System Event.
+     * @param ai Configured AI capability.
+     * @returns The sampled live invocation deadline, when configured.
      */
-    preferenceEvent(accepted, scope, kind, previous, selected, runtime) {
-        const recipientId = accepted.recipientId;
-        if (recipientId === undefined)
-            throw new Error("Agent preference requires a recipient.");
-        const payload = create(SelectionChangedSchema, {
-            agent: scope.agent,
-            sourceSignal: scope.source,
-            kind,
-            ...(previous === undefined ? {} : { previousModel: previous }),
-            ...(selected === undefined ? {} : { selectedModel: selected }),
-            changedAt: Time.currentTime(),
-        });
-        runtime.registerSystemEventSchema(SelectionChangedSchema);
-        return AgentInteractionEvents.envelope(accepted, runtime.signalMetadata, recipientId, SelectionChangedSchema, payload);
-    },
+    deadline(ai) {
+        if (this.#deadlineSampled)
+            return this.#deadlineEpochMs;
+        this.#deadlineSampled = true;
+        const duration = this.limits(ai).deadlineMs;
+        this.#deadlineEpochMs =
+            duration === undefined ? undefined : Time.currentTimeMillis() + duration;
+        return this.#deadlineEpochMs;
+    }
     /**
-     * Reads an explicit model selection, including inherited defaults as absence.
+     * Applies only the narrower per-repository bounds to the shared registry policy.
      *
-     * @param preferences Current Agent instance model preferences.
-     * @param kind Generation or decision model kind.
-     * @returns Selected deployment reference, or inherited default.
+     * @param ai Configured AI capability.
+     * @returns The current configured limits for the start audit.
      */
-    preferenceModel(preferences, kind) {
-        const selected = preferences.find((entry) => entry.kind === kind);
-        return selected?.selection.case === "model" ? selected.selection.value : undefined;
-    },
-    /**
-     * Builds the immutable completion image and emitted domain history.
-     *
-     * @param record Durable Agent execution record.
-     * @param version Entity version associated with the signal.
-     * @param outputs Prepared outgoing domain signals.
-     * @param preferences Current Agent instance model preferences.
-     * @returns Record completed with original outputs and resulting version.
-     */
-    completionFacts(record, version, outputs, preferences) {
-        const initialVersion = record.started?.initialVersion;
-        if (initialVersion === undefined)
-            throw new Error("Agent completion requires its started Version.");
-        const commands = outputs
-            .filter((output) => output.case === "command")
-            .map((output) => create(AgentOutgoingCommandSchema, { command: output.value }));
-        record.status =
-            commands.length === 0
-                ? AgentInvocationStatus.AGENT_INVOCATION_COMPLETED
-                : AgentInvocationStatus.AGENT_INVOCATION_COMPLETED_PENDING_COMMANDS;
-        record.completion = create(AgentExecutionCompletionSchema, {
-            initialVersion,
-            resultingVersion: version,
-            preferences: [...preferences],
-            commands,
-        });
-        return record;
-    },
+    limits(ai) {
+        const global = registryOptions(ai).invocationLimits ?? {};
+        const local = repositoryAccess.agentConfiguration(this.repository).ai?.invocationLimits ?? {};
+        const limits = {};
+        const keys = [
+            "operations",
+            "modelRequests",
+            "toolCalls",
+            "recordedReads",
+            "deadlineMs",
+            "totalInputBytes",
+            "totalOutputBytes",
+        ];
+        for (const key of keys) {
+            const first = global[key];
+            const second = local[key];
+            const value = first === undefined ? second : second === undefined ? first : Math.min(first, second);
+            if (value !== undefined)
+                limits[key] = value;
+        }
+        return limits;
+    }
     /**
-     * Stores only committed domain Events in the Agent's emitted history.
+     * Binds one original System audit writer to retained Agent history.
      *
-     * @param outputs Prepared outgoing domain signals.
-     * @returns Committed domain Event rows for Agent history.
+     * @param loaded Current Entity and retained storage for this turn.
+     * @returns The history writer bound to this Agent and source.
      */
-    emittedHistory(outputs) {
-        return outputs.flatMap((output) => {
-            if (output.case !== "event" || output.value.context?.rejection !== undefined)
-                return [];
-            const event = output.value;
-            const occurredAt = event.context?.timestamp;
-            if (occurredAt === undefined)
-                throw new Error("Agent emitted Event requires its original timestamp.");
-            return [
-                create(AgentHistoryEntrySchema, {
-                    occurredAt,
-                    item: { case: "domainEvent", value: event },
-                }),
-            ];
+    audit(loaded) {
+        const history = loaded.agentHistory;
+        if (history === undefined)
+            throw new Error("Live Agent execution requires history storage.");
+        return new AgentLiveAudit(this.invocation, this.repository.stateSchema, this.entityId, loaded.storageInput.id.key(this.entityId), history, this.runtime.signalMetadata, this.runtime.registerSystemEventSchema, this.runtime.publishAgentSystemEvent, async () => {
+            this.signal.throwIfAborted();
+            await this.checkSession();
+            this.signal.throwIfAborted();
         });
-    },
+    }
     /**
-     * Commits changed Entity state with the already prepared execution image.
+     * Writes the genuine dispatch System row before publishing its original Event.
      *
-     * @param repository Registered Entity repository for this operation.
-     * @param runtime Bounded Context storage and publication services.
-     * @param tenantId Tenant selected for this accepted signal.
-     * @param session Fenced Agent execution session.
-     * @param loaded Loaded Entity and its repository storage state.
-     * @param entityId Typed recipient Entity identifier.
-     * @param makeNext Callback constructing the next durable execution record.
-     * @param historyEntries Agent history rows included in the fenced mutation.
-     * @returns Saved execution record after the changed Entity commit.
+     * @param loaded Current Entity and retained storage for this turn.
+     * @returns Completion after the original dispatch System Event is saved.
      */
-    async commitChanged(repository, runtime, tenantId, session, loaded, entityId, makeNext, historyEntries) {
-        const version = RepositoryEntities.repositoryVersion(loaded.entity);
-        const state = RepositoryEntities.repositoryState(loaded.entity);
-        const lifecycle = RepositoryEntities.repositoryLifecycle(loaded.entity);
-        const deferred = await standAccess.deferUpdate(runtime.stand, repository.stateSchema, state, RepositoryStand.standUpdateOptions(tenantId, version, lifecycle), repository.metadata);
-        const prepared = RepositoryStand.preparedRecord(repository, deferred, entityId);
-        return this.commitDeferred(repository, session, loaded, entityId, makeNext, historyEntries, deferred, prepared);
-    },
+    async dispatchStart(loaded) {
+        await this.checkSession();
+        const source = this.invocation.source;
+        const event = source.case === "command"
+            ? HandlerDispatchPublisher.commandEvent(this.runtime, this.repository, source.value, this.entityId)
+            : HandlerDispatchPublisher.reactorEvent(this.runtime, this.repository, source.value, this.entityId);
+        const occurredAt = event.context?.timestamp;
+        if (occurredAt === undefined || loaded.agentHistory === undefined)
+            throw new Error("Agent dispatch audit requires timestamp and history.");
+        await loaded.agentHistory.appendAll(this.entityId, [
+            create(AgentHistoryEntrySchema, { occurredAt, item: { case: "systemEvent", value: event } }),
+        ]);
+        await this.checkSession();
+        if (source.case === "command")
+            HandlerDispatchPublisher.publishCommand(this.runtime, event);
+        else
+            HandlerDispatchPublisher.publishReactor(this.runtime, event);
+    }
     /**
-     * Applies the deferred Stand image only after fenced provider completion.
+     * Executes current generated handlers inside the Entity's local transaction.
      *
-     * @param repository Registered Entity repository for this operation.
-     * @param session Fenced Agent execution session.
-     * @param loaded Loaded Entity and its repository storage state.
-     * @param entityId Typed recipient Entity identifier.
-     * @param makeNext Callback constructing the next durable execution record.
-     * @param historyEntries Agent history rows included in the fenced mutation.
-     * @param deferred Prepared Stand update awaiting conditional commit.
-     * @param prepared Prepared conditional Entity commit.
-     * @returns Saved execution record after the deferred Entity commit.
+     * @param audit Retained history audit for this invocation.
+     * @param budget Invocation-wide resource budget.
+     * @param loaded Current Entity and retained storage for this turn.
+     * @param preferences Current or staged model preferences.
+     * @param selected Models or selection retained for this invocation.
+     * @returns The typed model result with its operation identifier.
      */
-    async commitDeferred(repository, session, loaded, entityId, makeNext, historyEntries, deferred, prepared) {
+    async invoke(loaded, selected, preferences, audit, budget) {
+        transactionalEntityAccess.start(loaded.entity);
         try {
-            const completed = await session.complete(makeNext, historyEntries, {
-                context: loaded.storageInput.context,
-                entity: loaded.storageInput,
-                entityId,
-                next: prepared,
-                ...(RepositoryStorage.historyConfiguration(repository).stateHistory
-                    ? { states: [prepared] }
-                    : {}),
-            });
-            deferred.notify();
-            return completed;
+            const produced = [];
+            for (const handler of this.handlers)
+                produced.push(...(await this.invokeHandler(loaded, handler, selected, preferences, audit, budget)));
+            const commit = await commitFenced(loaded.entity, (current) => transactionalEntityAccess.commit(current));
+            if (commit.status === "rejected")
+                throw new TransitionValidationError(commit.validation.error);
+            return produced;
         }
         catch (error) {
-            deferred.cancel();
+            transactionalEntityAccess.rollback(loaded.entity);
             throw error;
         }
-    },
-    /**
-     * Binds declared generated Event and Command results in handler order.
-     *
-     * @param repository Agent declaration.
-     * @param runtime Signal metadata factory.
-     * @param accepted Original accepted envelope.
-     * @param entityId Typed recipient.
-     * @param version Entity Version before this transition.
-     * @param produced Handler results in declaration order.
-     * @returns Original outgoing envelopes ready for one conditional completion.
-     */
-    bindOutputs(repository, runtime, accepted, entityId, version, produced) {
-        const source = accepted.signal;
-        if (source.case !== "command" && source.case !== "event")
-            throw new Error("Agent output requires its accepted source signal.");
-        const routing = repositoryRoutings.get(repository);
-        if (routing === undefined)
-            throw new Error("Agent output requires registered schemas.");
-        return produced.map((signal) => this.bindOutput(repository, runtime, routing, source, entityId, version, signal));
-    },
-    /**
-     * Binds one declared result using its generated Event or Command role.
-     *
-     * @param repository Registered Entity repository for this operation.
-     * @param runtime Bounded Context storage and publication services.
-     * @param routing Registered generated handler routing metadata.
-     * @param source Original accepted source signal.
-     * @param entityId Typed recipient Entity identifier.
-     * @param version Entity version associated with the signal.
-     * @param signal Original domain signal or execution cancellation signal.
-     * @returns Typed outgoing signal with its original envelope.
-     */
-    bindOutput(repository, runtime, routing, source, entityId, version, signal) {
-        const typeName = EntityInvocation.messageTypeName(signal);
-        const eventSchema = routing.producedEventSchemas.find((entry) => entry.typeName === typeName);
-        if (eventSchema !== undefined)
-            return this.bindEventOutput(repository, runtime, source, entityId, version, signal, eventSchema);
-        const schema = routing.producedCommandSchemas.find((entry) => entry.typeName === typeName);
-        if (schema === undefined)
-            throw new Error(`Agent cannot emit undeclared signal "${typeName}".`);
-        return this.bindCommandOutput(runtime, source, signal, schema);
-    },
-    /**
-     * Creates the original domain Event envelope and producer context.
-     *
-     * @param repository Registered Entity repository for this operation.
-     * @param runtime Bounded Context storage and publication services.
-     * @param source Original accepted source signal.
-     * @param entityId Typed recipient Entity identifier.
-     * @param version Entity version associated with the signal.
-     * @param signal Original domain signal or execution cancellation signal.
-     * @param schema Generated message descriptor for the signal.
-     * @returns Typed original Event envelope for one normal EventBus handoff.
-     */
-    bindEventOutput(repository, runtime, source, entityId, version, signal, schema) {
-        if (source.case !== "command" && source.case !== "event")
-            throw new Error("Missing source.");
-        const metadata = source.case === "command"
-            ? runtime.signalMetadata.eventFromCommand(source.value, { version: version.number })
-            : runtime.signalMetadata.eventFromEvent(source.value, { version: version.number });
-        const event = create(EventSchema, {
-            id: metadata.id,
-            message: AnyMessages.pack(schema, signal),
-            context: RepositorySignals.eventContextWithProducer(metadata.context, repository, entityId, version),
-        });
-        return { case: "event", value: event };
-    },
-    /**
-     * Creates the original Command envelope from its accepted origin.
-     *
-     * @param runtime Bounded Context storage and publication services.
-     * @param source Original accepted source signal.
-     * @param signal Original domain signal or execution cancellation signal.
-     * @param schema Generated message descriptor for the signal.
-     * @returns Typed original Command envelope for durable delivery.
-     */
-    bindCommandOutput(runtime, source, signal, schema) {
-        if (source.case !== "command" && source.case !== "event")
-            throw new Error("Missing source.");
-        const metadata = source.case === "command"
-            ? runtime.signalMetadata.commandFromCommand(source.value)
-            : runtime.signalMetadata.commandFromEvent(source.value);
-        const command = create(CommandSchema, {
-            id: metadata.id,
-            message: AnyMessages.pack(schema, signal),
-            context: metadata.context,
-        });
-        return { case: "command", value: command };
-    },
+    }
     /**
-     * Dispatches every emitted Event to the normal EventBus and advances saved Commands.
+     * Executes one handler with live AI and read facades scoped to its returned work.
      *
-     * @param runtime Bound normal bus acceptance callbacks.
-     * @param session Fenced record containing pending saved envelopes.
-     * @param outputs Locally produced outputs in original handler order.
-     * @returns When the fenced repository operation completes.
+     * @param audit Retained history audit for this invocation.
+     * @param budget Invocation-wide resource budget.
+     * @param handler Selected generated handler.
+     * @param loaded Current Entity and retained storage for this turn.
+     * @param preferences Current or staged model preferences.
+     * @param selected Models or selection retained for this invocation.
+     * @returns The declared handler result scoped to live capabilities.
      */
-    async deliverInitial(runtime, session, outputs) {
-        let commandIndex = 0;
-        let failed = false;
-        let firstFailure;
-        for (const output of outputs) {
-            try {
-                if (output.case === "event") {
-                    await runtime.publishAgentEvent(output.value);
-                }
-                else {
-                    await this.deliverCommand(runtime, session, commandIndex);
-                }
-            }
-            catch (error) {
-                if (!failed) {
-                    firstFailure = error;
-                    failed = true;
-                }
-            }
-            if (output.case === "command")
-                commandIndex += 1;
+    async invokeHandler(loaded, handler, selected, preferences, audit, budget) {
+        const { facade, actor, deadline } = this.handlerFacade(selected, preferences, audit, budget);
+        const historyScope = repositoryAccess.agentHistoryScope(loaded.storageInput.context, loaded.storageInput, this.entityId);
+        const reads = new AgentLiveReadRuntime(historyScope, budget, this.checkSession);
+        const release = this.bind(loaded.entity, facade, reads, actor);
+        try {
+            const output = await AgentLiveHandler.awaitHandler(this.callHandler(loaded.entity, handler), this.signal, deadline);
+            reads.finish();
+            facade.finish();
+            return output;
         }
-        if (failed)
-            throw firstFailure;
-    },
-    /**
-     * Retries pending saved Commands without rerunning the Agent handler.
-     *
-     * @param runtime Bound normal Command bus callbacks.
-     * @param session Fenced record containing saved Commands.
-     * @returns Completion after pending Command attempts.
-     */
-    async deliverCommands(runtime, session) {
-        for (const [index] of (session.record().completion?.commands ?? []).entries()) {
-            if (session.signal.aborted)
-                return;
-            await this.deliverCommand(runtime, session, index);
+        finally {
+            facade.close();
+            release();
         }
-    },
+    }
     /**
-     * Sends one saved Command under the current claim and records its acknowledgement.
+     * Creates live AI and actor capabilities to one generated handler.
      *
-     * @param runtime Bound normal Command bus callbacks.
-     * @param session Fenced record containing saved Commands.
-     * @param index Command position in the saved completion.
-     * @returns Completion after the Command is acknowledged or already delivered.
+     * @param audit Retained history audit for this invocation.
+     * @param budget Invocation-wide resource budget.
+     * @param preferences Current or staged model preferences.
+     * @param selected Models or selection retained for this invocation.
+     * @returns The handler facade with live AI and actor capabilities.
      */
-    async deliverCommand(runtime, session, index) {
-        const output = session.record().completion?.commands[index];
-        if (output === undefined || output.delivered)
-            return;
-        const command = output.command;
-        if (command === undefined)
-            throw new Error("Agent outgoing Command has no original envelope.");
-        const key = this.outputKey(output);
-        const plan = output.plan ?? (await runtime.prepareSavedCommand(command));
-        if (output.plan === undefined) {
-            await session.update((current) => {
-                const pending = current.completion?.commands[index];
-                if (pending === undefined ||
-                    pending.plan !== undefined ||
-                    pending.command?.id?.uuid !== command.id?.uuid)
-                    throw new Error("Saved Agent Command changed before plan installation.");
-                pending.plan = plan;
-                return current;
-            });
-        }
-        await runtime.publishSavedCommand(command, plan);
-        await session.markDelivered([key]);
-        runtime.recordAcceptedSaved(command);
-    },
+    handlerFacade(selected, preferences, audit, budget) {
+        const ai = this.runtime.ai;
+        const policy = repositoryAccess.agentConfiguration(this.repository).ai;
+        if (ai === undefined || policy === undefined)
+            throw new Error("Agent AI policy is missing.");
+        const scope = AgentModelSelection.scopeLive(this.invocation, this.repository.stateSchema, this.runtime.signalMetadata, this.tenantId);
+        const facade = new AgentLiveAiRuntime(ai, policy, scope, selected, budget, this.signal, this.deadline(ai), (kind, model) => {
+            this.stage(preferences, kind, model);
+        }, audit, this.checkSession);
+        return { facade, actor: scope.actor, deadline: this.deadline(ai) };
+    }
     /**
-     * Returns the typed original ID of one completed outgoing Command.
+     * Prepares a per-kind selection without changing the observed preference image.
      *
-     * @param output Prepared outgoing Command.
-     * @returns Original durable Command ID.
+     * @param kind Declared model or operation kind.
+     * @param model Selected AI model for this invocation.
+     * @param preferences Current or staged model preferences.
      */
-    outputKey(output) {
-        if (output.command?.id !== undefined)
-            return output.command.id;
-        throw new Error("Agent outgoing Command requires its original typed ID.");
-    },
+    stage(preferences, kind, model) {
+        const index = preferences.findIndex((entry) => entry.kind === kind);
+        if (index >= 0)
+            preferences.splice(index, 1);
+        if (model !== undefined)
+            preferences.push(create(ModelPreferenceSchema, { kind, selection: { case: "model", value: model } }));
+    }
     /**
-     * Validates every stored binding against the current generated selectors.
+     * Binds current protected history, query, and AI capabilities to one handler.
      *
-     * @param repository Agent registration.
-     * @param accepted Immutable source and ordered bindings.
-     * @returns Current matching handler metadata.
+     * @param actor Captured signal actor context.
+     * @param entity Current Entity instance.
+     * @param facade Handler-facing operation facade.
+     * @param reads Retained Agent history reader.
+     * @returns The handler bound to current protected history and AI capabilities.
      */
-    handlers(repository, accepted) {
-        const routing = repositoryRoutings.get(repository);
-        if (routing === undefined)
-            throw new Error("Agent execution requires registered handlers.");
-        const current = this.selectedHandlers(routing, accepted);
-        if (accepted.handlers.length !== current.length || current.length === 0)
-            throw new AgentExecutionFault("REVISION_CHANGED", "Accepted Agent handler binding changed before replay.");
-        for (const [ordinal, handler] of current.entries()) {
-            const binding = accepted.handlers[ordinal];
-            if (binding === undefined || !AgentAdmission.matchesHandler(binding, handler, ordinal))
-                throw new AgentExecutionFault("REVISION_CHANGED", "Accepted Agent handler binding changed before replay.");
+    bind(entity, facade, reads, actor) {
+        const history = AgentHistoryReads.withReadInterceptor(entity, (scope, request, live, maxBytes, present) => reads.history(scope, request, live, maxBytes, present));
+        let query;
+        try {
+            query = ProcessManagerQueries.bind(entity, this.runtime, actor, this.tenantId, (schema, request, live) => reads.query(schema, request, live));
+            const ai = AgentAiBindings.bind(entity, facade);
+            return () => {
+                ai();
+                query?.();
+                history();
+            };
         }
-        return current;
-    },
-    /**
-     * Finds current Command or Event handlers from the immutable source envelope.
-     *
-     * @param routing Registered generated handler routing metadata.
-     * @param accepted Durable original signal and saved handler bindings.
-     * @returns Generated handlers selected for the accepted signal.
-     */
-    selectedHandlers(routing, accepted) {
-        if (accepted.signal.case === "command") {
-            const binding = accepted.handlers[0];
-            const current = routing.commandReadiness?.findCommandAssignee(binding?.signalType ?? "");
-            return current === undefined ? [] : [current.registeredHandler];
-        }
-        if (accepted.signal.case !== "event")
-            throw new Error("Agent source envelope is missing.");
-        const event = accepted.signal.value;
-        const packed = EntityInvocation.requireSignalMessage(event.message, "event");
-        const schema = RepositoryRoutes.schemaForTypeUrl(routing.eventSchemas, packed.typeUrl, "event");
-        const value = EntityInvocation.unpackRequired(packed, schema, "event");
-        const external = event.context?.external === true;
-        return [
-            ...routing.eventReactors(schema.typeName, value, external),
-            ...routing.commandReactions(schema.typeName, value, external),
-        ];
-    },
-    /**
-     * Records start facts and the original dispatch System Event before handler execution.
-     *
-     * @param repository Agent registration.
-     * @param runtime Bound services.
-     * @param session Fenced provider claim and current record.
-     * @param loaded Restored Entity and initial Version.
-     * @param entityId Original typed recipient.
-     * @param tenantId Accepted delivery tenant when applicable.
-     * @returns Updated record image for exact subsequent CAS.
-     */
-    async start(repository, runtime, session, loaded, entityId, tenantId) {
-        const accepted = session.record().accepted;
-        if (accepted === undefined)
-            throw new Error("Agent start requires accepted work.");
-        const started = this.startFacts(repository, runtime, accepted, loaded);
-        const audit = this.startAudit(runtime, repository, accepted, entityId);
-        await session.update((current) => {
-            current.started = started;
-            return current;
-        }, [this.startHistory(audit)]);
-        if (accepted.signal.case === "command")
-            HandlerDispatchPublisher.publishCommand(runtime, audit);
-        else
-            HandlerDispatchPublisher.publishReactor(runtime, audit);
-        return this.selectMissingModels(repository, runtime, session, accepted, tenantId);
-    },
-    /**
-     * Stores the original dispatch audit envelope in mandatory Agent history.
-     *
-     * @param audit Original Agent System event envelope.
-     * @returns Typed Agent history row for the original dispatch Event.
-     */
-    startHistory(audit) {
-        const occurredAt = audit.context?.timestamp;
-        if (occurredAt === undefined)
-            throw new Error("Agent dispatch audit requires its timestamp.");
-        return create(AgentHistoryEntrySchema, {
-            occurredAt,
-            item: { case: "systemEvent", value: audit },
-        });
-    },
-    /**
-     * Verifies admission revisions and fixes whole-invocation limits before execution.
-     *
-     * @param repository Registered Entity repository for this operation.
-     * @param runtime Bounded Context storage and publication services.
-     * @param accepted Durable original signal and saved handler bindings.
-     * @param loaded Loaded Entity and its repository storage state.
-     * @returns Durable deadline, initial version, and whole-invocation bounds.
-     */
-    startFacts(repository, runtime, accepted, loaded) {
-        const configuration = repositoryAccess.agentConfiguration(repository);
-        const ai = runtime.ai;
-        if (accepted.key === undefined || ai === undefined || configuration.ai === undefined)
-            throw new Error("Agent execution start requires accepted work and AI policy.");
-        const limits = registryOptions(ai).invocationLimits ?? {};
-        return create(AgentExecutionStartSchema, {
-            ...(limits.deadlineMs === undefined
-                ? {}
-                : { deadline: addMillis(Time.currentTime(), limits.deadlineMs) }),
-            initialVersion: RepositoryEntities.priorVersion(loaded.current),
-            bounds: this.invocationBounds(limits),
-        });
-    },
-    /**
-     * Persists each model kind without a saved connection identity.
-     *
-     * @param repository Agent registration and permitted capabilities.
-     * @param runtime Bound AI registry.
-     * @param session Current fenced execution record.
-     * @param accepted Original accepted signal and actor.
-     * @param tenantId Accepted tenant when applicable.
-     * @returns Record after each missing identity has been saved.
-     */
-    async selectMissingModels(repository, runtime, session, accepted, tenantId) {
-        const ai = runtime.ai;
-        const configuration = repositoryAccess.agentConfiguration(repository).ai;
-        if (ai === undefined || configuration === undefined)
-            throw new Error("Agent model selection requires saved start facts and AI policy.");
-        const deadlineMs = this.savedModelDeadline(session, "selection");
-        const source = accepted.signal.value?.message;
-        for (const kind of ["generation", "decision"]) {
-            if (!configuration.models.some((model) => model.definition.kind === kind))
-                continue;
-            const modelKind = AgentModelSelection.kind(kind);
-            if (session.record().started?.models.some((model) => model.kind === modelKind))
-                continue;
-            const selected = await AgentModelSelection.selectKind(ai, configuration, AgentModelSelection.scope(accepted, repository.stateSchema, tenantId), session.initialPreferences(), session.signal, deadlineMs, kind, source);
-            await this.saveSelectedModel(session, selected);
+        catch (error) {
+            query?.();
+            history();
+            throw error;
         }
-        return session.record();
-    },
+    }
     /**
-     * Writes one selected model under the current Agent claim.
+     * Invokes and validates one declared generated Command or Event handler.
      *
-     * @param session Fenced Agent execution session.
-     * @param selected Authorized deployment and connection identity.
-     * @returns When the selection is durable.
+     * @param entity Current Entity instance.
+     * @param handler Selected generated handler.
+     * @returns The validated generated handler result.
      */
-    async saveSelectedModel(session, selected) {
-        await session.update((record) => {
-            if (record.started === undefined)
-                throw new Error("Agent start facts disappeared.");
-            record.started.models.push(selected);
-            return record;
-        });
-    },
-    /**
-     * Rejects accepted work when its exact handler and AI policy changed.
-     *
-     * @param repository Registered Entity repository for this operation.
-     * @param accepted Durable original signal and saved handler bindings.
-     * @param handlers Generated handlers in their saved order.
-     * @param ai Configured AI registry for this Bounded Context.
-     * @param configuration Repository and AI policy used for revision checks.
-     */
-    assertRevisions(repository, accepted, handlers, ai, configuration) {
-        if (configuration.ai === undefined)
-            throw new Error("Agent AI policy is required.");
-        const revisions = AgentRevisions.atAdmission(repository.stateSchema, handlers, ai, configuration.ai);
-        if (accepted.codeRevision?.value !== configuration.codeRevision ||
-            accepted.schemaRevision?.value !== revisions.schema ||
-            accepted.policyRevision?.value !== revisions.policy)
-            throw new AgentExecutionFault("REVISION_CHANGED", "Accepted Agent code, schema, or policy changed before execution.");
-    },
-    /**
-     * Copies the whole-invocation budget into its durable integer fields.
-     *
-     * @param limits Configured whole-invocation limits.
-     * @returns Whole-transition limits persisted at invocation start.
-     */
-    invocationBounds(limits) {
-        return create(AgentInvocationBoundsSchema, {
-            ...(limits.operations === undefined ? {} : { operations: BigInt(limits.operations) }),
-            ...(limits.modelRequests === undefined
-                ? {}
-                : { modelRequests: BigInt(limits.modelRequests) }),
-            ...(limits.toolCalls === undefined ? {} : { toolCalls: BigInt(limits.toolCalls) }),
-            ...(limits.recordedReads === undefined
-                ? {}
-                : { recordedReads: BigInt(limits.recordedReads) }),
-            ...(limits.deadlineMs === undefined ? {} : { deadlineMillis: BigInt(limits.deadlineMs) }),
-            ...(limits.totalInputBytes === undefined
-                ? {}
-                : { totalInputBytes: BigInt(limits.totalInputBytes) }),
-            ...(limits.totalOutputBytes === undefined
-                ? {}
-                : { totalOutputBytes: BigInt(limits.totalOutputBytes) }),
-            ...(limits.maxRecoveryBytes === undefined
-                ? {}
-                : { maxRecoveryBytes: BigInt(limits.maxRecoveryBytes) }),
-        });
-    },
+    async callHandler(entity, handler) {
+        const source = this.invocation.source;
+        const kind = source.case;
+        const message = EntityInvocation.unpackRequired(EntityInvocation.requireSignalMessage(source.value.message, kind), handler.handler.schema, kind);
+        const context = kind === "command"
+            ? EntityInvocation.commandHandlerContext(source.value)
+            : EntityInvocation.eventHandlerContext(source.value);
+        const produced = await EntityInvocation.invokeEntityMethod(entity, handler.handler.methodName, message, handler.handler.parameterCount, context);
+        const outputs = produced === undefined
+            ? []
+            : Array.isArray(produced)
+                ? Array.from(produced)
+                : [produced];
+        RepositoryHandlers.requireDeclaredOutputs(handler.handler, outputs);
+        return outputs;
+    }
     /**
-     * Creates a genuine source-specific dispatch System Event before the handler.
+     * Commits the observed state/preferences image and its final audit atomically.
      *
-     * @param runtime Bounded Context storage and publication services.
-     * @param repository Registered Entity repository for this operation.
-     * @param accepted Durable original signal and saved handler bindings.
-     * @param entityId Typed recipient Entity identifier.
-     * @returns Original dispatch System Event envelope.
+     * @param expected Expected persisted value or version.
+     * @param loaded Current Entity and retained storage for this turn.
+     * @param preferences Current or staged model preferences.
+     * @param produced Declared outgoing signals.
+     * @returns Completion after the conditional state, preferences, and final audit commit.
      */
-    startAudit(runtime, repository, accepted, entityId) {
-        const source = accepted.signal;
-        if (source.case === "command")
-            return HandlerDispatchPublisher.commandEvent(runtime, repository, source.value, entityId);
-        if (source.case === "event")
-            return HandlerDispatchPublisher.reactorEvent(runtime, repository, source.value, entityId);
-        throw new Error("Agent start requires its accepted envelope.");
-    },
+    async complete(loaded, expected, preferences, produced) {
+        const version = RepositoryEntities.repositoryVersion(loaded.entity);
+        const routing = repositoryRoutings.get(this.repository);
+        if (routing === undefined)
+            throw new Error("Live Agent output requires registered routing.");
+        const outputs = produced.case === "rejected"
+            ? [produced.output]
+            : produced.values.map((item) => AgentLiveOutputs.bindOutput(this.repository, this.runtime, routing, this.invocation.source, this.entityId, version, item));
+        await this.authorizePreferences(expected ?? [], preferences);
+        await this.checkSession();
+        const preferenceEvents = this.preferenceEvents(expected ?? [], preferences);
+        const history = [
+            ...AgentLiveOutputs.emittedHistory(outputs),
+            ...preferenceEvents.map((event) => this.systemEntry(event)),
+        ];
+        await this.commit(loaded, expected, preferences, history);
+        await this.checkSession();
+        for (const event of preferenceEvents)
+            await this.runtime.publishAgentSystemEvent(event);
+        this.publish(outputs);
+    }
     /**
-     * Invokes saved Command or Event bindings inside one Entity transaction.
+     * Applies final conditional state and preference mutation under the observed Version.
      *
-     * @param entity Restored Agent instance.
-     * @param accepted Original accepted signal.
-     * @param handlers Validated current handler bindings.
-     * @param repository Registered Entity repository for this operation.
-     * @param runtime Bounded Context storage and publication services.
-     * @param tenantId Tenant selected for this accepted signal.
-     * @param session Fenced Agent execution session.
-     * @returns Outputs returned by the selected generated handlers.
+     * @param expected Expected persisted value or version.
+     * @param history Retained history entries or history port.
+     * @param loaded Current Entity and retained storage for this turn.
+     * @param preferences Current or staged model preferences.
+     * @returns The atomic conditional commit result for the observed version.
      */
-    async invoke(repository, runtime, tenantId, session, entity, accepted, handlers) {
-        transactionalEntityAccess.start(entity);
+    async commit(loaded, expected, preferences, history) {
+        const deferred = await this.deferredUpdate(loaded);
         try {
-            const signals = [];
-            for (const [ordinal, handler] of handlers.entries()) {
-                signals.push(...(await this.invokeBoundHandler(repository, runtime, tenantId, session, entity, accepted, handler, ordinal)));
-            }
-            await this.commitInvokedEntity(entity);
-            return signals;
+            const prepared = deferred === undefined
+                ? undefined
+                : RepositoryStand.preparedRecord(this.repository, deferred, this.entityId);
+            await this.checkSession();
+            await loaded.commits.commitAgent({
+                entityId: this.entityId,
+                expectedVersion: loaded.current?.version?.number ?? 0,
+                expectedPreferences: expected,
+                preferences,
+                historyEntries: history,
+                ...(prepared === undefined ? {} : { entityCommit: this.entityCommit(loaded, prepared) }),
+            });
+            deferred?.notify();
         }
         catch (error) {
-            transactionalEntityAccess.rollback(entity);
+            deferred?.cancel();
             throw error;
         }
-    },
+    }
     /**
-     * Validates the transaction result before Agent output completion.
+     * Creates current state and its enabled history only for a changed Entity.
      *
-     * @param entity Loaded recipient Entity instance.
-     * @returns When the fenced repository operation completes.
+     * @param loaded Current Entity and retained storage for this turn.
+     * @param prepared Prepared Entity mutation and outputs.
+     * @returns The changed Entity image and enabled history for the commit.
      */
-    async commitInvokedEntity(entity) {
-        const commit = await commitFenced(entity, (current) => transactionalEntityAccess.commit(current));
-        if (commit.status === "rejected")
-            throw new TransitionValidationError(commit.validation.error);
-    },
+    entityCommit(loaded, prepared) {
+        return {
+            context: loaded.storageInput.context,
+            entity: loaded.storageInput,
+            entityId: this.entityId,
+            next: prepared,
+            ...(loaded.storageInput.stateHistory ? { states: [prepared] } : {}),
+        };
+    }
     /**
-     * Binds named AI and history reads around one generated handler call.
+     * Prepares the changed Entity state for publication only after atomic commit.
      *
-     * @param repository Registered Entity repository for this operation.
-     * @param runtime Bounded Context storage and publication services.
-     * @param tenantId Tenant selected for this accepted signal.
-     * @param session Fenced Agent execution session.
-     * @param entity Loaded recipient Entity instance.
-     * @param accepted Durable original signal and saved handler bindings.
-     * @param handler Generated handler selected for this signal.
-     * @param ordinal Saved position of the selected handler.
-     * @returns Outputs returned by one generated handler.
-     */
-    async invokeBoundHandler(repository, runtime, tenantId, session, entity, accepted, handler, ordinal) {
-        const facade = this.handlerFacade(repository, runtime, tenantId, session, accepted, ordinal);
-        const reads = new AgentReadRuntime(session, ordinal);
-        const release = this.bindHandlerCapabilities(entity, runtime, tenantId, accepted, reads, facade);
-        try {
-            const deadlineEpochMs = this.handlerDeadline(session);
-            const signals = await this.awaitHandler(this.invokeHandler(entity, accepted, handler), session.signal, deadlineEpochMs);
-            reads.finish();
-            facade.finish();
-            return signals;
-        }
-        finally {
-            facade.close();
-            release();
+     * @param loaded Current Entity and retained storage for this turn.
+     * @returns The Stand update deferred until the atomic commit succeeds.
+     */
+    deferredUpdate(loaded) {
+        if (!RepositoryEntities.repositoryChanged(loaded.entity))
+            return Promise.resolve(undefined);
+        return standAccess.deferUpdate(this.runtime.stand, this.repository.stateSchema, RepositoryEntities.repositoryState(loaded.entity), RepositoryStand.standUpdateOptions(this.tenantId, RepositoryEntities.repositoryVersion(loaded.entity), RepositoryEntities.repositoryLifecycle(loaded.entity)), this.repository.metadata);
+    }
+    /**
+     * Checks authorization of effective changed selections before final persistence.
+     *
+     * @param after Proposed value after the transition.
+     * @param before Persisted value before the transition.
+     * @returns Completion after changed model selections pass authorization.
+     */
+    async authorizePreferences(before, after) {
+        const ai = this.runtime.ai;
+        const policy = repositoryAccess.agentConfiguration(this.repository).ai;
+        if (ai === undefined || policy?.authorizeSelection === undefined)
+            return;
+        const scope = AgentModelSelection.scopeLive(this.invocation, this.repository.stateSchema, this.runtime.signalMetadata, this.tenantId);
+        for (const kind of [AiModelKind.GENERATION, AiModelKind.DECISION]) {
+            const previous = this.preference(before, kind);
+            const selected = this.preference(after, kind);
+            if (previous === undefined && selected === undefined)
+                continue;
+            if (previous !== undefined &&
+                selected !== undefined &&
+                equals(ModelRefSchema, previous, selected))
+                continue;
+            await AgentModelSelection.authorizeSelection(ai, policy, scope, selected, this.signal, this.deadline(ai));
         }
-    },
+    }
     /**
-     * Binds Agent AI, indexed history and routed projection queries for one handler.
+     * Returns the explicit model reference for one kind, or inherited absence.
      *
-     * @param entity Loaded recipient Entity instance.
-     * @param runtime Bounded Context storage and publication services.
-     * @param tenantId Tenant selected for this accepted signal.
-     * @param accepted Durable original signal and saved handler bindings.
-     * @param reads Handler-scoped durable read facade.
-     * @param facade Handler-scoped AI facade.
-     * @returns Release callback for handler-scoped AI and read facades.
-     */
-    bindHandlerCapabilities(entity, runtime, tenantId, accepted, reads, facade) {
-        const releaseHistory = AgentHistoryReads.withJournal(entity, (scope, view, request, live, maxBytes) => reads.history(scope, view, request, live, maxBytes));
-        let releaseQuery;
-        try {
-            releaseQuery = ProcessManagerQueries.bind(entity, runtime, accepted.actor, tenantId, (schema, query, live) => reads.query(schema, query, live));
-            const releaseAi = AgentAiBindings.bind(entity, facade);
-            return () => {
-                releaseQuery?.();
-                releaseHistory();
-                releaseAi();
-            };
-        }
-        catch (error) {
-            releaseQuery?.();
-            releaseHistory();
-            throw error;
-        }
-    },
+     * @param kind Declared model or operation kind.
+     * @param values Typed values being committed.
+     * @returns The explicit model reference for the kind, or inherited absence.
+     */
+    preference(values, kind) {
+        const selected = values.find((entry) => entry.kind === kind);
+        return selected?.selection.case === "model" ? selected.selection.value : undefined;
+    }
     /**
-     * Creates one handler-scoped facade from its accepted model policy.
+     * Creates original selection System Events for changed committed preferences.
      *
-     * @param repository Registered Entity repository for this operation.
-     * @param runtime Bounded Context storage and publication services.
-     * @param tenantId Tenant selected for this accepted signal.
-     * @param session Fenced Agent execution session.
-     * @param accepted Durable original signal and saved handler bindings.
-     * @param ordinal Saved position of the selected handler.
-     * @returns AI facade bound to one selected handler.
-     */
-    handlerFacade(repository, runtime, tenantId, session, accepted, ordinal) {
-        const ai = runtime.ai;
-        const configuration = repositoryAccess.agentConfiguration(repository).ai;
-        if (ai === undefined || configuration === undefined)
-            throw new Error("Agent handler requires its bound AI registry.");
-        return new AgentAiRuntime(ai, configuration, AgentModelSelection.scope(accepted, repository.stateSchema, tenantId), session, ordinal, new AgentInteractionAudit(session, accepted, repository.stateSchema, runtime.signalMetadata, runtime.registerSystemEventSchema, runtime.publishAgentSystemEvent));
-    },
+     * @param after Proposed value after the transition.
+     * @param before Persisted value before the transition.
+     * @returns The original selection System Events for changed preferences.
+     */
+    preferenceEvents(before, after) {
+        const scope = AgentModelSelection.scopeLive(this.invocation, this.repository.stateSchema, this.runtime.signalMetadata, this.tenantId);
+        return [AiModelKind.GENERATION, AiModelKind.DECISION].flatMap((kind) => {
+            const previous = this.preference(before, kind);
+            const selected = this.preference(after, kind);
+            if (previous === undefined && selected === undefined)
+                return [];
+            if (previous !== undefined &&
+                selected !== undefined &&
+                equals(ModelRefSchema, previous, selected))
+                return [];
+            return [this.selectionEvent(scope, kind, previous, selected)];
+        });
+    }
     /**
-     * Invokes one selected generated handler and validates its declared results.
+     * Creates one original committed model-selection System Event.
      *
-     * @param entity Loaded recipient Entity instance.
-     * @param accepted Durable original signal and saved handler bindings.
-     * @param handler Generated handler selected for this signal.
-     * @returns Declared outputs returned by one generated handler.
+     * @param kind Declared model or operation kind.
+     * @param previous Persisted value before the update.
+     * @param scope Captured invocation or tenant scope.
+     * @param selected Models or selection retained for this invocation.
+     * @returns The original committed model-selection System Event.
      */
-    async invokeHandler(entity, accepted, handler) {
-        const source = accepted.signal;
-        if (source.case !== "command" && source.case !== "event")
-            throw new Error("Agent source envelope is missing.");
-        const kind = source.case;
-        const message = EntityInvocation.unpackRequired(EntityInvocation.requireSignalMessage(source.value.message, kind), handler.handler.schema, kind);
-        const context = source.case === "command"
-            ? EntityInvocation.commandHandlerContext(source.value)
-            : EntityInvocation.eventHandlerContext(source.value);
-        const produced = await EntityInvocation.invokeEntityMethod(entity, handler.handler.methodName, message, handler.handler.parameterCount, context);
-        const signals = produced === undefined
-            ? []
-            : Array.isArray(produced)
-                ? Array.from(produced)
-                : [produced];
-        RepositoryHandlers.requireDeclaredOutputs(handler.handler, signals);
-        return signals;
-    },
+    selectionEvent(scope, kind, previous, selected) {
+        const payload = create(SelectionChangedSchema, {
+            agent: scope.agent,
+            sourceSignal: scope.source,
+            kind,
+            ...(previous === undefined ? {} : { previousModel: previous }),
+            ...(selected === undefined ? {} : { selectedModel: selected }),
+            changedAt: Time.currentTime(),
+        });
+        this.runtime.registerSystemEventSchema(SelectionChangedSchema);
+        return AgentLiveInteractionEvents.envelope(this.invocation, this.runtime.signalMetadata, this.invocation.recipientId, SelectionChangedSchema, payload);
+    }
     /**
-     * Reads the original invocation deadline before starting an application callback.
+     * Wraps one committed original System Event in indexed history.
      *
-     * @param session Current fenced execution session.
-     * @returns Absolute saved deadline in milliseconds.
+     * @param event Original typed Event envelope.
+     * @returns The indexed history entry for the original System Event.
      */
-    handlerDeadline(session) {
-        const record = session.record();
-        const deadline = record.started?.deadline;
-        if (deadline === undefined && record.started?.bounds?.deadlineMillis !== undefined)
-            throw new Error("Agent handler requires its saved deadline.");
-        if (session.signal.aborted || this.deadlineExpired(record))
-            throw new Error("Agent handler deadline or claim ended.");
-        return deadline === undefined
-            ? undefined
-            : Number(deadline.seconds) * 1_000 + Math.floor(deadline.nanos / 1_000_000);
-    },
+    systemEntry(event) {
+        const occurredAt = event.context?.timestamp;
+        if (occurredAt === undefined)
+            throw new Error("Agent System Event requires Time.");
+        return create(AgentHistoryEntrySchema, {
+            occurredAt,
+            item: { case: "systemEvent", value: event },
+        });
+    }
     /**
-     * Awaits an application handler within its saved deadline and current claim.
+     * Publishes produced signals through ordinary tracked publication after commit.
      *
-     * @typeParam Value Handler result.
-     * @param work Already-started generated handler invocation.
-     * @param signal Session cancellation when claim authority ends.
-     * @param deadlineEpochMs Original saved invocation deadline.
-     * @returns Handler result only while its claim and deadline remain valid.
+     * @param outputs Declared outgoing Command or Event envelopes.
      */
-    async awaitHandler(work, signal, deadlineEpochMs) {
-        let timer;
-        let abort = () => undefined;
-        const cutoff = new Promise((_resolve, reject) => {
-            abort = () => {
-                reject(new Error("Agent handler claim ended."));
-            };
-            const tick = () => {
-                if (deadlineEpochMs === undefined)
-                    return;
-                const remaining = deadlineEpochMs - Time.currentTimeMillis();
-                if (remaining <= 0)
-                    reject(new Error("Agent handler deadline expired."));
-                else
-                    timer = setTimeout(tick, Math.min(remaining, 2_147_483_647));
-            };
-            signal.addEventListener("abort", abort, { once: true });
-            if (signal.aborted)
-                abort();
+    publish(outputs) {
+        for (const output of outputs) {
+            if (output.case === "command")
+                void this.runtime.publisher.publishCommand(output.value);
+            else if (output.value.context?.rejection !== undefined)
+                void this.runtime.publisher.publishRejectionEvent(output.value);
             else
-                tick();
-        });
-        try {
-            const result = await Promise.race([work, cutoff]);
-            if (signal.aborted ||
-                (deadlineEpochMs !== undefined && Time.currentTimeMillis() >= deadlineEpochMs))
-                throw new Error("Agent handler deadline or claim ended.");
-            return result;
-        }
-        finally {
-            clearTimeout(timer);
-            signal.removeEventListener("abort", abort);
+                void this.runtime.publisher.publishReactorEvent(output.value);
         }
-    },
-};
-/**
- * Adds a positive timeout to a Time-sampled Protobuf timestamp.
- *
- * @param at Provider-independent current time.
- * @param millis Bounded additional milliseconds.
- * @returns Absolute timestamp retaining nanosecond precision.
- */
-function addMillis(at, millis) {
-    const nanos = at.nanos + (millis % 1000) * 1_000_000;
-    return {
-        ...at,
-        seconds: at.seconds + BigInt(Math.floor(millis / 1000)) + BigInt(Math.floor(nanos / 1_000_000_000)),
-        nanos: nanos % 1_000_000_000,
-    };
+    }
 }
 /**
  * Executes one Process Manager Command against its loaded Entity state.
@@ -3604,12 +3075,11 @@ class ProcessManagerCommandExecution {
             const produced = await EntityInvocation.invokeEntityMethod(entity, assignee.handler.methodName, message, assignee.handler.parameterCount, EntityInvocation.commandHandlerContext(this.#command));
             const signals = this.#support.normalizeProducedSignals(produced);
             if (signals.length === 0)
-                throw new Error("Repository command handlers must return a signal.");
+                throw receptionObservation.recordPostHandlerFailure(new Error("Repository command handlers must return a signal."));
             RepositoryHandlers.requireDeclaredOutputs(assignee.handler, signals);
             const commit = await commitFenced(entity, (current) => transactionalEntityAccess.commit(current, assignee.handler.kind === "command-assignment" && signals.length > 0));
-            if (commit.status === "rejected") {
-                throw new TransitionValidationError(commit.validation.error);
-            }
+            if (commit.status === "rejected")
+                throw EntityInvocation.rejectedTransition(commit.validation.error);
             return signals;
         }
         catch (error) {
@@ -3647,7 +3117,7 @@ class ProcessManagerCommandExecution {
         });
         return create(EventSchema, {
             id: metadata.id,
-            message: AnyMessages.pack(schema, signal),
+            message: RepositorySignals.packProduced(schema, signal),
             context: RepositorySignals.eventContextWithProducer(metadata.context, this.#repository, entityId, version),
         });
     }
@@ -3667,7 +3137,7 @@ class ProcessManagerCommandExecution {
             const metadata = this.#runtime.signalMetadata.commandFromCommand(this.#command);
             return create(CommandSchema, {
                 id: metadata.id,
-                message: AnyMessages.pack(schema, signal),
+                message: RepositorySignals.packProduced(schema, signal),
                 context: metadata.context,
             });
         }));
@@ -3781,7 +3251,7 @@ class ProcessManagerEventExecution {
      *
      * @param entityId Target Entity identifier.
      * @param intake Decoded Event and matching handlers.
-     * @returns Completion after accepted results are published.
+     * @returns Completion after accepted results are registered for publication.
      */
     async #executeEntity(entityId, intake) {
         const tenantOptions = RepositoryTenants.standTenantOptions(this.#runtime.context, this.#event);
@@ -3798,7 +3268,7 @@ class ProcessManagerEventExecution {
             return;
         this.#publishChangedState(loaded, entityId);
         this.#postEvents(events);
-        await this.#postCommands(commands);
+        this.#postCommands(commands);
     }
     /**
      * Publishes a state-change System Event when the Entity changed.
@@ -3844,17 +3314,18 @@ class ProcessManagerEventExecution {
         const commands = [];
         const events = [];
         const releaseQuery = ProcessManagerQueries.bind(entity, this.#runtime, this.#runtime.signalMetadata.originFromEvent(this.#event).actorContext, tenantId);
-        transactionalEntityAccess.start(entity);
+        let started = false;
         try {
+            transactionalEntityAccess.start(entity);
+            started = true;
             await this.#invokeEventHandlers(entityId, entity, intake, eventContext, events, commands);
             await this.#commitEntity(entity, events.length > 0);
-            return Object.freeze({
-                commands: Object.freeze(commands),
-                events: Object.freeze(events),
-            });
+            const emitted = { commands: Object.freeze(commands), events: Object.freeze(events) };
+            return Object.freeze(emitted);
         }
         catch (error) {
-            transactionalEntityAccess.rollback(entity);
+            if (started)
+                transactionalEntityAccess.rollback(entity);
             throw error;
         }
         finally {
@@ -3914,7 +3385,7 @@ class ProcessManagerEventExecution {
     async #commitEntity(entity, producedEvents) {
         const commit = await commitFenced(entity, (current) => transactionalEntityAccess.commit(current, producedEvents));
         if (commit.status === "rejected")
-            throw new TransitionValidationError(commit.validation.error);
+            throw EntityInvocation.rejectedTransition(commit.validation.error);
     }
     /**
      * Binds reactor results as Entity Events.
@@ -3946,7 +3417,7 @@ class ProcessManagerEventExecution {
         });
         return create(EventSchema, {
             id: metadata.id,
-            message: AnyMessages.pack(schema, signal),
+            message: RepositorySignals.packProduced(schema, signal),
             context: RepositorySignals.eventContextWithProducer(metadata.context, this.#repository, entityId, version),
         });
     }
@@ -3966,7 +3437,7 @@ class ProcessManagerEventExecution {
             const metadata = this.#runtime.signalMetadata.commandFromEvent(this.#event);
             return create(CommandSchema, {
                 id: metadata.id,
-                message: AnyMessages.pack(schema, signal),
+                message: RepositorySignals.packProduced(schema, signal),
                 context: metadata.context,
             });
         }));
@@ -3975,11 +3446,11 @@ class ProcessManagerEventExecution {
      * Publishes each produced Command in handler order.
      *
      * @param commands Bound Commands to publish.
-     * @returns Completion after all Commands are published.
      */
-    async #postCommands(commands) {
+    #postCommands(commands) {
         for (const command of commands) {
-            await this.#runtime.publisher.publishCommand(command);
+            // spine-log-boundary: server.process_manager_command_follow_up
+            void this.#runtime.publisher.publishCommand(command);
         }
     }
     /**
@@ -4284,6 +3755,15 @@ Object.freeze(RepositoryIdentity);
  * Internal entity invocation operations.
  */
 const EntityInvocation = {
+    /**
+     * Returns a rejected Entity transition as an exact reception failure.
+     *
+     * @param validationError The rejected transition detail.
+     * @returns The original transition error for propagation.
+     */
+    rejectedTransition(validationError) {
+        return receptionObservation.recordPostHandlerFailure(new TransitionValidationError(validationError));
+    },
     /**
      * Reads a generated message's type name or rejects malformed output.
      *
@@ -4361,7 +3841,7 @@ const EntityInvocation = {
      * @returns Decoded generated message.
      */
     unpackRequired(message, schema, signalKind) {
-        const unpacked = AnyMessages.unpack(message, schema);
+        const unpacked = AnyPacker.tryUnpack(message, schema);
         if (unpacked === undefined) {
             throw new Error(`Repository ${signalKind} execution requires a readable message.`);
         }
@@ -4399,9 +3879,9 @@ const RepositoryEntities = {
     bindStorage(repository, runtime, tenantId, entityId, entity) {
         const storageInput = RepositoryStorage.entityStorageInput(repository, RepositoryTenants.storageContextForTenant(runtime.context, tenantId));
         const storage = RepositoryStorage.openRepositoryEntityStorage(repository, runtime.storageFactory, storageInput);
-        RepositoryHistoryInternals.bindEntityHistory(entity, storage, entityId, repository.stateSchema);
+        RepositoryHistoryInternals.bindEntityHistory(repository, entity, storage, entityId, repository.stateSchema, storageInput.context.tenantId);
         if (repository.entityFamily === "agent")
-            this.bindAgentHistory(entity, entityId, storageInput, storage.agentHistory);
+            this.bindAgentHistory(repository, entity, entityId, storageInput, storage.agentHistory);
         return {
             commits: storage.commits,
             events: storage.events,
@@ -4412,24 +3892,61 @@ const RepositoryEntities = {
     /**
      * Attaches the indexed history port to one restored Agent.
      *
+     * @param repository Repository tracking the captured runtime.
      * @param entity Restored Agent instance.
      * @param entityId Typed Agent identifier.
      * @param input Entity storage scope.
      * @param history Mandatory Agent history port.
      */
-    bindAgentHistory(entity, entityId, input, history) {
+    bindAgentHistory(repository, entity, entityId, input, history) {
         if (history === undefined)
             throw new Error("Agent history storage is required.");
-        AgentHistoryReads.bind(entity, {
+        const lifetime = RepositoryStorage.lifetime(repository);
+        const runtime = repositoryRuntimes.get(repository);
+        if (runtime === undefined)
+            throw new Error("Agent history requires its active runtime.");
+        AgentHistoryReads.bind(entity, this.agentHistoryBinding(repository, entity, entityId, input, history, runtime, lifetime));
+    },
+    /**
+     * Captures retained Agent history admission and outward filtering in one binding.
+     *
+     * @param repository Repository tracking the active runtime.
+     * @param entity Restored Agent instance.
+     * @param entityId Typed Agent identifier.
+     * @param input Retained storage scope.
+     * @param history Indexed Agent history handle.
+     * @param runtime Current context services.
+     * @param lifetime Repository storage lifetime.
+     * @returns History binding with an invocation-time actor snapshot.
+     */
+    agentHistoryBinding(repository, entity, entityId, input, history, runtime, lifetime) {
+        return {
             storage: history,
             entityId,
-            scope: {
-                context: input.context.name,
-                tenant: JSON.stringify(input.context.tenantId ?? null),
-                repository: input.sourceType.typeName,
-                entity: input.id.key(entityId),
+            onAdmit: async (onRead) => {
+                if (repositoryRuntimes.get(repository) !== runtime)
+                    throw new Error("Agent history requires its active runtime.");
+                await runtime.onAdmit(input.context.tenantId);
+                return RepositoryStorage.track(repository, onRead, lifetime);
             },
-        });
+            captureActor: () => entityHistoryAccess.currentActor(entity),
+            filterPage: (page, view, request, actorContext) => RepositoryAgentReads.visibleHistory(runtime.stand, page, entityId, view, request, input.context.tenantId, actorContext === undefined ? {} : { actorContext }),
+            scope: this.agentHistoryScope(input, entityId),
+        };
+    },
+    /**
+     * Returns the exact retained Agent repository and typed ID for cursor validation.
+     * @param input Captured Agent storage scope.
+     * @param entityId Typed Agent identifier.
+     * @returns Stable scope encoded in history cursors.
+     */
+    agentHistoryScope(input, entityId) {
+        return {
+            context: input.context.name,
+            tenant: JSON.stringify(input.context.tenantId ?? null),
+            repository: input.sourceType.typeName,
+            entity: input.id.key(entityId),
+        };
     },
     /**
      * Restores an Entity from Stand or creates a fresh instance at Version zero.
@@ -4535,6 +4052,34 @@ Object.freeze(RepositoryEntities);
  * Internal repository signals operations.
  */
 const RepositorySignals = {
+    /**
+     * Packs one handler-produced signal and records only its validation failure.
+     *
+     * @typeParam Schema Generated schema for the signal.
+     * @param schema Generated schema for the signal.
+     * @param message Handler-produced message.
+     * @returns Validated packed signal.
+     */
+    packProduced(schema, message) {
+        try {
+            return RepositorySignals.packValidated(schema, message);
+        }
+        catch (error) {
+            throw receptionObservation.recordPostHandlerFailure(error);
+        }
+    },
+    /**
+     * Packs a repository-produced value after checking its domain constraints.
+     *
+     * @typeParam Schema Generated schema for the value.
+     * @param schema Generated schema for the value.
+     * @param message Repository-produced message to pack.
+     * @returns Validated packed message.
+     */
+    packValidated(schema, message) {
+        Validate.check(schema, message);
+        return AnyPacker.pack(schema, message);
+    },
     /**
      * Validates that a rejection type was declared by the invoked handler.
      *
@@ -4622,7 +4167,7 @@ const RepositorySignals = {
         const metadata = runtime.signalMetadata.eventFromCommand(command, {});
         return create(EventSchema, {
             id: metadata.id,
-            message: AnyMessages.pack(rejection.schema, rejection.messageThrown()),
+            message: RepositorySignals.packValidated(rejection.schema, rejection.messageThrown()),
             context: create(EventContextSchema, {
                 ...RepositorySignals.eventContextWithProducer(metadata.context, repository, entityId),
                 rejection: create(RejectionEventContextSchema, {
@@ -4686,7 +4231,7 @@ class EntityStateChangePublishing {
         this.#publish(runtime, () => runtime.signalMetadata.eventFromCommand(command, {
             version,
         }), {
-            id: AnyMessages.pack(CommandIdSchema, command.id),
+            id: RepositorySignals.packValidated(CommandIdSchema, command.id),
             typeUrl: command.message?.typeUrl ?? "",
         }, { repository, entityId, oldState, oldLifecycle, newState, lifecycle, version });
     }
@@ -4707,7 +4252,7 @@ class EntityStateChangePublishing {
         this.#publish(runtime, () => runtime.signalMetadata.eventFromEvent(source, {
             version,
         }), {
-            id: AnyMessages.pack(EventIdSchema, source.id),
+            id: RepositorySignals.packValidated(EventIdSchema, source.id),
             typeUrl: source.message?.typeUrl ?? "",
         }, { repository, entityId, oldState, oldLifecycle, newState, lifecycle, version });
     }
@@ -4726,7 +4271,7 @@ class EntityStateChangePublishing {
             runtime.registerSystemEventSchema(draft.schema);
             const event = create(EventSchema, {
                 id: metadata.id,
-                message: AnyMessages.pack(draft.schema, draft.messageAt(metadata.context.timestamp)),
+                message: RepositorySignals.packValidated(draft.schema, draft.messageAt(metadata.context.timestamp)),
                 context: RepositorySignals.eventContextWithProducer(metadata.context, change.repository, change.entityId),
             });
             this.#post(runtime, event);
@@ -4760,7 +4305,7 @@ class EntityStateChangePublishing {
         return {
             entity,
             signalId: [create(MessageIdSchema, { id: origin.id, typeUrl: origin.typeUrl })],
-            state: AnyMessages.pack(change.repository.stateSchema, change.newState),
+            state: RepositorySignals.packValidated(change.repository.stateSchema, change.newState),
             version: create(VersionSchema, { number: change.version }),
         };
     }
@@ -4803,7 +4348,7 @@ class EntityStateChangePublishing {
                 ...(change.oldState === undefined
                     ? {}
                     : {
-                        oldState: AnyMessages.pack(change.repository.stateSchema, change.oldState),
+                        oldState: RepositorySignals.packValidated(change.repository.stateSchema, change.oldState),
                     }),
                 newState: fields.state,
                 signalId: fields.signalId,
@@ -4968,7 +4513,7 @@ class HandlerDispatchPublishing {
         });
         return create(EventSchema, {
             id: runtime.signalMetadata.eventId(),
-            message: AnyMessages.pack(EntityLog.CommandDispatchedToHandlerSchema, this.#message(repository, command, entityId, context.timestamp)),
+            message: RepositorySignals.packValidated(EntityLog.CommandDispatchedToHandlerSchema, this.#message(repository, command, entityId, context.timestamp)),
             context,
         });
     }
@@ -5018,7 +4563,7 @@ class HandlerDispatchPublishing {
         });
         return create(EventSchema, {
             id: runtime.signalMetadata.eventId(),
-            message: AnyMessages.pack(EntityLog.EventDispatchedToReactorSchema, this.#eventMessage(EntityLog.EventDispatchedToReactorSchema, repository, source, entityId, context.timestamp)),
+            message: RepositorySignals.packValidated(EntityLog.EventDispatchedToReactorSchema, this.#eventMessage(EntityLog.EventDispatchedToReactorSchema, repository, source, entityId, context.timestamp)),
             context,
         });
     }
@@ -5047,7 +4592,7 @@ class HandlerDispatchPublishing {
             });
             const diagnostic = create(EventSchema, {
                 id: runtime.signalMetadata.eventId(),
-                message: AnyMessages.pack(schema, this.#eventMessage(schema, repository, event, entityId, context.timestamp)),
+                message: RepositorySignals.packValidated(schema, this.#eventMessage(schema, repository, event, entityId, context.timestamp)),
                 context,
             });
             this.#post(runtime, schema, diagnostic);
@@ -5136,6 +4681,7 @@ const HandlerDispatchPublisher = Object.freeze(new HandlerDispatchPublishing());
 Object.freeze(RepositorySignals);
 /**
  * Internal repository stand operations.
+ *
  * @internal
  */
 export const RepositoryStand = {
@@ -5168,60 +4714,12 @@ export const RepositoryStand = {
             lifecycle,
         });
     },
-    /**
-     * Maps one Event position to its Process Manager producer version.
-     *
-     * @param sequence One-based position among produced Events.
-     * @returns Producer sequence number for Event metadata.
-     */
 };
 Object.freeze(RepositoryStand);
 /**
  * Internal repository tenants operations.
  */
 const RepositoryTenants = {
-    /**
-     * Builds tenant-aware storage context for Entity inbox delivery.
-     *
-     * @param context Bounded context storage mode.
-     * @param tenantId Delivery tenant when multitenant.
-     * @returns Storage context for durable Entity inbox rows.
-     */
-    entityInboxDeliveryContext(context, tenantId) {
-        if (!context.multitenant) {
-            return Object.freeze({ name: context.name, multitenant: false });
-        }
-        const tid = tenantId;
-        if (tid === undefined) {
-            throw new Error(`Multitenant Entity Inbox handoff for "${context.name}" requires tenantId.`);
-        }
-        return Object.freeze({
-            name: context.name,
-            multitenant: true,
-            tenantId: RepositoryTenants.require(tid),
-        });
-    },
-    /**
-     * Builds tenant-aware storage context for Projection inbox delivery.
-     *
-     * @param context Bounded context storage mode.
-     * @param tenantId Delivery tenant when multitenant.
-     * @returns Storage context for durable Projection inbox rows.
-     */
-    projectionDeliveryContext(context, tenantId) {
-        if (!context.multitenant) {
-            return Object.freeze({ name: context.name, multitenant: false });
-        }
-        const tid = tenantId;
-        if (tid === undefined) {
-            throw new Error(`Multitenant projection inbox handoff for "${context.name}" requires tenantId.`);
-        }
-        return Object.freeze({
-            name: context.name,
-            multitenant: true,
-            tenantId: RepositoryTenants.require(tid),
-        });
-    },
     /**
      * Validates an Event tenant before Projection inbox handoff.
      *
@@ -5428,9 +4926,15 @@ const RepositoryHandlers = {
     requireDeclaredOutputs(handler, signals) {
         const schemas = HandlerMetadataValues.returnedSchemas(handler);
         for (const signal of signals) {
-            const typeName = EntityInvocation.messageTypeName(signal);
+            let typeName;
+            try {
+                typeName = EntityInvocation.messageTypeName(signal);
+            }
+            catch (error) {
+                throw receptionObservation.recordPostHandlerFailure(error);
+            }
             if (!schemas.some((schema) => schema.typeName === typeName)) {
-                throw new Error(`Handler "${handler.methodName}" returned undeclared message "${typeName}".`);
+                throw receptionObservation.recordPostHandlerFailure(new Error(`Handler "${handler.methodName}" returned undeclared message "${typeName}".`));
             }
         }
     },
@@ -5971,7 +5475,7 @@ const RepositoryRoutes = {
      * @returns Candidate target Entity ID.
      */
     async callCommandRoute(route, message, schema, context, reads) {
-        const unpacked = AnyMessages.unpack(message, schema);
+        const unpacked = AnyPacker.tryUnpack(message, schema);
         if (unpacked === undefined) {
             throw new Error("Repository command routing requires a readable Command message.");
         }
@@ -6135,7 +5639,7 @@ const RepositoryRoutes = {
         if (message?.typeUrl !== TypeUrls.derive(EntityLog.EntityStateChangedSchema)) {
             throw new Error(`${operation} requires an EntityStateChanged System event.`);
         }
-        const changed = AnyMessages.unpack(message, EntityLog.EntityStateChangedSchema);
+        const changed = AnyPacker.tryUnpack(message, EntityLog.EntityStateChangedSchema);
         const packedState = changed?.newState;
         if (packedState === undefined || packedState.typeUrl === "") {
             throw new Error(`${operation} requires EntityStateChanged.newState.`);
@@ -6143,7 +5647,7 @@ const RepositoryRoutes = {
         const schema = schemas.find((candidate) => TypeUrls.derive(candidate) === packedState.typeUrl);
         if (schema === undefined)
             return undefined;
-        const state = AnyMessages.unpack(packedState, schema);
+        const state = AnyPacker.tryUnpack(packedState, schema);
         if (state === undefined)
             throw new Error(`${operation} requires a readable Entity state.`);
         return Object.freeze({ schema, state });
@@ -6186,7 +5690,7 @@ const RepositoryRoutes = {
      * @returns Validated target Entity IDs.
      */
     async callEventRoute(route, message, schema, context, targetIdField, reads) {
-        const unpacked = AnyMessages.unpack(message, schema);
+        const unpacked = AnyPacker.tryUnpack(message, schema);
         if (unpacked === undefined) {
             throw new Error("Repository event routing requires a readable Event message.");
         }
@@ -6240,7 +5744,7 @@ const RepositoryRoutes = {
      * @returns Nonempty first-field value.
      */
     readFirstFieldId(message, schema, signalKind) {
-        const unpacked = AnyMessages.unpack(message, schema);
+        const unpacked = AnyPacker.tryUnpack(message, schema);
         const firstField = schema.fields[0];
         if (unpacked === undefined || firstField === undefined) {
             throw new Error(`Repository ${signalKind} routing requires a readable first field.`);
@@ -6479,12 +5983,235 @@ const RepositoryRoutes = {
                 return undefined;
         }
     },
-};
-Object.freeze(RepositoryRoutes);
-/**
- * Internal repository storage operations.
- */
-const RepositoryStorage = {
+};
+Object.freeze(RepositoryRoutes);
+/**
+ * Internal repository storage operations.
+ */
+const RepositoryStorage = {
+    /**
+     * Returns one retained EventStore for unchanged Process Manager output.
+     *
+     * @param repository Registered Process Manager repository.
+     * @param runtime Its captured runtime services.
+     * @returns Tenant-aware EventStore for produced Events.
+     */
+    eventStore(repository, runtime) {
+        const lifetime = this.lifetime(repository);
+        lifetime.eventStore ??= new EventStore(runtime.context, runtime.storageFactory);
+        return lifetime.eventStore;
+    },
+    /**
+     * Creates one repository runtime's retained storage registry.
+     *
+     * @returns Empty registry accepting storage work.
+     */
+    newLifetime() {
+        return {
+            entities: new Map(),
+            histories: new Map(),
+            ports: new Set(),
+            commits: new Set(),
+            active: new Set(),
+            open: true,
+        };
+    },
+    /**
+     * Returns the active storage registry for one registered repository.
+     *
+     * @param repository Registered repository.
+     * @returns Its current retained-storage registry.
+     */
+    lifetime(repository) {
+        const lifetime = repositoryStorageLifetimes.get(repository);
+        if (lifetime?.open !== true)
+            throw new Error("Repository storage requires an active runtime.");
+        return lifetime;
+    },
+    /**
+     * Admits one complete physical storage operation before runtime closure.
+     *
+     * @typeParam T Result of the operation.
+     * @param repository Registered repository.
+     * @param work Work that acquires and uses retained storage.
+     * @param expected Captured lifetime for a bound history reader, if any.
+     * @returns The operation result or its original failure.
+     */
+    async track(repository, work, expected) {
+        const lifetime = this.lifetime(repository);
+        if (expected !== undefined && lifetime !== expected)
+            throw new Error("Repository history requires its active runtime.");
+        const result = work();
+        lifetime.active.add(result);
+        return result.finally(() => {
+            lifetime.active.delete(result);
+        });
+    },
+    /**
+     * Starts repository shutdown after new admissions are fenced.
+     *
+     * @param repository Repository being detached.
+     * @returns Completion after admitted operations and every close attempt.
+     */
+    closeRuntime(repository) {
+        const lifetime = repositoryStorageLifetimes.get(repository);
+        if (lifetime === undefined)
+            return Promise.resolve();
+        if (lifetime.closing !== undefined)
+            return lifetime.closing;
+        if (lifetime.idleOutcome !== undefined) {
+            const error = lifetime.idleOutcome.error;
+            return error === undefined ? Promise.resolve() : Promise.reject(error);
+        }
+        lifetime.open = false;
+        lifetime.closing = this.drainLifetime(lifetime);
+        return lifetime.closing;
+    },
+    /**
+     * Rejects synchronous rollback while repository storage work remains active.
+     *
+     * @param repository Repository being rolled back.
+     */
+    assertIdle(repository) {
+        const lifetime = repositoryStorageLifetimes.get(repository);
+        if (lifetime !== undefined && (lifetime.active.size > 0 || lifetime.closing !== undefined))
+            throw new Error("Repository idle cleanup requires no active storage work.");
+    },
+    /**
+     * Closes retained resources synchronously during idle assembly rollback.
+     *
+     * @param repository Repository being rolled back.
+     */
+    closeRuntimeIdle(repository) {
+        const lifetime = repositoryStorageLifetimes.get(repository);
+        if (lifetime === undefined)
+            return;
+        if (lifetime.idleOutcome !== undefined) {
+            if (lifetime.idleOutcome.error !== undefined)
+                throw lifetime.idleOutcome.error;
+            return;
+        }
+        lifetime.open = false;
+        const errors = [];
+        if (lifetime.eventStore !== undefined) {
+            try {
+                eventStoreAccess.closeIdle(lifetime.eventStore);
+            }
+            catch (error) {
+                errors.push(error);
+            }
+        }
+        errors.push(...this.closeLifetimePortsIdle(lifetime));
+        const failure = this.closeFailure(errors);
+        lifetime.idleOutcome = failure === undefined ? {} : { error: failure };
+        if (failure !== undefined)
+            throw failure;
+    },
+    /**
+     * Waits for admitted storage operations, closes the retained EventStore, and releases all ports.
+     *
+     * @param lifetime Repository storage registry being closed.
+     * @returns Completion after every close attempt.
+     */
+    async drainLifetime(lifetime) {
+        await Promise.allSettled([...lifetime.active]);
+        const errors = [];
+        if (lifetime.eventStore !== undefined) {
+            try {
+                await lifetime.eventStore.close();
+            }
+            catch (error) {
+                errors.push(error);
+            }
+        }
+        errors.push(...(await this.closeLifetimePorts(lifetime)));
+        const failure = this.closeFailure(errors);
+        if (failure !== undefined)
+            throw failure;
+    },
+    /**
+     * Closes each retained physical port once.
+     *
+     * @param lifetime Repository storage registry being closed.
+     * @returns Every close failure in attempt order.
+     */
+    async closeLifetimePorts(lifetime) {
+        const commits = [...lifetime.commits];
+        lifetime.commits.clear();
+        const ports = [...lifetime.ports];
+        lifetime.ports.clear();
+        const errors = [];
+        const closing = commits.map((commit) => {
+            try {
+                return commit.close();
+            }
+            catch (error) {
+                errors.push(error);
+                return Promise.resolve();
+            }
+        });
+        for (const result of await Promise.allSettled(closing))
+            if (result.status === "rejected")
+                errors.push(result.reason);
+        for (const port of ports) {
+            try {
+                port.close();
+            }
+            catch (error) {
+                errors.push(error);
+            }
+        }
+        lifetime.entities.clear();
+        lifetime.histories.clear();
+        delete lifetime.eventStore;
+        return errors;
+    },
+    /**
+     * Closes ports synchronously during assembly rollback.
+     *
+     * @param lifetime The captured repository storage lifetime.
+     * @returns Synchronous cleanup failures, if any.
+     */
+    closeLifetimePortsIdle(lifetime) {
+        const commits = [...lifetime.commits];
+        lifetime.commits.clear();
+        const ports = [...lifetime.ports];
+        lifetime.ports.clear();
+        lifetime.entities.clear();
+        lifetime.histories.clear();
+        delete lifetime.eventStore;
+        const errors = [];
+        for (const commit of commits) {
+            try {
+                commit.closeIdle();
+            }
+            catch (error) {
+                errors.push(error);
+            }
+        }
+        for (const port of ports) {
+            try {
+                port.close();
+            }
+            catch (error) {
+                errors.push(error);
+            }
+        }
+        return errors;
+    },
+    /**
+     * Returns one close failure or aggregates multiple failures.
+     *
+     * @param errors Physical port cleanup failures.
+     * @returns The reported cleanup failure, if any.
+     */
+    closeFailure(errors) {
+        if (errors.length === 0)
+            return undefined;
+        if (errors.length === 1)
+            return errors[0];
+        return new AggregateError(errors, "Repository storage close failed.");
+    },
     /**
      * Opens provider Entity storage for one read scope without a commit handle.
      *
@@ -6501,72 +6228,120 @@ const RepositoryStorage = {
         return candidate.createEntityStorage(input);
     },
     /**
-     * Opens Entity storage and an atomic commit port from a storage factory.
+     * Returns the canonical tenant/model/history bucket for Entity storage.
      *
-     * @typeParam I Entity identifier type.
-     * @typeParam S Generated Entity state type.
-     * @param factory Provider storage factory.
-     * @param input Entity storage location and schema.
-     * @param agent Whether to open mandatory Agent history.
-     * @returns Storage ports closed together by one handle.
+     * @typeParam I Typed Entity identifier.
+     * @typeParam S Generated Entity state.
+     * @param lifetime Active repository storage registry.
+     * @param input Captured Entity storage configuration.
+     * @returns Slots for one model and history configuration.
      */
-    openEntityStorage(factory, input, agent = false) {
-        const candidate = factory;
-        if (candidate.createEntityStorage === undefined)
-            throw new Error("StorageFactory does not provide required atomic Entity commit storage.");
-        const entity = candidate.createEntityStorage(input);
-        const commits = EntityCommitStorageFactories.create(factory, input);
-        let ports;
-        try {
-            if (agent)
-                ports = this.openAgentPorts(factory, input);
-        }
-        catch (error) {
-            commits.close();
-            entity.close();
-            throw error;
+    entityBucket(lifetime, input) {
+        const key = JSON.stringify({
+            context: input.context.name,
+            state: input.sourceType.typeName,
+            history: input.stateHistory,
+        });
+        let bucket = lifetime.entities.get(key);
+        if (bucket === undefined) {
+            bucket = new Map();
+            lifetime.entities.set(key, bucket);
         }
-        return {
-            ...entity,
-            commits,
-            ...ports,
-            close: () => {
-                ports?.agentExecution.close();
-                ports?.agentHistory.close();
-                commits.close();
-                entity.close();
-            },
-        };
+        return bucket;
     },
     /**
-     * Opens both mandatory Agent ports and closes the first if the second fails.
+     * Returns the canonical tenant/model bucket for Agent audit history.
      *
      * @typeParam I Typed Agent identifier.
-     * @typeParam S Generated Agent state message.
-     * @param factory Storage factory registered with the Bounded Context.
-     * @param input Original Inbox or storage input.
-     * @returns Indexed history and execution handles for the same tenant.
+     * @typeParam S Generated Agent state.
+     * @param lifetime Active repository storage registry.
+     * @param input Captured Agent storage configuration.
+     * @returns Audit ports independent of the state-history switch.
+     */
+    historyBucket(lifetime, input) {
+        const key = JSON.stringify({ context: input.context.name, state: input.sourceType.typeName });
+        let bucket = lifetime.histories.get(key);
+        if (bucket === undefined) {
+            bucket = new Map();
+            lifetime.histories.set(key, bucket);
+        }
+        return bucket;
+    },
+    /**
+     * Returns retained read-only Entity storage without acquiring a commit port.
+     *
+     * @typeParam I Typed Entity identifier.
+     * @typeParam S Generated Entity state.
+     * @param repository Registered repository.
+     * @param factory Repository storage factory.
+     * @param input Captured Entity storage configuration.
+     * @returns Reusable current, state-history, and event-history ports.
      */
-    openAgentPorts(factory, input) {
-        const agentHistory = AgentHistoryStorageFactories.create(factory, {
+    repositoryReadEntityStorage(repository, factory, input) {
+        const lifetime = this.lifetime(repository);
+        const bucket = this.entityBucket(lifetime, input);
+        const key = TenantBoundary.of(input.context).key;
+        const existing = bucket.get(key);
+        if (existing !== undefined)
+            return existing.entity;
+        const entity = this.openReadEntityStorage(factory, input);
+        bucket.set(key, { entity });
+        lifetime.ports.add(entity);
+        return entity;
+    },
+    /**
+     * Returns shared Agent audit history for one tenant and model.
+     *
+     * @typeParam I Typed Agent identifier.
+     * @typeParam S Generated Agent state.
+     * @param repository Registered Agent repository.
+     * @param factory Repository storage factory.
+     * @param input Captured Entity storage configuration.
+     * @returns Reusable Agent audit-history port.
+     */
+    openRepositoryAgentHistory(repository, factory, input) {
+        const lifetime = this.lifetime(repository);
+        const bucket = this.historyBucket(lifetime, input);
+        const key = TenantBoundary.of(input.context).key;
+        const existing = bucket.get(key);
+        if (existing !== undefined)
+            return existing;
+        const history = AgentHistoryStorageFactories.create(factory, {
             context: input.context,
             stateType: input.sourceType.typeName,
             id: { key: input.id.key },
         });
-        try {
-            const agentExecution = AgentExecutionStorageFactories.create(factory, {
-                entity: input,
-                stateType: input.sourceType.typeName,
-            });
-            return { agentHistory, agentExecution };
-        }
-        catch (error) {
-            agentHistory.close();
-            throw error;
+        bucket.set(key, history);
+        lifetime.ports.add(history);
+        return history;
+    },
+    /**
+     * Closes every acquired port, retaining the first failure and any later failures.
+     *
+     * @param ports Acquired ports in close order.
+     * @param acquisitionError Earlier acquisition failure, if any.
+     */
+    closePorts(ports, acquisitionError) {
+        const errors = acquisitionError === undefined ? [] : [acquisitionError];
+        for (const port of ports) {
+            try {
+                if ("closeIdle" in port)
+                    port.closeIdle();
+                else
+                    port.close();
+            }
+            catch (error) {
+                errors.push(error);
+            }
         }
+        if (errors.length === 1)
+            throw errors[0];
+        if (errors.length > 1)
+            throw new AggregateError(errors, "Entity storage cleanup failed.");
     },
     /**
-     * Returns one shared Entity storage handle per context and state type.
+     * Returns one retained Entity storage handle per context, tenant, state type,
+     * and captured state-history configuration.
      *
      * @typeParam I Entity identifier type.
      * @typeParam S Generated Entity state type.
@@ -6576,20 +6351,72 @@ const RepositoryStorage = {
      * @returns Shared Entity storage handle.
      */
     openRepositoryEntityStorage(repository, factory, input) {
-        const key = JSON.stringify({ context: input.context, state: input.sourceType.typeName });
-        let handles = repositoryEntityHandles.get(repository);
-        const handle = RepositoryStorage.openEntityStorage(factory, input, repository.entityFamily === "agent");
-        if (handles === undefined) {
-            handles = new Map();
-            repositoryEntityHandles.set(repository, handles);
-        }
-        const existing = handles.get(key);
-        if (existing !== undefined) {
-            handle.close();
-            return existing;
+        const lifetime = this.lifetime(repository);
+        const bucket = this.entityBucket(lifetime, input);
+        const key = TenantBoundary.of(input.context).key;
+        const existing = bucket.get(key);
+        if (existing?.full !== undefined)
+            return existing.full;
+        return this.upgradeRepositoryEntityStorage(repository, factory, input, lifetime, bucket, key, existing);
+    },
+    /**
+     * Adds commit and Agent ports to a retained or newly acquired Entity port.
+     *
+     * @typeParam I Typed Entity identifier.
+     * @typeParam S Generated Entity state.
+     * @param repository Registered repository.
+     * @param factory Repository storage factory.
+     * @param input Captured Entity storage configuration.
+     * @param lifetime Active repository registry.
+     * @param bucket Entity slots for this model and history configuration.
+     * @param key Canonical tenant key.
+     * @param existing Read-only slot if one was opened earlier.
+     * @returns Complete retained write storage.
+     */
+    upgradeRepositoryEntityStorage(repository, factory, input, lifetime, bucket, key, existing) {
+        const entity = existing?.entity ?? this.openReadEntityStorage(factory, input);
+        let commits;
+        try {
+            const commit = EntityCommitStorageFactories.create(factory, input);
+            commits = commit;
+            const agentHistory = repository.entityFamily === "agent"
+                ? this.openRepositoryAgentHistory(repository, factory, input)
+                : undefined;
+            const full = {
+                ...entity,
+                commits: commit,
+                ...(agentHistory === undefined ? {} : { agentHistory }),
+            };
+            this.retainUpgradedSlot(lifetime, bucket, key, existing, full, entity, commit);
+            return full;
+        }
+        catch (error) {
+            const rollback = commits === undefined ? [] : [commits];
+            if (existing === undefined)
+                rollback.push(entity);
+            this.closePorts(rollback, error);
+            throw error;
         }
-        handles.set(key, handle);
-        return handle;
+    },
+    /**
+     * Records a completed Entity storage upgrade in the current lifetime.
+     *
+     * @typeParam I Typed Entity identifier.
+     * @typeParam S Generated Entity state.
+     * @param lifetime Active repository registry.
+     * @param bucket Entity slots for one model and history configuration.
+     * @param key Canonical tenant key.
+     * @param existing Previously retained read-only slot, if any.
+     * @param full Completed Entity storage.
+     * @param entity Shared Entity read port.
+     * @param commit Newly acquired commit port.
+     */
+    retainUpgradedSlot(lifetime, bucket, key, existing, full, entity, commit) {
+        const slot = existing ?? { entity };
+        slot.full = full;
+        bucket.set(key, slot);
+        lifetime.ports.add(entity);
+        lifetime.commits.add(commit);
     },
     /**
      * Builds Entity storage input with configured state and Event history flags.
@@ -6599,12 +6426,15 @@ const RepositoryStorage = {
      * @returns Entity storage description for the provider.
      */
     entityStorageInput(repository, context) {
-        const descriptor = entityStorageDescriptor(context, repositorySpecScanner.scan(repository.entityType, repository.metadata), repository.metadata);
+        const snapshot = repositorySnapshots.get(repository);
+        if (snapshot === undefined)
+            throw new TypeError("Entity storage requires a Repository instance.");
+        const descriptor = entityStorageDescriptor(context, repositorySpecScanner.scan(snapshot.entityType, snapshot.metadata), snapshot.metadata);
         const history = RepositoryStorage.historyConfiguration(repository);
         return {
             ...descriptor,
             stateHistory: history.stateHistory,
-            eventHistory: repository.entityFamily === "aggregate" || history.processManagerEventHistory,
+            eventHistory: snapshot.entityFamily === "aggregate" || history.processManagerEventHistory,
         };
     },
     /**
@@ -6653,29 +6483,242 @@ const RepositoryStorage = {
 };
 Object.freeze(RepositoryStorage);
 /**
- * Internal repository history internals operations.
+ * Provides internal repository history operations.
  */
 const RepositoryHistoryInternals = {
     /**
      * Binds state and Event history readers to one restored Entity instance.
      *
+     * @param repository Registered repository admitting history reads.
      * @param entity Instance receiving the history accessors.
      * @param storage Entity storage used for reads and maintenance.
      * @param entityId Identifier used to select history records.
      * @param schema Schema used to unpack state records.
+     * @param tenantId Captured tenant for later live membership checks.
      */
-    bindEntityHistory(entity, storage, entityId, schema) {
-        const stateCache = RepositoryHistoryInternals.createHistoryCache((depth, startingFromVersion) => storage.states.backward(entityId, depth, startingFromVersion), (record) => BigInt(EntityRecords.unpack(schema, record).versionMessage.number), { requireDescendingVersions: true });
+    bindEntityHistory(repository, entity, storage, entityId, schema, tenantId) {
+        const lifetime = RepositoryStorage.lifetime(repository);
+        const runtime = repositoryRuntimes.get(repository);
+        if (runtime === undefined)
+            throw new Error("Repository history requires its active runtime.");
+        const onAdmit = () => this.admitHistory(repository, runtime, tenantId);
+        const { stateCache, eventCache } = this.boundHistoryCaches(storage, entityId, schema);
         entityStateHistoryCaches.set(entity, stateCache);
-        const eventCache = RepositoryHistoryInternals.createHistoryCache((depth, startingFromVersion) => storage.events.backward(entityId, depth, startingFromVersion), (event) => RepositorySignals.readEventVersion(event), { cacheCompleteVersionGroups: true });
         entityHistoryAccess.bind(entity, {
-            stateAt: async (time) => RepositoryHistoryInternals.cloneHistoryState(await storage.states.stateAt(entityId, time)),
-            states: async (depth) => RepositoryHistoryInternals.freezeHistoryStates((await stateCache.read(depth)).map((record) => EntityRecords.unpack(schema, record).state)),
-            events: async (depth) => RepositoryHistoryInternals.freezeHistoryEvents(await eventCache.read(depth)),
-            stateMaintenance: storage.states,
-            eventMaintenance: storage.events,
+            ...this.historyReaders({
+                repository,
+                lifetime,
+                stand: runtime.stand,
+                storage,
+                schema,
+                entityId,
+                tenantId,
+                entity,
+                onAdmit,
+                stateCache,
+                eventCache,
+            }),
+            stateMaintenance: this.boundStateMaintenance(repository, lifetime, storage.states, onAdmit),
+            eventMaintenance: this.boundEventMaintenance(repository, lifetime, storage.events, onAdmit),
         });
     },
+    /**
+     * Admits retained history provider work only while repository membership remains current.
+     *
+     * @param repository Repository whose runtime must remain current.
+     * @param runtime Captured context runtime.
+     * @param tenantId Bound tenant when multitenant.
+     * @returns Completion after membership admission.
+     */
+    async admitHistory(repository, runtime, tenantId) {
+        if (repositoryRuntimes.get(repository) !== runtime)
+            throw new Error("Repository history requires its active runtime.");
+        await runtime.onAdmit(tenantId);
+    },
+    /**
+     * Captures each protected history call's actor and request before admission awaits.
+     *
+     * @param scope Bound repository, caches, and admission work.
+     * @returns State and Event read callbacks for the Entity.
+     */
+    historyReaders(scope) {
+        return {
+            stateAt: (time) => this.historyStateAt(scope, time),
+            states: (depth) => this.historyStates(scope, depth),
+            events: (depth) => this.historyEvents(scope, depth),
+        };
+    },
+    /**
+     * Captures an Entity's state-at request and actor before membership awaits.
+     * @param scope Bound history resources.
+     * @param time Caller-selected historical time.
+     * @returns Historical state, if retained and visible.
+     */
+    async historyStateAt(scope, time) {
+        const actor = entityHistoryAccess.currentActor(scope.entity);
+        const captured = clone(TimestampSchema, time);
+        await scope.onAdmit();
+        return this.readBoundStateAt(scope.repository, scope.lifetime, scope.stand, scope.storage, scope.schema, scope.entityId, captured, scope.tenantId, actor);
+    },
+    /**
+     * Captures an Entity state-history depth and actor before membership awaits.
+     * @param scope Bound history resources.
+     * @param depth Number of prior states requested.
+     * @returns Visible historical states in retained order.
+     */
+    async historyStates(scope, depth) {
+        const actor = entityHistoryAccess.currentActor(scope.entity);
+        await scope.onAdmit();
+        return this.readBoundStates(scope.repository, scope.lifetime, scope.stand, scope.schema, scope.stateCache, scope.entityId, depth, scope.tenantId, actor);
+    },
+    /**
+     * Captures an Entity Event-history depth and actor before membership awaits.
+     * @param scope Bound history resources.
+     * @param depth Number of prior Events requested.
+     * @returns Visible retained Event envelopes.
+     */
+    async historyEvents(scope, depth) {
+        const actor = entityHistoryAccess.currentActor(scope.entity);
+        await scope.onAdmit();
+        return this.readBoundEvents(scope.repository, scope.lifetime, scope.stand, scope.eventCache, scope.entityId, depth, scope.tenantId, actor);
+    },
+    /**
+     * Creates state and Event caches over retained history ports.
+     *
+     * @param storage Retained history ports.
+     * @param entityId Captured Entity identifier.
+     * @param schema State schema for record version decoding.
+     * @returns Bound state and Event caches.
+     */
+    boundHistoryCaches(storage, entityId, schema) {
+        const stateCache = this.createHistoryCache((depth, startingFromVersion) => storage.states.backward(entityId, depth, startingFromVersion), (record) => BigInt(EntityRecords.unpack(schema, record).versionMessage.number), { requireDescendingVersions: true });
+        const eventCache = this.createHistoryCache((depth, startingFromVersion) => storage.events.backward(entityId, depth, startingFromVersion), (event) => RepositorySignals.readEventVersion(event), { cacheCompleteVersionGroups: true });
+        return { stateCache, eventCache };
+    },
+    /**
+     * Admits complete state-history maintenance against a captured runtime.
+     *
+     * @param repository Repository with the bound Entity.
+     * @param lifetime Runtime that provided the retained port.
+     * @param states Retained state-history port.
+     * @param onAdmit Checks current membership before physical work.
+     * @returns Guarded maintenance methods.
+     */
+    boundStateMaintenance(repository, lifetime, states, onAdmit) {
+        return {
+            trim: async (id, keep) => {
+                await onAdmit();
+                return RepositoryStorage.track(repository, () => states.trim(id, keep), lifetime);
+            },
+            truncate: async (time) => {
+                await onAdmit();
+                return RepositoryStorage.track(repository, () => states.truncate(time), lifetime);
+            },
+        };
+    },
+    /**
+     * Admits complete Event-history maintenance against a captured runtime.
+     *
+     * @param repository Repository with the bound Entity.
+     * @param lifetime Runtime that provided the retained port.
+     * @param events Retained Event-history port.
+     * @param onAdmit Checks current membership before physical work.
+     * @returns Guarded maintenance method.
+     */
+    boundEventMaintenance(repository, lifetime, events, onAdmit) {
+        return {
+            truncate: async (time) => {
+                await onAdmit();
+                return RepositoryStorage.track(repository, () => events.truncate(time), lifetime);
+            },
+        };
+    },
+    /**
+     * Reads one bound historical state within repository admission.
+     *
+     * @param repository Registered repository.
+     * @param lifetime Captured repository storage lifetime.
+     * @param stand Producing context's outward read policy.
+     * @param storage Retained Entity read port.
+     * @param schema Historical state schema.
+     * @param entityId Captured Entity identifier.
+     * @param time Historical instant.
+     * @param tenantId Effective tenant of the bound Entity.
+     * @param actorContext Actor metadata of an active handler, when present.
+     * @returns Historical state, if present.
+     */
+    readBoundStateAt(repository, lifetime, stand, storage, schema, entityId, time, tenantId, actorContext) {
+        return RepositoryStorage.track(repository, async () => {
+            const state = this.cloneHistoryState(await storage.states.stateAt(entityId, time));
+            if (state === undefined)
+                return undefined;
+            const visible = await standAccess.filterState(stand, schema, state, {
+                operation: { kind: "history", history: { source: "entity-state-at", entityId, time } },
+                ...(tenantId === undefined ? {} : { effectiveTenant: tenantId }),
+                ...(actorContext === undefined ? {} : { actorContext }),
+            });
+            return visible ?? undefined;
+        }, lifetime);
+    },
+    /**
+     * Reads a complete bound state-history page within repository admission.
+     *
+     * @param repository Registered repository.
+     * @param lifetime Captured repository storage lifetime.
+     * @param stand Producing context's outward read policy.
+     * @param schema State schema used to unpack rows.
+     * @param cache Bound state-history cache.
+     * @param entityId Captured Entity identifier.
+     * @param depth Requested history depth.
+     * @param tenantId Effective tenant of the bound Entity.
+     * @param actorContext Actor metadata of an active handler, when present.
+     * @returns Frozen historical states.
+     */
+    readBoundStates(repository, lifetime, stand, schema, cache, entityId, depth, tenantId, actorContext) {
+        return RepositoryStorage.track(repository, async () => {
+            const states = this.freezeHistoryStates((await cache.read(depth)).map((record) => EntityRecords.unpack(schema, record).state));
+            const visible = [];
+            for (const state of states) {
+                const next = await standAccess.filterState(stand, schema, state, {
+                    operation: { kind: "history", history: { source: "entity-states", entityId, depth } },
+                    ...(tenantId === undefined ? {} : { effectiveTenant: tenantId }),
+                    ...(actorContext === undefined ? {} : { actorContext }),
+                });
+                if (next !== null)
+                    visible.push(Object.freeze(next));
+            }
+            return Object.freeze(visible);
+        }, lifetime);
+    },
+    /**
+     * Reads a complete bound Event-history page within repository admission.
+     *
+     * @param repository Registered repository.
+     * @param lifetime Captured repository storage lifetime.
+     * @param stand Producing context's outward read policy.
+     * @param cache Bound Event-history cache.
+     * @param entityId Captured Entity identifier.
+     * @param depth Requested history depth.
+     * @param tenantId Effective tenant of the bound Entity.
+     * @param actorContext Actor metadata of an active handler, when present.
+     * @returns Frozen historical Events.
+     */
+    readBoundEvents(repository, lifetime, stand, cache, entityId, depth, tenantId, actorContext) {
+        return RepositoryStorage.track(repository, async () => {
+            const events = this.freezeHistoryEvents(await cache.read(depth));
+            const visible = [];
+            for (const event of events) {
+                const next = await standAccess.filterEvent(stand, event, {
+                    operation: { kind: "history", history: { source: "entity-events", entityId, depth } },
+                    ...(tenantId === undefined ? {} : { effectiveTenant: tenantId }),
+                    ...(actorContext === undefined ? {} : { actorContext }),
+                });
+                if (next !== null)
+                    visible.push(Object.freeze(next));
+            }
+            return Object.freeze(visible);
+        }, lifetime);
+    },
     /**
      * Creates a history cache that serializes reads and extends prior results.
      *
@@ -7063,14 +7106,11 @@ const DispatchGuards = {
      */
     async wasDispatched(repository, runtime, event, entityId, journalEventId, depth) {
         const input = RepositoryStorage.entityStorageInput(repository, RepositoryTenants.storageContextForEvent(runtime.context, event));
-        const storage = RepositoryStorage.openEntityStorage(runtime.storageFactory, input);
-        try {
+        return RepositoryStorage.track(repository, async () => {
+            const storage = RepositoryStorage.repositoryReadEntityStorage(repository, runtime.storageFactory, input);
             const persisted = await storage.events.backward(entityId, depth);
             return persisted.some((candidate) => candidate.id?.value === journalEventId);
-        }
-        finally {
-            storage.close();
-        }
+        });
     },
     /**
      * Records a successful delivery and discards the oldest excess identifiers.
@@ -7228,7 +7268,7 @@ const InboxMessages = {
         if (message.label !== "HANDLE_COMMAND") {
             throw new Error(`Entity Inbox replay does not handle "${message.label}" messages.`);
         }
-        const command = message.signal === undefined ? undefined : AnyMessages.unpack(message.signal, CommandSchema);
+        const command = message.signal === undefined ? undefined : AnyPacker.tryUnpack(message.signal, CommandSchema);
         if (command === undefined) {
             throw CommandValidationError.invalidPayload();
         }
@@ -7271,7 +7311,7 @@ const InboxMessages = {
                 typeUrl: message.signal.typeUrl,
                 value: new Uint8Array(message.signal.value),
             });
-        const event = signal === undefined ? undefined : AnyMessages.unpack(signal, EventSchema);
+        const event = signal === undefined ? undefined : AnyPacker.tryUnpack(signal, EventSchema);
         if (event === undefined) {
             throw new Error(unreadableMessage);
         }
@@ -7368,7 +7408,7 @@ const InboxReplay = {
         const assignee = routing.commandReadiness?.findCommandAssignee(route.messageFullTypeName);
         if (assignee === undefined)
             throw new Error("Agent Command has no selected assignee.");
-        await InboxReplay.admitAgent(repository, runtime, message, tenantId, route.entityId, { kind: "command", value: command }, command.context?.actorContext ?? create(ActorContextSchema), [assignee.registeredHandler]);
+        await InboxReplay.admitAgent(repository, runtime, message, tenantId, route.entityId, { case: "command", value: command }, [assignee.registeredHandler]);
     },
     /**
      * Admits matching Event handlers from the stored target without rerouting.
@@ -7388,7 +7428,7 @@ const InboxReplay = {
         const handlers = InboxReplay.agentEventHandlers(routing, route.messageFullTypeName, event);
         if (handlers.length === 0)
             return;
-        await InboxReplay.admitAgent(repository, runtime, message, tenantId, route.entityIds[0], { kind: "event", value: event }, runtime.signalMetadata.originFromEvent(event).actorContext ?? create(ActorContextSchema), handlers);
+        await InboxReplay.admitAgent(repository, runtime, message, tenantId, route.entityIds[0], { case: "event", value: event }, handlers);
     },
     /**
      * Restores selected Event and Command reactions from the original payload.
@@ -7417,64 +7457,154 @@ const InboxReplay = {
      * @param tenantId Selected delivery tenant.
      * @param entityId Typed target from the stored route.
      * @param signal Original source envelope.
-     * @param actor Original actor metadata.
      * @param handlers Selected handler metadata in execution order.
      * @returns When the fenced repository operation completes.
      */
-    async admitAgent(repository, runtime, message, tenantId, entityId, signal, actor, handlers) {
-        const revisions = InboxReplay.agentRevisions(repository, runtime, handlers);
-        const input = RepositoryStorage.entityStorageInput(repository, RepositoryTenants.storageContextForTenant(runtime.context, tenantId));
-        const execution = InboxReplay.agentExecutionHandle(repository, runtime, input);
-        await execution.admit(AgentAdmission.create({
-            stateType: repository.stateSchema.typeName,
-            agentKey: input.id.key(entityId),
-            recipientId: message.inboxId.targetId,
+    async admitAgent(repository, runtime, message, tenantId, entityId, signal, handlers) {
+        const context = RepositoryTenants.storageContextForTenant(runtime.context, tenantId);
+        const input = RepositoryStorage.entityStorageInput(repository, context);
+        const deliverySignal = AgentDeliveryScope.signal();
+        if (deliverySignal === undefined)
+            throw new Error("Agent admission requires delivery scope.");
+        const cancellation = AbortSignal.any([deliverySignal, runtime.agentSignal]);
+        const key = InboxReplay.capacityKeyFor(repository, input.context, input.id.key(entityId));
+        const reservation = runtime.reserveAgent(key, cancellation);
+        if (reservation === undefined) {
+            runtime.deferAgent(message, tenantId);
+            AgentDeliveryScope.record({ kind: "deferred" });
+            return;
+        }
+        await InboxReplay.admitReservedAgent({
+            repository,
+            runtime,
+            context: input.context,
+            message,
+            tenantId,
+            entityId,
             signal,
-            actor,
-            inbox: message,
             handlers,
-            codeRevision: revisions.codeRevision,
-            schemaRevision: revisions.schema,
-            policyRevision: revisions.policy,
-        }));
-        runtime.wakeAcceptedAgent(repository, tenantId);
+            reservation,
+        });
     },
     /**
-     * Opens the actual tenant's mandatory execution handle.
+     * Serializes the complete local Agent identity for one capacity slot.
      *
-     * @typeParam I Typed Agent identifier.
-     * @typeParam S Generated Agent state message.
-     * @param repository Registered Entity repository for this operation.
-     * @param runtime Bounded Context storage and publication services.
-     * @param input Original Inbox or storage input.
-     * @returns Fenced execution handle for the accepted tenant.
+     * @param context Captured tenant storage context.
+     * @param stateType Declared Agent state type.
+     * @param id Canonical typed Agent identifier.
+     * @returns Stable local capacity key for this Agent and tenant.
      */
-    agentExecutionHandle(repository, runtime, input) {
-        const storage = RepositoryStorage.openRepositoryEntityStorage(repository, runtime.storageFactory, input);
-        if (storage.agentExecution === undefined)
-            throw new Error("Agent Inbox replay requires durable execution storage.");
-        return storage.agentExecution;
+    agentCapacityKey(context, stateType, id) {
+        return JSON.stringify([context.name, String(TenantBoundary.of(context).key), stateType, id]);
     },
     /**
-     * Records the registered code, schema, and AI policy before Inbox handoff.
+     * Builds a capacity key for one repository entity in the selected tenant.
      *
-     * @param repository Registered Entity repository for this operation.
-     * @param runtime Bounded Context storage and publication services.
-     * @param handlers Generated handlers in their saved order.
-     * @returns Pinned code, schema, and AI policy digests.
-     */
-    agentRevisions(repository, runtime, handlers) {
-        const ai = runtime.ai;
-        const configuration = repositoryAccess.agentConfiguration(repository);
-        if (ai === undefined ||
-            configuration.ai === undefined ||
-            configuration.codeRevision === undefined)
-            throw new Error("Agent Inbox replay requires registered AI capabilities and revisions.");
-        return {
-            codeRevision: configuration.codeRevision,
-            ...AgentRevisions.atAdmission(repository.stateSchema, handlers, ai, configuration.ai),
+     * @param repository Agent repository declaring the state type.
+     * @param context Captured tenant storage context.
+     * @param id Canonical typed Agent identifier.
+     * @returns Stable local capacity key for this repository entity.
+     */
+    capacityKeyFor(repository, context, id) {
+        return this.agentCapacityKey(context, repository.stateSchema.typeName, id);
+    },
+    /**
+     * Completes receipt admission or returns a nonacknowledging provider error.
+     * @param input Captured signal, runtime, and local capacity reservation.
+     * @returns Completion of receipt admission or recorded provider failure.
+     */
+    async admitReservedAgent(input) {
+        const { repository, runtime, context, message, signal, reservation } = input;
+        try {
+            const accepted = await InboxReplay.acceptAgentReceipt(runtime, context, repository, message, signal);
+            if (!accepted) {
+                reservation.release();
+                AgentDeliveryScope.record({ kind: "duplicate" });
+                return;
+            }
+            InboxReplay.recordAcceptedAgent(input);
+        }
+        catch (error) {
+            reservation.release();
+            AgentDeliveryScope.record({ kind: "error", error });
+        }
+    },
+    /**
+     * Records one accepted typed signal to its post-ack serialized live turn.
+     * @param input Accepted signal and its retained capacity reservation.
+     */
+    recordAcceptedAgent(input) {
+        const { repository, runtime, message, tenantId, entityId, signal, handlers, reservation } = input;
+        const invocation = {
+            stateType: repository.stateSchema.typeName,
+            recipientId: clone(AnySchema, message.inboxId.targetId),
+            source: signal,
+        };
+        AgentDeliveryScope.record({
+            kind: "accepted",
+            discard: () => {
+                reservation.release();
+            },
+            run: (fence, checkSession) => {
+                const cancellation = AbortSignal.any([fence, runtime.agentSignal]);
+                const checkAgentSession = InboxReplay.agentSessionGuard(cancellation, checkSession);
+                return reservation.run(() => withDeliveryCommitFence(checkAgentSession, () => new AgentLiveRunner(repository, runtime, tenantId, entityId, invocation, handlers, cancellation, checkAgentSession).run()));
+            },
+        });
+    },
+    /**
+     * Verifies context cancellation on both sides of asynchronous shard validation.
+     * @param cancellation Combined context and shard cancellation signal.
+     * @param checkSession Validates the current shard session.
+     * @returns A guard for live Agent effects and commits.
+     */
+    agentSessionGuard(cancellation, checkSession) {
+        return async () => {
+            cancellation.throwIfAborted();
+            await checkSession();
+            cancellation.throwIfAborted();
         };
     },
+    /**
+     * Writes one typed receipt after a local Agent capacity reservation.
+     * @param context Captured tenant storage context.
+     * @param message Original Inbox row with the typed recipient.
+     * @param repository Agent repository declaring the state type.
+     * @param runtime Bound repository runtime containing the receipt port.
+     * @param signal Original Command or Event signal.
+     * @returns Whether this exact Agent signal was newly accepted.
+     */
+    acceptAgentReceipt(runtime, context, repository, message, signal) {
+        const source = signal.case === "command"
+            ? { kind: "command", id: InboxReplay.requireAgentCommandId(signal.value) }
+            : { kind: "event", id: InboxReplay.requireAgentEventId(signal.value) };
+        return runtime.agentReceipts.accept(context, {
+            stateType: repository.stateSchema.typeName,
+            recipientId: message.inboxId.targetId,
+            source,
+            action: message.label,
+        });
+    },
+    /**
+     * Validates the original typed Command ID before writing an Agent receipt.
+     * @param command Original Command addressed to the Agent.
+     * @returns Original nonempty typed Command ID.
+     */
+    requireAgentCommandId(command) {
+        if (command.id === undefined || command.id.uuid.trim().length === 0)
+            throw new Error("Agent acceptance requires the original Command ID.");
+        return command.id;
+    },
+    /**
+     * Validates the original typed Event ID before writing an Agent receipt.
+     * @param event Original Event addressed to the Agent.
+     * @returns Original nonempty typed Event ID.
+     */
+    requireAgentEventId(event) {
+        if (event.id === undefined || event.id.value.trim().length === 0)
+            throw new Error("Agent acceptance requires the original Event ID.");
+        return event.id;
+    },
     /**
      * Dispatches a stored Process Manager Command after tenant and payload validation.
      *
@@ -7583,7 +7713,7 @@ const InboxReplay = {
     validateReplayedCommandPayload(routing, command) {
         const commandMessage = EntityInvocation.requireSignalMessage(command.message, "command");
         const commandSchema = RepositoryRoutes.schemaForTypeUrl(routing.commandSchemas, commandMessage.typeUrl, "command");
-        const payload = AnyMessages.unpack(commandMessage, commandSchema);
+        const payload = AnyPacker.tryUnpack(commandMessage, commandSchema);
         if (payload === undefined) {
             throw CommandValidationError.invalidPayload();
         }
@@ -7611,7 +7741,7 @@ const InboxReplay = {
     validateReplayedEventPayload(routing, event, invalidPayloadMessage = "Projection inbox replay requires a readable event payload.") {
         const eventMessage = EntityInvocation.requireSignalMessage(event.message, "event");
         const eventSchema = RepositoryRoutes.schemaForTypeUrl(routing.eventSchemas, eventMessage.typeUrl, "event");
-        const payload = AnyMessages.unpack(eventMessage, eventSchema);
+        const payload = AnyPacker.tryUnpack(eventMessage, eventSchema);
         if (payload === undefined) {
             throw new Error(invalidPayloadMessage);
         }
@@ -7792,18 +7922,14 @@ const InboxHandoff = {
         const commandId = RepositorySignals.requireCommandId(command);
         const keepUntil = new Date(Time.currentTimeMillis() + inboxDedupMs);
         const deliveryTenantId = RepositoryTenants.requireCommandTenant(runtime.context, command);
-        const delivery = new Delivery({
-            context: RepositoryTenants.entityInboxDeliveryContext(runtime.context, deliveryTenantId),
-            storageFactory: runtime.storageFactory,
-            strategy: runtime.entityInbox.strategy(),
-        });
+        const delivery = serverEnvironmentAccess.coreDelivery(ServerEnvironment.instance());
         await runtime.entityInbox.receive(delivery, {
             inboxId: {
                 targetId: InboxMessages.inboxTargetId(route.entityId, repository.idField),
                 targetTypeUrl: TypeUrls.derive(repository.stateSchema),
             },
             signalId: commandId.uuid,
-            signal: AnyMessages.pack(CommandSchema, command, { validate: false }),
+            signal: AnyPacker.pack(CommandSchema, command),
             label: "HANDLE_COMMAND",
             status: "TO_DELIVER",
             keepUntil,
@@ -7822,17 +7948,14 @@ const InboxHandoff = {
         const eventId = RepositorySignals.requireEventId(event);
         const keepUntil = new Date(Time.currentTimeMillis() + inboxDedupMs);
         const deliveryTenantId = RepositoryTenants.requireProjectionTenant(runtime.context, event);
-        const delivery = new Delivery({
-            context: RepositoryTenants.projectionDeliveryContext(runtime.context, deliveryTenantId),
-            storageFactory: runtime.storageFactory,
-        });
+        const delivery = serverEnvironmentAccess.coreDelivery(ServerEnvironment.instance());
         await runtime.projectionInbox.receive(delivery, {
             inboxId: {
                 targetId: InboxMessages.inboxTargetId(entityId, repository.idField),
                 targetTypeUrl: TypeUrls.derive(repository.stateSchema),
             },
             signalId: eventId.value,
-            signal: AnyMessages.pack(EventSchema, event, { validate: false }),
+            signal: AnyPacker.pack(EventSchema, event),
             label: "UPDATE_SUBSCRIBER",
             status: "TO_DELIVER",
             shard: ShardIndex.single(),
@@ -7852,11 +7975,7 @@ const InboxHandoff = {
         const eventId = RepositorySignals.requireEventId(event);
         const keepUntil = new Date(Time.currentTimeMillis() + inboxDedupMs);
         const deliveryTenantId = RepositoryTenants.requirePmEventTenant(runtime.context, event);
-        const delivery = new Delivery({
-            context: RepositoryTenants.entityInboxDeliveryContext(runtime.context, deliveryTenantId),
-            storageFactory: runtime.storageFactory,
-            strategy: runtime.entityInbox.strategy(),
-        });
+        const delivery = serverEnvironmentAccess.coreDelivery(ServerEnvironment.instance());
         await runtime.entityInbox.receive(delivery, InboxHandoff.pmEventInboxInput(repository, eventId.value, event, entityId, keepUntil), deliveryTenantId);
     },
     /**
@@ -7872,11 +7991,7 @@ const InboxHandoff = {
         const eventId = RepositorySignals.requireEventId(event);
         const keepUntil = new Date(Time.currentTimeMillis() + inboxDedupMs);
         const deliveryTenantId = RepositoryTenants.requirePmEventTenant(runtime.context, event);
-        const delivery = new Delivery({
-            context: RepositoryTenants.entityInboxDeliveryContext(runtime.context, deliveryTenantId),
-            storageFactory: runtime.storageFactory,
-            strategy: runtime.entityInbox.strategy(),
-        });
+        const delivery = serverEnvironmentAccess.coreDelivery(ServerEnvironment.instance());
         for (let start = 0; start < entityIds.length; start += 1_000) {
             const inputs = entityIds
                 .slice(start, start + 1_000)
@@ -7901,7 +8016,7 @@ const InboxHandoff = {
                 targetTypeUrl: TypeUrls.derive(repository.stateSchema),
             },
             signalId,
-            signal: AnyMessages.pack(EventSchema, event, { validate: false }),
+            signal: AnyPacker.pack(EventSchema, event),
             label: "REACT_UPON_EVENT",
             status: "TO_DELIVER",
             keepUntil,
@@ -7909,182 +8024,6 @@ const InboxHandoff = {
     },
 };
 Object.freeze(InboxHandoff);
-/**
- * Rebinds generated repository recipients without repeating accepted route queries.
- */
-const SavedRepositoryDispatch = {
-    /**
-     * Maps a generated repository family to its serialized binding value.
-     *
-     * @param repository Registered Entity repository for this operation.
-     * @returns Repository family encoded in a saved dispatch target.
-     */
-    family(repository) {
-        switch (repository.entityFamily) {
-            case "aggregate":
-                return AgentSavedRepositoryFamily.AGENT_SAVED_AGGREGATE;
-            case "projection":
-                return AgentSavedRepositoryFamily.AGENT_SAVED_PROJECTION;
-            case "process-manager":
-                return AgentSavedRepositoryFamily.AGENT_SAVED_PROCESS_MANAGER;
-            case "agent":
-                return AgentSavedRepositoryFamily.AGENT_SAVED_AGENT;
-        }
-    },
-    /**
-     * Finds the current generated handlers that determine an Event handoff.
-     *
-     * @param routing Registered generated handler routing metadata.
-     * @param event Original typed Event envelope.
-     * @returns Generated handlers matching the outgoing Event.
-     */
-    eventHandlers(routing, event) {
-        const packed = EntityInvocation.requireSignalMessage(event.message, "event");
-        const schema = RepositoryRoutes.schemaForTypeUrl(routing.eventSchemas, packed.typeUrl, "event");
-        const value = EntityInvocation.unpackRequired(packed, schema, "event");
-        const external = event.context?.external === true;
-        return [
-            ...routing.eventReactors(schema.typeName, value, external),
-            ...routing.commandReactions(schema.typeName, value, external),
-            ...routing
-                .eventSubscribers(schema.typeName, value, external)
-                .map((entry) => entry.registeredHandler),
-        ];
-    },
-    /**
-     * Calculates a digest of ordered generated metadata and message descriptors.
-     *
-     * @param repository Registered Entity repository for this operation.
-     * @param handlers Generated handlers in their saved order.
-     * @returns Digest of ordered generated handler metadata.
-     */
-    fingerprint(repository, handlers) {
-        const selected = handlers.map(({ entity, handler }, ordinal) => ({
-            ordinal,
-            receiver: entity.schema.typeName,
-            kind: handler.kind,
-            method: handler.methodName,
-            signal: handler.messageFullTypeName,
-            origin: handler.origin,
-            parameters: handler.parameterCount,
-            where: handler.where === undefined ? null : [handler.where.eventField, handler.where.equals],
-            descriptor: Buffer.from(toBinary(FileDescriptorProtoSchema, handler.schema.file.proto)).toString("base64"),
-        }));
-        const state = Buffer.from(toBinary(FileDescriptorProtoSchema, repository.stateSchema.file.proto));
-        return createHash("sha256").update(state).update(JSON.stringify(selected)).digest("hex");
-    },
-    /**
-     * Restores a typed ID only when its canonical wire representation is unchanged.
-     *
-     * @param repository Registered Entity repository for this operation.
-     * @param packed Original typed Protobuf payload.
-     * @returns Typed recipient identifier from the frozen route.
-     */
-    recipient(repository, packed) {
-        const id = InboxMessages.targetEntityId(packed, repository.idField);
-        if (!equals(AnySchema, InboxMessages.inboxTargetId(id, repository.idField), packed))
-            throw new Error("Saved Agent output recipient ID is not canonical for its repository.");
-        return id;
-    },
-    /**
-     * Checks the stable repository and signal identity before saved transport.
-     *
-     * @param repository Registered Entity repository for this operation.
-     * @param target Frozen recipient binding.
-     * @param kind Generation or decision model kind.
-     * @returns Whether the checked condition holds.
-     */
-    matches(repository, target, kind) {
-        return (target.kind === kind &&
-            target.receiverStateType === repository.stateSchema.typeName &&
-            target.repositoryFamily === SavedRepositoryDispatch.family(repository));
-    },
-    /**
-     * Prepares one typed Command recipient with its selected generated assignee.
-     *
-     * @param repository Registered Entity repository for this operation.
-     * @param routing Registered generated handler routing metadata.
-     * @param command Original typed Command envelope.
-     * @returns Validated frozen Command recipient target.
-     */
-    async prepareCommand(repository, routing, command) {
-        const route = await repository.routeCommand(command);
-        const assignee = routing.commandReadiness?.findCommandAssignee(route.messageFullTypeName);
-        if (assignee === undefined)
-            throw new Error("Saved Agent Command has no generated assignee.");
-        return create(SavedTargetSchema, {
-            kind: AgentSavedTargetKind.AGENT_SAVED_REPOSITORY_COMMAND,
-            receiverStateType: repository.stateSchema.typeName,
-            repositoryFamily: SavedRepositoryDispatch.family(repository),
-            signalType: route.messageFullTypeName,
-            bindingFingerprint: SavedRepositoryDispatch.fingerprint(repository, [
-                assignee.registeredHandler,
-            ]),
-            recipients: [InboxMessages.inboxTargetId(route.entityId, repository.idField)],
-        });
-    },
-    /**
-     * Resolves the original Command recipient without calling its route again.
-     *
-     * @param repository Registered Entity repository for this operation.
-     * @param routing Registered generated handler routing metadata.
-     * @param command Original typed Command envelope.
-     * @param target Frozen recipient binding.
-     * @returns When the fenced repository operation completes.
-     */
-    bindCommand(repository, routing, command, target) {
-        const { runtime, signalType, recipient } = SavedRepositoryDispatch.requireCommandBinding(repository, routing, command, target);
-        const entityId = SavedRepositoryDispatch.recipient(repository, recipient);
-        const route = {
-            entityId,
-            messageFullTypeName: signalType,
-            invocation: "deferred",
-        };
-        return Promise.resolve(() => InboxHandoff.handoffEntityCommand(repository, runtime, command, route));
-    },
-    /**
-     * Checks saved Command metadata, typed target presence, and runtime registration.
-     *
-     * @param repository Registered Entity repository for this operation.
-     * @param routing Registered generated handler routing metadata.
-     * @param command Original typed Command envelope.
-     * @param target Frozen recipient binding.
-     * @returns Registered Command route and original recipient.
-     */
-    requireCommandBinding(repository, routing, command, target) {
-        const packed = EntityInvocation.requireSignalMessage(command.message, "command");
-        const schema = RepositoryRoutes.schemaForTypeUrl(routing.commandSchemas, packed.typeUrl, "command");
-        const assignee = routing.commandReadiness?.findCommandAssignee(schema.typeName);
-        const fingerprint = assignee === undefined
-            ? ""
-            : SavedRepositoryDispatch.fingerprint(repository, [assignee.registeredHandler]);
-        const recipient = target.recipients[0];
-        const runtime = repositoryRuntimes.get(repository);
-        if (!SavedRepositoryDispatch.matches(repository, target, AgentSavedTargetKind.AGENT_SAVED_REPOSITORY_COMMAND) ||
-            target.signalType !== schema.typeName ||
-            target.bindingFingerprint !== fingerprint ||
-            target.recipients.length !== 1 ||
-            recipient === undefined ||
-            runtime === undefined)
-            throw new Error("Saved Agent Command repository binding changed before delivery.");
-        return { runtime, signalType: schema.typeName, recipient };
-    },
-    /**
-     * Creates one internal Command binding from the repository registration.
-     *
-     * @param repository Registered Entity repository for this operation.
-     * @param routing Registered generated handler routing metadata.
-     * @returns Saved Command binding for this registration.
-     */
-    commandBinding(repository, routing) {
-        return {
-            prepare: (command) => SavedRepositoryDispatch.prepareCommand(repository, routing, command),
-            matches: (target) => SavedRepositoryDispatch.matches(repository, target, AgentSavedTargetKind.AGENT_SAVED_REPOSITORY_COMMAND),
-            bind: (command, target) => SavedRepositoryDispatch.bindCommand(repository, routing, command, target),
-        };
-    },
-};
-Object.freeze(SavedRepositoryDispatch);
 /**
  * Connects bus dispatchers and Inbox replay to repository execution.
  */
@@ -8119,7 +8058,7 @@ const RepositoryDispatch = {
             messageSchemas: () => routing.commandSchemas,
             dispatch: (command) => RepositoryDispatch.dispatchRepositoryCommand(repository, routing, command),
         });
-        return SavedDispatcherBindings.command(dispatcher, SavedRepositoryDispatch.commandBinding(repository, routing));
+        return dispatcher;
     },
     /**
      * Creates an Event dispatcher that preserves routes computed during acceptance.