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

package/dist/repository/repository.js

@@ -11,16 +11,22 @@
  * or implied. See the License for the specific language governing permissions and limitations under
  * the License.
  */
-import { clone, create, ScalarType, toBinary, } from "@bufbuild/protobuf";
-import { AnySchema, Int32ValueSchema, Int64ValueSchema, StringValueSchema, } from "@bufbuild/protobuf/wkt";
+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 { 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 { StorageQueryPolicy, } from "@spine-event-engine/storage";
+import { EventStore, StorageQueryPolicy, } from "@spine-event-engine/storage";
 import { TenantBoundary } 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 { registryOptions } from "@spine-event-engine/ai/spi/runtime";
 import { CommandValidationError } from "../bus/command-errors.js";
 import { SignalPublisher } from "../runtime/signal-publisher.js";
 import { ServerEnvironment, serverEnvironmentAccess } from "../server/server-environment.js";
@@ -30,11 +36,24 @@ import { EventRoutingInternals } from "./event-routing.js";
 import { StateUpdateRoutingInternals, } from "./state-update-routing.js";
 import { RoutingDeclarations } from "./routing-declarations.js";
 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 { 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";
-import { Aggregate, ProcessManager, Projection, entityHistoryAccess, processManagerQueryAccess, transactionalEntityAccess, } from "../entity/entity.js";
+import { Aggregate, Agent, ProcessManager, Projection, entityHistoryAccess, processManagerQueryAccess, transactionalEntityAccess, } from "../entity/entity.js";
 import { describeEntityMetadata, attachEntitySchema, } from "../entity/entity-metadata.js";
 import { EntityIds, EntityRecords, entityStorageDescriptor, } from "../entity/entity-storage-descriptor.js";
 import { repositorySpecScanner } from "../entity/spec-scanner.js";
@@ -185,6 +204,31 @@ export class Repository {
     get snapshot() {
         return RepositoryIdentity.cloneRepositorySnapshot(RepositoryIdentity.createRepositorySnapshot(this.#entityType, this.#entityFamily, this.#metadata));
     }
+    /**
+     * Opens retained history for one Agent without restoring an Entity.
+     * The trusted application must authorize the caller before using this read.
+     *
+     * @param this Registered Agent repository.
+     * @param id Typed Agent identifier.
+     * @param scope Explicit tenant boundary; pass `{}` in a single-tenant Bounded Context.
+     * @returns Reader for indexed history categories.
+     */
+    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.
      *
@@ -213,6 +257,199 @@ export class Repository {
         });
     }
 }
+const RepositoryAgentReads = {
+    /**
+     * Captures a validated Agent and tenant boundary without opening Entity storage.
+     *
+     * @param repository Registered Agent repository.
+     * @param id Typed Agent identifier.
+     * @param scope Explicit tenant selection.
+     * @returns Detached read identity and active runtime.
+     */
+    capture(repository, id, scope) {
+        if (repository.entityFamily !== "agent")
+            throw new TypeError("Agent read requires an Agent repository.");
+        const scopeValue = scope;
+        if (scopeValue === null || typeof scopeValue !== "object")
+            throw new TypeError("Agent read requires an explicit scope.");
+        const runtime = repositoryRuntimes.get(repository);
+        if (runtime === undefined)
+            throw new Error("Agent read requires an active repository.");
+        const validated = RepositoryRoutes.readRouteId(id, repository.idField, "command");
+        const field = repository.idField.descriptor;
+        const copiedId = field.fieldKind === "message"
+            ? clone(field.message, validated)
+            : validated;
+        const tenant = scope.tenantId === undefined ? undefined : RepositoryTenants.require(scope.tenantId);
+        const context = RepositoryTenants.storageContextForTenant(runtime.context, tenant);
+        return { runtime, context, id: copiedId };
+    },
+    /**
+     * Returns a detached public history request before provider access.
+     *
+     * @param request Page request and opaque cursor.
+     * @returns Independent request values.
+     */
+    request(request) {
+        return {
+            pageSize: request.pageSize,
+            ...(request.cursor === undefined ? {} : { cursor: request.cursor }),
+        };
+    },
+    /**
+     * Creates the four scoped history views for one captured Agent identity.
+     *
+     * @param repository Registered Agent repository.
+     * @param id Typed Agent identifier.
+     * @param scope Explicit tenant selection.
+     * @returns Reader using indexed provider history.
+     */
+    history(repository, id, scope) {
+        const captured = this.capture(repository, id, scope);
+        const read = (view, request) => this.historyPage(repository, captured, view, this.request(request));
+        return Object.freeze({
+            fullHistory: (request) => read({ kind: "full" }, request),
+            conversationHistory: async (request) => {
+                const conversationValue = request.conversation;
+                if (conversationValue === null ||
+                    typeof conversationValue !== "object" ||
+                    !("$typeName" in conversationValue) ||
+                    conversationValue.$typeName !== ConversationIdSchema.typeName ||
+                    !("value" in conversationValue) ||
+                    typeof conversationValue.value !== "string" ||
+                    conversationValue.value.length === 0)
+                    throw new TypeError("Agent conversation history requires a ConversationId.");
+                const conversation = clone(ConversationIdSchema, request.conversation);
+                const page = await read({ kind: "conversation", conversation }, request);
+                return this.project(page, "conversationRecord");
+            },
+            systemEventHistory: async (request) => this.project(await read({ kind: "system" }, request), "systemEvent"),
+            domainEventHistory: async (request) => this.project(await read({ kind: "domain" }, request), "domainEvent"),
+        });
+    },
+    /**
+     * Reads one category from the existing indexed history provider.
+     *
+     * @param repository Registered Agent repository.
+     * @param captured Detached Agent and tenant identity.
+     * @param view Indexed category and optional conversation.
+     * @param request Detached page request.
+     * @returns Detached history entries and opaque continuation.
+     */
+    async historyPage(repository, captured, view, request) {
+        if (repositoryRuntimes.get(repository) !== captured.runtime)
+            throw new Error("Agent read requires an active repository.");
+        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();
+        }
+    },
+    /**
+     * Returns one typed category from the full Proto history oneof.
+     *
+     * @typeParam K Selected history oneof category.
+     * @param page Complete indexed history page.
+     * @param kind Expected oneof category.
+     * @returns Category values and the original continuation.
+     */
+    project(page, kind) {
+        const items = page.items.map((entry) => {
+            if (entry.item.case !== kind)
+                throw new Error("Agent history provider returned the wrong category.");
+            return entry.item.value;
+        });
+        return {
+            items,
+            ...(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();
 const repositoryRoutings = new WeakMap();
@@ -225,6 +462,8 @@ const repositoryRuntimes = new WeakMap();
 const repositoryEntityHandles = 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.
@@ -248,10 +487,27 @@ const RepositoryRegistration = {
         repositoryRoutings.set(repository, routing);
         repositoryProducedEventSchemas.set(repository, Object.freeze([...routing.producedEventSchemas]));
         repositoryHistoryConfigurations.set(repository, RepositoryStorage.readHistoryConfiguration(options, entityFamily));
+        this.installAgentOptions(repository, options, entityFamily);
         repositorySnapshots.set(repository, RepositoryIdentity.createRepositorySnapshot(entityType, entityFamily, metadata));
         repositoryDispatchers.set(repository, RepositoryDispatch.createRepositoryDispatchers(repository, routing));
         RepositoryRegistration.installTargets(repository, routing);
     },
+    /**
+     * Captures Agent capability and code revisions during repository registration.
+     *
+     * @typeParam EntityType Concrete generated Entity constructor.
+     * @param repository Registered Entity repository for this operation.
+     * @param options Repository or execution options for this operation.
+     * @param family Registered Entity family.
+     */
+    installAgentOptions(repository, options, family) {
+        if (family !== "agent")
+            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.
      *
@@ -312,6 +568,98 @@ 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;
+    },
+    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 }) });
+    },
+    /**
+     * Opens a scoped provider read without restoring an application Entity.
+     *
+     * @param repository Registered Agent repository.
+     * @param entityId Typed Agent identifier.
+     * @param view Indexed category.
+     * @param read Requested count, byte budget, and complete continuation key.
+     * @param tenantId Complete tenant identity when required.
+     * @returns Retained entries and continuation status.
+     */
+    async agentHistory(repository, entityId, view, read, tenantId) {
+        if (repository.entityFamily !== "agent")
+            throw new TypeError("Agent history requires an Agent repository.");
+        const runtime = repositoryRuntimes.get(repository);
+        if (runtime === undefined)
+            throw new Error("Agent history requires an active repository.");
+        const context = RepositoryTenants.storageContextForTenant(runtime.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();
+        }
+    },
+    async agentHistoryPage(repository, entityId, request, tenantId) {
+        if (repository.entityFamily !== "agent")
+            throw new TypeError("Agent history requires an Agent repository.");
+        const runtime = repositoryRuntimes.get(repository);
+        if (runtime === undefined)
+            throw new Error("Agent history requires an active repository.");
+        const context = RepositoryTenants.storageContextForTenant(runtime.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({
+                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.
+     */
+    agentHistoryScope(context, input, entityId) {
+        return {
+            context: context.name,
+            tenant: JSON.stringify(context.tenantId ?? null),
+            repository: input.sourceType.typeName,
+            entity: input.id.key(entityId),
+        };
+    },
     /**
      * Looks up command dispatch for the repository.
      *
@@ -1558,13 +1906,10 @@ class ProjectionEventExecution {
     async #loadProjection(entityId, options, mode) {
         const stored = await standAccess.readCurrent(this.#runtime.stand, this.#repository.stateSchema, entityId, options);
         const entity = RepositoryEntities.instantiate(this.#repository, entityId, stored, mode === "rebuild" && stored?.deleted === true);
-        const { commits, events, storageInput } = RepositoryEntities.bindStorage(this.#repository, this.#runtime, options.tenantId, entityId, entity);
-        return RepositoryEntities.loaded(entity, stored, commits, events, storageInput, this.#repository.stateSchema, entityId);
+        const { commits, events, agentHistory, storageInput } = RepositoryEntities.bindStorage(this.#repository, this.#runtime, options.tenantId, entityId, entity);
+        return RepositoryEntities.loaded(entity, stored, commits, events, agentHistory, storageInput, this.#repository.stateSchema, entityId);
     }
 }
-/**
- * Binds Process Manager query access to Stand for one handler invocation.
- */
 const ProcessManagerQueries = Object.freeze({
     /**
      * Binds tenant-aware query reads and returns a release callback.
@@ -1573,15 +1918,16 @@ const ProcessManagerQueries = Object.freeze({
      * @param runtime Context Stand and query services.
      * @param actorContext Actor metadata from the source signal.
      * @param tenantId Tenant for query reads, when present.
+     * @param intercept Durable Agent snapshot interception, when active.
      * @returns Callback that removes the query binding.
      */
-    bind(entity, runtime, actorContext, tenantId) {
+    bind(entity, runtime, actorContext, tenantId, intercept) {
         const context = actorContext === undefined
             ? create(ActorContextSchema)
             : clone(ActorContextSchema, actorContext);
         const effectiveTenant = EffectiveTenants.current(runtime.context.multitenant, tenantId);
         context.tenantId = effectiveTenant;
-        return processManagerQueryAccess.bind(entity, (plan, schema, query) => ProcessManagerQueries.read(runtime, effectiveTenant, plan, schema, query), context);
+        return processManagerQueryAccess.bind(entity, (plan, schema, query) => ProcessManagerQueries.read(runtime, effectiveTenant, plan, schema, query, intercept), context);
     },
     /**
      * Routes a handler read to the registered state target before reaching storage.
@@ -1592,9 +1938,10 @@ const ProcessManagerQueries = Object.freeze({
      * @param plan Compiled read criteria.
      * @param schema State schema supplied by the handler.
      * @param query Wire query carrying the actor and requested fields.
+     * @param intercept Durable Agent snapshot interception, when active.
      * @returns Detached state snapshots decoded with the caller's schema.
      */
-    async read(runtime, tenantId, plan, schema, query) {
+    async read(runtime, tenantId, plan, schema, query, intercept) {
         const routes = RegisteredTargets.forStand(runtime.stand);
         const typeUrl = TypeUrls.derive(schema);
         const target = routes?.find(typeUrl);
@@ -1609,7 +1956,23 @@ const ProcessManagerQueries = Object.freeze({
         if (target !== undefined)
             routes?.validate(target, plan);
         const destination = EffectiveTenants.destination(tenantId, target?.context.isMultitenant ?? runtime.context.multitenant);
-        const results = await QueryReader.read(target?.context.stand() ?? runtime.stand, registeredSchema, plan, destination, 10_000, query);
+        const live = () => this.load(target?.context.stand() ?? runtime.stand, registeredSchema, plan, destination, query, schema);
+        return intercept === undefined ? live() : intercept(schema, query, live);
+    },
+    /**
+     * Reads the authorized target after optional Agent snapshot reuse is checked.
+     *
+     * @typeParam Schema Generated Projection state descriptor.
+     * @param stand Stand selected by the authorized query route.
+     * @param registeredSchema Descriptor registered for the target.
+     * @param plan Compiled query criteria.
+     * @param destination Effective tenant selected for the target.
+     * @param query Original typed Query envelope.
+     * @param schema Descriptor expected by the caller.
+     * @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);
         return Object.freeze(results.map((result) => clone(schema, result.state)));
     },
 });
@@ -1654,32 +2017,65 @@ class ProcessManagerExecutionSupport {
     async load(entityId, options) {
         const stored = await standAccess.readCurrent(this.#runtime.stand, this.#repository.stateSchema, entityId, options);
         const entity = RepositoryEntities.instantiate(this.#repository, entityId, stored, false);
-        const { commits, events, storageInput } = RepositoryEntities.bindStorage(this.#repository, this.#runtime, options.tenantId, entityId, entity);
-        return RepositoryEntities.loaded(entity, stored, commits, events, storageInput, this.#repository.stateSchema, entityId);
+        const { commits, events, agentHistory, storageInput } = RepositoryEntities.bindStorage(this.#repository, this.#runtime, options.tenantId, entityId, entity);
+        return RepositoryEntities.loaded(entity, stored, commits, events, agentHistory, storageInput, this.#repository.stateSchema, entityId);
     }
     /**
      * Stores changed Process Manager state or produced Events under one Version.
      *
      * @param loaded Process Manager and commit storage.
      * @param options Stand tenant selection.
-     * @param events Produced or diagnostic Events to retain when configured.
+     * @param diagnostics Input and produced Events to retain when configured.
+     * @param producedEvents Delivery Events to save before current state.
      * @returns `true` after a successful commit or unchanged no-op.
      */
-    async commit(loaded, options, events) {
+    async commit(loaded, options, diagnostics, producedEvents) {
         const version = RepositoryEntities.repositoryVersion(loaded.entity);
         const priorNumber = loaded.current?.version?.number ?? 0;
         if (version.number === priorNumber) {
-            await this.#appendUnchangedDiagnostics(loaded, events);
+            await this.#appendUnchangedDiagnostics(loaded, diagnostics);
+            const store = new EventStore(this.#runtime.context, this.#runtime.storageFactory);
+            try {
+                await store.appendAll(producedEvents);
+            }
+            finally {
+                store.close();
+            }
+            await this.#appendAgentEvents(loaded, producedEvents);
             return true;
         }
         const entityId = loaded.entity.id;
         const state = RepositoryEntities.repositoryState(loaded.entity);
         const lifecycle = RepositoryEntities.repositoryLifecycle(loaded.entity);
         const deferred = await standAccess.deferUpdate(this.#runtime.stand, this.#repository.stateSchema, state, RepositoryStand.standUpdateOptions(options.tenantId, version, lifecycle), this.#repository.metadata);
-        await this.#storeProcessManagerRecord(loaded, entityId, events, deferred);
-        this.#notifyProcessManager(deferred, events);
+        await this.#storeProcessManagerRecord(loaded, entityId, diagnostics, producedEvents, deferred);
+        this.#notifyProcessManager(deferred, diagnostics);
+        await this.#appendAgentEvents(loaded, producedEvents);
         return true;
     }
+    /**
+     * Stores original envelopes emitted by an Agent under its repository.
+     *
+     * @param loaded Restored Agent with history storage.
+     * @param events Emitted domain Event envelopes.
+     * @returns Completion after every append.
+     */
+    async #appendAgentEvents(loaded, events) {
+        if (this.#repository.entityFamily !== "agent")
+            return;
+        const history = loaded.agentHistory;
+        if (history === undefined)
+            throw new Error("Agent history storage is required.");
+        const id = loaded.entity.id;
+        for (const event of events) {
+            if (event.context?.timestamp === undefined)
+                throw new Error("Agent emitted Event requires its original timestamp.");
+            await history.append(id, create(AgentHistoryEntrySchema, {
+                occurredAt: event.context.timestamp,
+                item: { case: "domainEvent", value: event },
+            }));
+        }
+    }
     /**
      * Writes configured Process Manager diagnostics without storing unchanged state.
      *
@@ -1698,13 +2094,14 @@ class ProcessManagerExecutionSupport {
      *
      * @param loaded Process Manager and commit storage.
      * @param entityId Process Manager identifier.
-     * @param events Diagnostic Events to retain when configured.
+     * @param diagnostics Diagnostic Events to retain when configured.
+     * @param producedEvents Delivery Events to save before current state.
      * @param deferred Stand update to notify or cancel.
      * @returns Completion after durable persistence.
      */
-    async #storeProcessManagerRecord(loaded, entityId, events, deferred) {
+    async #storeProcessManagerRecord(loaded, entityId, diagnostics, producedEvents, deferred) {
         try {
-            await this.#commitProcessManagerRecord(loaded, entityId, events, deferred);
+            await this.#commitProcessManagerRecord(loaded, entityId, diagnostics, producedEvents, deferred);
             entityStateHistoryCaches.get(loaded.entity)?.clear();
         }
         catch (error) {
@@ -1717,11 +2114,12 @@ class ProcessManagerExecutionSupport {
      *
      * @param loaded Loaded Process Manager and commit storage.
      * @param entityId Process Manager identifier.
-     * @param events Diagnostic Events to retain when configured.
+     * @param diagnostics Diagnostic Events to retain when configured.
+     * @param producedEvents Delivery Events to save before current state.
      * @param deferred Stand update containing the prepared record.
      * @returns Completion after the storage commit.
      */
-    #commitProcessManagerRecord(loaded, entityId, events, deferred) {
+    #commitProcessManagerRecord(loaded, entityId, diagnostics, producedEvents, deferred) {
         const history = RepositoryStorage.historyConfiguration(this.#repository);
         const record = RepositoryStand.preparedRecord(this.#repository, deferred, entityId);
         return loaded.commits.commit({
@@ -1731,8 +2129,9 @@ class ProcessManagerExecutionSupport {
             next: record,
             ...(history.stateHistory ? { states: [record] } : {}),
             ...(history.processManagerEventHistory
-                ? { diagnostics: events.map((event) => clone(EventSchema, event)) }
+                ? { diagnostics: diagnostics.map((event) => clone(EventSchema, event)) }
                 : {}),
+            events: producedEvents.map((event) => clone(EventSchema, event)),
         });
     }
     /**
@@ -1751,7 +2150,1271 @@ class ProcessManagerExecutionSupport {
     }
 }
 /**
- * Executes a routed Process Manager Command and publishes its results.
+ * Advances admitted Agent work only under a provider claim and exact record fence.
+ */
+const AgentExecutionRunner = {
+    /**
+     * Processes one accepted Agent transition under its provider claim.
+     *
+     * @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.
+     */
+    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);
+    },
+    /**
+     * Updates and releases one exact claim while its saved work advances.
+     *
+     * @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.
+     */
+    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();
+        }
+    },
+    /**
+     * Handles transient failures while giving expired work a final audit.
+     *
+     * @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.
+     */
+    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;
+    },
+    /**
+     * Processes one claimed record according to its saved completion or request state.
+     *
+     * @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.
+     */
+    deadlineExpired(record) {
+        const deadline = record.started?.deadline;
+        return (deadline !== undefined &&
+            Time.currentTimeMillis() >=
+                Number(deadline.seconds) * 1_000 + Math.floor(deadline.nanos / 1_000_000));
+    },
+    /**
+     * Checks for a dispatched model reservation whose response was never saved.
+     *
+     * @param record Durable Agent execution record.
+     * @returns Whether the checked condition holds.
+     */
+    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));
+        });
+    },
+    /**
+     * 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(),
+        });
+        return AgentInteractionEvents.envelope(accepted, runtime.signalMetadata, accepted.recipientId, AgentInvocationTerminatedSchema, payload);
+    },
+    /**
+     * Returns IDs only for physically reserved model requests without saved outcomes.
+     *
+     * @param record Durable execution journal.
+     * @returns Original attempt IDs for unresolved physical sends.
+     */
+    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]
+                : [];
+        });
+    },
+    /**
+     * 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]
+                : [];
+        });
+    },
+    /**
+     * 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;
+    },
+    /**
+     * Rejects a Command draft and persists only its declared rejection.
+     *
+     * @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.
+     */
+    async outputsOrRejection(repository, runtime, tenantId, session, entity, accepted, handlers, entityId, initialVersion) {
+        try {
+            return await this.produceOutputs(repository, runtime, tenantId, session, entity, accepted, handlers, entityId, initialVersion);
+        }
+        catch (error) {
+            if (!RejectionThrowable.is(error) || accepted.signal.case !== "command")
+                throw error;
+            const handler = 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)];
+        }
+    },
+    /**
+     * 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.
+     *
+     * @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.
+     */
+    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))
+                continue;
+            await AgentModelSelection.authorizeSelection(runtime.ai, policy, scope, selected, session.signal, deadlineMs);
+        }
+    },
+    /**
+     * 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)];
+        });
+    },
+    /**
+     * Builds one effective selection change with its original causal context.
+     *
+     * @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.
+     */
+    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);
+    },
+    /**
+     * Reads an explicit model selection, including inherited defaults as absence.
+     *
+     * @param preferences Current Agent instance model preferences.
+     * @param kind Generation or decision model kind.
+     * @returns Selected deployment reference, or inherited default.
+     */
+    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;
+    },
+    /**
+     * Stores only committed domain Events in the Agent's emitted history.
+     *
+     * @param outputs Prepared outgoing domain signals.
+     * @returns Committed domain Event rows for Agent history.
+     */
+    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 },
+                }),
+            ];
+        });
+    },
+    /**
+     * Commits changed Entity state with the already prepared execution image.
+     *
+     * @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.
+     */
+    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);
+    },
+    /**
+     * Applies the deferred Stand image only after fenced provider completion.
+     *
+     * @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.
+     */
+    async commitDeferred(repository, session, loaded, entityId, makeNext, historyEntries, deferred, prepared) {
+        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;
+        }
+        catch (error) {
+            deferred.cancel();
+            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.
+     *
+     * @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.
+     */
+    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;
+        }
+        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);
+        }
+    },
+    /**
+     * Sends one saved Command under the current claim and records its acknowledgement.
+     *
+     * @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.
+     */
+    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);
+    },
+    /**
+     * Returns the typed original ID of one completed outgoing Command.
+     *
+     * @param output Prepared outgoing Command.
+     * @returns Original durable Command ID.
+     */
+    outputKey(output) {
+        if (output.command?.id !== undefined)
+            return output.command.id;
+        throw new Error("Agent outgoing Command requires its original typed ID.");
+    },
+    /**
+     * Validates every stored binding against the current generated selectors.
+     *
+     * @param repository Agent registration.
+     * @param accepted Immutable source and ordered bindings.
+     * @returns Current matching handler metadata.
+     */
+    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.");
+        }
+        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);
+        }
+        return session.record();
+    },
+    /**
+     * Writes one selected model under the current Agent claim.
+     *
+     * @param session Fenced Agent execution session.
+     * @param selected Authorized deployment and connection identity.
+     * @returns When the selection is durable.
+     */
+    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) }),
+        });
+    },
+    /**
+     * Creates a genuine source-specific dispatch System Event before the handler.
+     *
+     * @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.
+     */
+    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.");
+    },
+    /**
+     * Invokes saved Command or Event bindings inside one Entity transaction.
+     *
+     * @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.
+     */
+    async invoke(repository, runtime, tenantId, session, entity, accepted, handlers) {
+        transactionalEntityAccess.start(entity);
+        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;
+        }
+        catch (error) {
+            transactionalEntityAccess.rollback(entity);
+            throw error;
+        }
+    },
+    /**
+     * Validates the transaction result before Agent output completion.
+     *
+     * @param entity Loaded recipient Entity instance.
+     * @returns When the fenced repository operation completes.
+     */
+    async commitInvokedEntity(entity) {
+        const commit = await commitFenced(entity, (current) => transactionalEntityAccess.commit(current));
+        if (commit.status === "rejected")
+            throw new TransitionValidationError(commit.validation.error);
+    },
+    /**
+     * Binds named AI and history reads around one generated handler call.
+     *
+     * @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();
+        }
+    },
+    /**
+     * Binds Agent AI, indexed history and routed projection queries for one handler.
+     *
+     * @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;
+        }
+    },
+    /**
+     * Creates one handler-scoped facade from its accepted model policy.
+     *
+     * @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));
+    },
+    /**
+     * Invokes one selected generated handler and validates its declared results.
+     *
+     * @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.
+     */
+    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;
+    },
+    /**
+     * Reads the original invocation deadline before starting an application callback.
+     *
+     * @param session Current fenced execution session.
+     * @returns Absolute saved deadline in milliseconds.
+     */
+    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);
+    },
+    /**
+     * Awaits an application handler within its saved deadline and current claim.
+     *
+     * @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.
+     */
+    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();
+            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);
+        }
+    },
+};
+/**
+ * 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.
  */
 class ProcessManagerCommandExecution {
     #repository;
@@ -1764,7 +3427,7 @@ class ProcessManagerCommandExecution {
      *
      * @param repository Process Manager repository receiving the Command.
      * @param routing Registered Command routes and schemas.
-     * @param runtime Built context services.
+     * @param runtime Built Bounded Context services.
      * @param command Source Command to execute.
      */
     constructor(repository, routing, runtime, command) {
@@ -1787,7 +3450,7 @@ class ProcessManagerCommandExecution {
             return undefined;
         const tenantOptions = RepositoryTenants.commandStandOptions(this.#runtime.context, this.#command);
         const loaded = await this.#support.load(intake.route.entityId, tenantOptions);
-        this.#publishDispatch(intake.route.entityId);
+        await this.#publishDispatch(loaded, intake.route.entityId);
         try {
             const produced = await this.#invoke(loaded.entity, intake.assignee, intake.message, tenantOptions.tenantId);
             return await this.#commitAndPublish(loaded, tenantOptions, intake, produced);
@@ -1800,12 +3463,29 @@ class ProcessManagerCommandExecution {
         }
     }
     /**
-     * Publishes a best-effort Command dispatch diagnostic.
+     * Persists required Agent dispatch history before the handler runs.
+     * Process Manager diagnostic publication remains best effort.
      *
-     * @param entityId Target Process Manager identifier.
+     * @param loaded Entity with mandatory Agent history when applicable.
+     * @param entityId Target Process Manager or Agent identifier.
+     * @returns Completion after the Agent audit append and publication.
      */
-    #publishDispatch(entityId) {
-        HandlerDispatchPublisher.command(this.#runtime, this.#repository, this.#command, entityId);
+    async #publishDispatch(loaded, entityId) {
+        if (this.#repository.entityFamily !== "agent") {
+            HandlerDispatchPublisher.command(this.#runtime, this.#repository, this.#command, entityId);
+            return;
+        }
+        const history = loaded.agentHistory;
+        if (history === undefined)
+            throw new Error("Agent history storage is required.");
+        const event = HandlerDispatchPublisher.commandEvent(this.#runtime, this.#repository, this.#command, entityId);
+        if (event.context?.timestamp === undefined)
+            throw new Error("Agent System Event requires its original timestamp.");
+        await history.append(entityId, create(AgentHistoryEntrySchema, {
+            occurredAt: event.context.timestamp,
+            item: { case: "systemEvent", value: event },
+        }));
+        HandlerDispatchPublisher.publishCommand(this.#runtime, event);
     }
     /**
      * Decodes a registered Command and finds its assignee.
@@ -1833,7 +3513,7 @@ class ProcessManagerCommandExecution {
     async #commitAndPublish(loaded, tenantOptions, intake, producedSignals) {
         const commands = this.#commandOutputs(intake.assignee, producedSignals);
         const events = this.#eventOutputs(intake.assignee, producedSignals, intake.route.entityId, RepositoryEntities.priorVersion(loaded.current));
-        const committed = await this.#support.commit(loaded, tenantOptions, events);
+        const committed = await this.#support.commit(loaded, tenantOptions, events, events);
         if (!committed)
             return undefined;
         this.#publishChangedState(loaded, intake.route.entityId);
@@ -1895,7 +3575,7 @@ class ProcessManagerCommandExecution {
     /**
      * Binds query access for one Command handler invocation.
      *
-     * @param entity Process Manager instance.
+     * @param entity Entity instance.
      * @param assignee Registered Command handler.
      * @param message Decoded Command message.
      * @param tenantId Tenant for query reads, when present.
@@ -1913,7 +3593,7 @@ class ProcessManagerCommandExecution {
     /**
      * Invokes a Command handler and checks delivery before the Entity transaction commits.
      *
-     * @param entity Process Manager instance to mutate.
+     * @param entity Entity instance to mutate.
      * @param assignee Registered Command handler.
      * @param message Decoded Command message.
      * @returns Validated handler signals after commit.
@@ -1924,7 +3604,7 @@ 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 Process Manager command handlers must return a signal.");
+                throw 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") {
@@ -1938,11 +3618,11 @@ class ProcessManagerCommandExecution {
         }
     }
     /**
-     * Binds assignment results as Process Manager Events.
+     * Binds assignment results as Entity Events.
      *
      * @param produced Domain Event messages from the handler.
-     * @param entityId Target Process Manager identifier.
-     * @param version Process Manager Version before this dispatch.
+     * @param entityId Target Entity identifier.
+     * @param version Entity Version before this dispatch.
      * @returns Frozen Event envelope list.
      */
     #bindProducedEvents(produced, entityId, version) {
@@ -1952,15 +3632,15 @@ class ProcessManagerCommandExecution {
      * Packs one declared Event with source and producer context.
      *
      * @param signal Domain Event message to pack.
-     * @param entityId Target Process Manager identifier.
-     * @param version Process Manager Version before this dispatch.
+     * @param entityId Target Entity identifier.
+     * @param version Entity Version before this dispatch.
      * @returns Bound Event envelope.
      */
     #bindProducedEvent(signal, entityId, version) {
         const typeName = EntityInvocation.messageTypeName(signal);
         const schema = this.#routing.producedEventSchemas.find((candidate) => candidate.typeName === typeName);
         if (schema === undefined) {
-            throw new Error(`Repository process-manager execution cannot pack event message "${typeName}".`);
+            throw new Error(`Repository Entity handler cannot pack Event message "${typeName}".`);
         }
         const metadata = this.#runtime.signalMetadata.eventFromCommand(this.#command, {
             version: version.number,
@@ -1982,7 +3662,7 @@ class ProcessManagerCommandExecution {
             const typeName = EntityInvocation.messageTypeName(signal);
             const schema = this.#routing.producedCommandSchemas.find((candidate) => candidate.typeName === typeName);
             if (schema === undefined) {
-                throw new Error(`Repository process-manager execution cannot pack command message "${typeName}".`);
+                throw new Error(`Repository Entity handler cannot pack Command message "${typeName}".`);
             }
             const metadata = this.#runtime.signalMetadata.commandFromCommand(this.#command);
             return create(CommandSchema, {
@@ -2013,12 +3693,12 @@ class ProcessManagerCommandExecution {
     #postEvents(events) {
         for (const event of events) {
             // spine-log-boundary: server.repository_event_follow_up
-            void this.#runtime.publisher.publishEvent(event);
+            void this.#runtime.publisher.publishReactorEvent(event);
         }
     }
 }
 /**
- * Runs Process Manager Event handlers and persists their results.
+ * Runs Process Manager or Agent Event handlers and persists their results.
  */
 class ProcessManagerEventExecution {
     #repository;
@@ -2027,9 +3707,9 @@ class ProcessManagerEventExecution {
     #event;
     #support;
     /**
-     * Captures Process Manager routing, runtime, and source Event.
+     * Captures Entity routing, runtime, and source Event.
      *
-     * @param repository Process Manager repository receiving the Event.
+     * @param repository Entity repository receiving the Event.
      * @param routing Registered Event routes and schemas.
      * @param runtime Built context services.
      * @param event Source Event to execute.
@@ -2042,7 +3722,7 @@ class ProcessManagerEventExecution {
         this.#support = new ProcessManagerExecutionSupport(repository, runtime);
     }
     /**
-     * Delivers a routed Event to the durable Process Manager inbox.
+     * Delivers a routed Event to the durable Entity inbox.
      *
      * @param acceptedRoute Route accepted before dispatch.
      * @returns Completion after inbox handoff.
@@ -2062,7 +3742,7 @@ class ProcessManagerEventExecution {
     /**
      * Delivers a routed Event for one target under the duplicate-dispatch guard.
      *
-     * @param entityId Target Process Manager identifier.
+     * @param entityId Target Entity identifier.
      * @param acceptedRoute Route accepted before replay.
      * @returns Completion after guarded target execution.
      */
@@ -2099,7 +3779,7 @@ class ProcessManagerEventExecution {
     /**
      * Invokes handlers, commits state, and publishes resulting Events and Commands.
      *
-     * @param entityId Target Process Manager identifier.
+     * @param entityId Target Entity identifier.
      * @param intake Decoded Event and matching handlers.
      * @returns Completion after accepted results are published.
      */
@@ -2113,7 +3793,7 @@ class ProcessManagerEventExecution {
             DispatchGuards.guardedJournalEvent(this.#repository, this.#event, entityId),
             ...events,
         ];
-        const committed = await this.#support.commit(loaded, tenantOptions, diagnostics);
+        const committed = await this.#support.commit(loaded, tenantOptions, diagnostics, events);
         if (!committed)
             return;
         this.#publishChangedState(loaded, entityId);
@@ -2121,10 +3801,10 @@ class ProcessManagerEventExecution {
         await this.#postCommands(commands);
     }
     /**
-     * Publishes a state-change System Event when the Process Manager changed.
+     * Publishes a state-change System Event when the Entity changed.
      *
-     * @param loaded Process Manager before and after handling.
-     * @param entityId Target Process Manager identifier.
+     * @param loaded Entity before and after handling.
+     * @param entityId Target Entity identifier.
      */
     #publishChangedState(loaded, entityId) {
         if (!RepositoryEntities.repositoryChanged(loaded.entity))
@@ -2153,8 +3833,8 @@ class ProcessManagerEventExecution {
     /**
      * Invokes Event handlers in one transaction with temporary query access.
      *
-     * @param entityId Target Process Manager identifier.
-     * @param entity Process Manager instance.
+     * @param entityId Target Entity identifier.
+     * @param entity Entity instance.
      * @param intake Decoded Event and matching handlers.
      * @param tenantId Tenant for query reads, when present.
      * @returns Validated Command and Event message lists.
@@ -2184,8 +3864,8 @@ class ProcessManagerEventExecution {
     /**
      * Invokes reactors and Command producers, collecting their separate outputs.
      *
-     * @param entityId Target Process Manager identifier.
-     * @param entity Process Manager instance.
+     * @param entityId Target Entity identifier.
+     * @param entity Entity instance.
      * @param intake Decoded Event and matching handlers.
      * @param context Copied source Event context.
      * @param events Output list for Event messages.
@@ -2193,15 +3873,23 @@ class ProcessManagerEventExecution {
      * @returns Completion after matching handlers run.
      */
     async #invokeEventHandlers(entityId, entity, intake, context, events, commands) {
-        if (intake.reactors.length > 0)
-            HandlerDispatchPublisher.reactor(this.#runtime, this.#repository, this.#event, entityId);
+        if (intake.reactors.length > 0) {
+            if (this.#repository.entityFamily === "agent") {
+                const diagnostic = HandlerDispatchPublisher.reactorEvent(this.#runtime, this.#repository, this.#event, entityId);
+                await AgentHistoryReads.appendSystem(entity, diagnostic);
+                HandlerDispatchPublisher.publishReactor(this.#runtime, diagnostic);
+            }
+            else {
+                HandlerDispatchPublisher.reactor(this.#runtime, this.#repository, this.#event, entityId);
+            }
+        }
         await this.#invokeHandlersInto(entity, intake.reactors, intake.message, context, events);
         await this.#invokeHandlersInto(entity, intake.commanders, intake.message, context, commands);
     }
     /**
      * Invokes each selected handler and appends its declared results.
      *
-     * @param entity Process Manager instance.
+     * @param entity Entity instance.
      * @param handlers Handler registrations to invoke.
      * @param message Decoded source Event message.
      * @param context Copied source Event context.
@@ -2219,7 +3907,7 @@ class ProcessManagerEventExecution {
     /**
      * Checks delivery immediately before the Entity transaction commits and raises transition rejection.
      *
-     * @param entity Process Manager instance to commit.
+     * @param entity Entity instance to commit.
      * @param producedEvents Whether handlers produced Events.
      * @returns Completion after a successful commit.
      */
@@ -2229,11 +3917,11 @@ class ProcessManagerEventExecution {
             throw new TransitionValidationError(commit.validation.error);
     }
     /**
-     * Binds reactor results as Process Manager Events.
+     * Binds reactor results as Entity Events.
      *
      * @param produced Domain Event messages from handlers.
-     * @param entityId Target Process Manager identifier.
-     * @param version Process Manager Version before this dispatch.
+     * @param entityId Target Entity identifier.
+     * @param version Entity Version before this dispatch.
      * @returns Frozen Event envelope list.
      */
     #bindProducedEvents(produced, entityId, version) {
@@ -2243,15 +3931,15 @@ class ProcessManagerEventExecution {
      * Packs one declared Event with source and producer context.
      *
      * @param signal Domain Event message to pack.
-     * @param entityId Target Process Manager identifier.
-     * @param version Process Manager Version before this dispatch.
+     * @param entityId Target Entity identifier.
+     * @param version Entity Version before this dispatch.
      * @returns Bound Event envelope.
      */
     #bindProducedEvent(signal, entityId, version) {
         const typeName = EntityInvocation.messageTypeName(signal);
         const schema = this.#routing.producedEventSchemas.find((candidate) => candidate.typeName === typeName);
         if (schema === undefined) {
-            throw new Error(`Repository process-manager execution cannot pack event message "${typeName}".`);
+            throw new Error(`Repository Entity handler cannot pack Event message "${typeName}".`);
         }
         const metadata = this.#runtime.signalMetadata.eventFromEvent(this.#event, {
             version: version.number,
@@ -2273,7 +3961,7 @@ class ProcessManagerEventExecution {
             const typeName = EntityInvocation.messageTypeName(signal);
             const schema = this.#routing.producedCommandSchemas.find((candidate) => candidate.typeName === typeName);
             if (schema === undefined) {
-                throw new Error(`Repository process-manager execution cannot pack command message "${typeName}".`);
+                throw new Error(`Repository Entity handler cannot pack Command message "${typeName}".`);
             }
             const metadata = this.#runtime.signalMetadata.commandFromEvent(this.#event);
             return create(CommandSchema, {
@@ -2302,7 +3990,7 @@ class ProcessManagerEventExecution {
     #postEvents(events) {
         for (const event of events) {
             // spine-log-boundary: server.process_manager_event_follow_up
-            void this.#runtime.publisher.publishEvent(event);
+            void this.#runtime.publisher.publishReactorEvent(event);
         }
     }
 }
@@ -2323,7 +4011,7 @@ const RepositoryIdentity = {
         const displayName = RepositoryIdentity.entityTypeName(entityType);
         const schema = RepositoryIdentity.readRepositorySchemaOption(options, displayName, entityFamily);
         const metadata = RepositoryIdentity.describeRepositoryEntityMetadata(displayName, entityFamily, schema);
-        if (metadata.kind !== entityFamily) {
+        if (metadata.kind !== (entityFamily === "agent" ? "entity" : entityFamily)) {
             throw new RepositoryIdentityError("ENTITY_SCHEMA_KIND_MISMATCH", `Repository entity type "${displayName}" does not match the supplied state schema.`);
         }
         if (options.stateUpdateRouting !== undefined && entityFamily !== "projection") {
@@ -2340,34 +4028,34 @@ const RepositoryIdentity = {
     requireEntityType(options) {
         if (!RepositoryIdentity.isRepositoryOptionsObject(options)) {
             throw new RepositoryIdentityError("UNSUPPORTED_ENTITY_TYPE", "Repository options must be a non-null object with an entity type class constructor " +
-                "extending Aggregate, Projection, or ProcessManager.");
+                "extending Aggregate, Projection, ProcessManager, or Agent.");
         }
         const entityType = RepositoryIdentity.readEntityTypeOption(options);
         if (typeof entityType !== "function" || !RepositoryIdentity.isClassConstructor(entityType)) {
             throw new RepositoryIdentityError("UNSUPPORTED_ENTITY_TYPE", `Repository entity type "${RepositoryIdentity.entityTypeName(entityType)}" must be a class constructor ` +
-                "extending Aggregate, Projection, or ProcessManager.");
+                "extending Aggregate, Projection, ProcessManager, or Agent.");
         }
         return entityType;
     },
     /**
-     * Validates and returns Aggregate, Projection, or Process Manager inheritance.
+     * Validates and returns Aggregate, Projection, Process Manager, or Agent inheritance.
      *
      * @param entityType Validated class constructor.
-     * @returns Aggregate, Projection, or Process Manager.
+     * @returns Aggregate, Projection, Process Manager, or Agent.
      */
     requireEntityFamily(entityType) {
         const family = RepositoryIdentity.resolveRepositoryEntityFamily(entityType);
         if (family !== undefined)
             return family;
         throw new RepositoryIdentityError("UNSUPPORTED_ENTITY_TYPE", `Repository entity type "${RepositoryIdentity.entityTypeName(entityType)}" must extend ` +
-            "Aggregate, Projection, or ProcessManager.");
+            "Aggregate, Projection, ProcessManager, or Agent.");
     },
     /**
      * Creates a frozen identity snapshot from validated Entity metadata.
      *
      * @typeParam EntityType Concrete Entity constructor represented by the snapshot.
      * @param entityType Entity constructor.
-     * @param entityFamily Aggregate, Projection, or Process Manager family.
+     * @param entityFamily Aggregate, Projection, Process Manager, or Agent family.
      * @param metadata Descriptor-derived state metadata.
      * @returns Copy-safe repository identity snapshot.
      */
@@ -2421,7 +4109,7 @@ const RepositoryIdentity = {
         }
         catch {
             throw new RepositoryIdentityError("UNSUPPORTED_ENTITY_TYPE", "Repository options entityType must be readable and resolve to a class constructor " +
-                "extending Aggregate, Projection, or ProcessManager.");
+                "extending Aggregate, Projection, ProcessManager, or Agent.");
         }
     },
     /**
@@ -2471,22 +4159,21 @@ const RepositoryIdentity = {
             return undefined;
         }
         const runtimeEntityType = entityType;
-        if (RepositoryIdentity.hasEntityFamilyInheritance(runtimeEntityType, Aggregate, Aggregate.prototype)) {
+        if (RepositoryIdentity.hasEntityFamilyInheritance(runtimeEntityType, Aggregate, Aggregate.prototype))
             return "aggregate";
-        }
-        if (RepositoryIdentity.hasEntityFamilyInheritance(runtimeEntityType, Projection, Projection.prototype)) {
+        if (RepositoryIdentity.hasEntityFamilyInheritance(runtimeEntityType, Projection, Projection.prototype))
             return "projection";
-        }
-        if (RepositoryIdentity.hasEntityFamilyInheritance(runtimeEntityType, ProcessManager, ProcessManager.prototype)) {
+        if (RepositoryIdentity.hasEntityFamilyInheritance(runtimeEntityType, ProcessManager, ProcessManager.prototype))
             return "process-manager";
-        }
+        if (RepositoryIdentity.hasEntityFamilyInheritance(runtimeEntityType, Agent, Agent.prototype))
+            return "agent";
         return undefined;
     },
     /**
      * Checks constructor and prototype inheritance against an Entity family.
      *
      * @param entityType Candidate constructor.
-     * @param familyConstructor Aggregate, Projection, or Process Manager constructor.
+     * @param familyConstructor Entity family constructor.
      * @param familyPrototype Prototype for the same family.
      * @returns Whether both inheritance paths match.
      */
@@ -2625,7 +4312,23 @@ const EntityInvocation = {
         if (typeof method !== "function") {
             throw new TypeError(`Repository entity execution requires method "${methodName}".`);
         }
-        return Reflect.apply(method, entity, parameterCount === 2 ? [message, context] : [message]);
+        let result;
+        try {
+            result = Reflect.apply(method, entity, parameterCount === 2 ? [message, context] : [message]);
+        }
+        catch (error) {
+            receptionObservation.recordHandlerFailure(error);
+            throw error;
+        }
+        if (result !== null &&
+            (typeof result === "object" || typeof result === "function") &&
+            typeof result.then === "function") {
+            return Promise.resolve(result).catch((error) => {
+                receptionObservation.recordHandlerFailure(error);
+                throw error;
+            });
+        }
+        return result;
     },
     /**
      * Copies a Command context or creates an empty context when absent.
@@ -2697,7 +4400,36 @@ const RepositoryEntities = {
         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);
-        return { commits: storage.commits, events: storage.events, storageInput };
+        if (repository.entityFamily === "agent")
+            this.bindAgentHistory(entity, entityId, storageInput, storage.agentHistory);
+        return {
+            commits: storage.commits,
+            events: storage.events,
+            ...(storage.agentHistory === undefined ? {} : { agentHistory: storage.agentHistory }),
+            storageInput,
+        };
+    },
+    /**
+     * Attaches the indexed history port to one restored Agent.
+     *
+     * @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) {
+        if (history === undefined)
+            throw new Error("Agent history storage is required.");
+        AgentHistoryReads.bind(entity, {
+            storage: history,
+            entityId,
+            scope: {
+                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.
@@ -2729,15 +4461,17 @@ const RepositoryEntities = {
      * @param stored Prior Stand snapshot, when present.
      * @param commits Durable commit storage.
      * @param events Durable diagnostic Event history.
+     * @param agentHistory Mandatory Agent history when this is an Agent.
      * @param storageInput Entity storage specification.
      * @param schema Entity state schema.
      * @param entityId Entity identifier.
      * @returns The loaded Entity and prior record.
      */
-    loaded(entity, stored, commits, events, storageInput, schema, entityId) {
+    loaded(entity, stored, commits, events, agentHistory, storageInput, schema, entityId) {
         return Object.freeze({
             commits,
             events,
+            ...(agentHistory === undefined ? {} : { agentHistory }),
             current: stored === undefined
                 ? undefined
                 : EntityRecords.pack(schema, entityId, stored.state, stored.versionMessage, {
@@ -2863,8 +4597,30 @@ const RepositorySignals = {
      * @returns Deferred rejection Event publication.
      */
     postRejectionEvent(runtime, repository, command, entityId, rejection) {
+        const event = this.rejectionEvent(runtime, repository, command, entityId, rejection);
+        return async () => {
+            try {
+                // spine-log-boundary: server.repository_rejection_follow_up
+                await runtime.publisher.publishRejectionEvent(event);
+            }
+            catch (error) {
+                runtime.publisher.reportFailure("event", event, error);
+            }
+        };
+    },
+    /**
+     * Creates the original declared rejection envelope without publishing it.
+     *
+     * @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 rejection Declared rejection from the selected handler.
+     * @returns Original declared-rejection Event envelope.
+     */
+    rejectionEvent(runtime, repository, command, entityId, rejection) {
         const metadata = runtime.signalMetadata.eventFromCommand(command, {});
-        const event = create(EventSchema, {
+        return create(EventSchema, {
             id: metadata.id,
             message: AnyMessages.pack(rejection.schema, rejection.messageThrown()),
             context: create(EventContextSchema, {
@@ -2875,15 +4631,6 @@ const RepositorySignals = {
                 }),
             }),
         });
-        return async () => {
-            try {
-                // spine-log-boundary: server.repository_rejection_follow_up
-                await runtime.publisher.publishRejectionEvent(event);
-            }
-            catch (error) {
-                runtime.publisher.reportFailure("event", event, error);
-            }
-        };
     },
     /**
      * Validates a nonempty Command ID for Event origin metadata.
@@ -3200,20 +4947,40 @@ class HandlerDispatchPublishing {
      */
     command(runtime, repository, command, entityId) {
         try {
-            const context = runtime.signalMetadata.eventContext({
-                origin: runtime.signalMetadata.originFromCommand(command),
-            });
-            const event = create(EventSchema, {
-                id: runtime.signalMetadata.eventId(),
-                message: AnyMessages.pack(EntityLog.CommandDispatchedToHandlerSchema, this.#message(repository, command, entityId, context.timestamp)),
-                context,
-            });
-            this.#post(runtime, EntityLog.CommandDispatchedToHandlerSchema, event);
+            this.publishCommand(runtime, this.commandEvent(runtime, repository, command, entityId));
         }
         catch (error) {
             runtime.publisher.reportFailure("event", create(EventSchema), error);
         }
     }
+    /**
+     * Builds the genuine Command dispatch diagnostic before its publication.
+     *
+     * @param runtime Bounded Context signal metadata.
+     * @param repository Receiving repository.
+     * @param command Source Command.
+     * @param entityId Target Entity identifier.
+     * @returns Original System Event envelope.
+     */
+    commandEvent(runtime, repository, command, entityId) {
+        const context = runtime.signalMetadata.eventContext({
+            origin: runtime.signalMetadata.originFromCommand(command),
+        });
+        return create(EventSchema, {
+            id: runtime.signalMetadata.eventId(),
+            message: AnyMessages.pack(EntityLog.CommandDispatchedToHandlerSchema, this.#message(repository, command, entityId, context.timestamp)),
+            context,
+        });
+    }
+    /**
+     * Sends the exact System envelope already retained for an Agent.
+     *
+     * @param runtime Bounded Context publication services.
+     * @param event Original System Event envelope.
+     */
+    publishCommand(runtime, event) {
+        this.#post(runtime, EntityLog.CommandDispatchedToHandlerSchema, event);
+    }
     /**
      * Publishes a best-effort EventDispatchedToSubscriber diagnostic.
      *
@@ -3236,6 +5003,34 @@ class HandlerDispatchPublishing {
     reactor(runtime, repository, event, entityId) {
         this.#publishEvent(runtime, repository, event, entityId, EntityLog.EventDispatchedToReactorSchema);
     }
+    /**
+     * Builds the genuine Event-to-reactor diagnostic with its original envelope.
+     *
+     * @param runtime Bounded Context signal metadata.
+     * @param repository Receiving repository.
+     * @param source Source Event.
+     * @param entityId Target Entity identifier.
+     * @returns Original System Event envelope.
+     */
+    reactorEvent(runtime, repository, source, entityId) {
+        const context = runtime.signalMetadata.eventContext({
+            origin: runtime.signalMetadata.originFromEvent(source),
+        });
+        return create(EventSchema, {
+            id: runtime.signalMetadata.eventId(),
+            message: AnyMessages.pack(EntityLog.EventDispatchedToReactorSchema, this.#eventMessage(EntityLog.EventDispatchedToReactorSchema, repository, source, entityId, context.timestamp)),
+            context,
+        });
+    }
+    /**
+     * Publishes the same Event-to-reactor diagnostic retained by Agent history.
+     *
+     * @param runtime Bounded Context publication services.
+     * @param event Original System Event envelope.
+     */
+    publishReactor(runtime, event) {
+        this.#post(runtime, EntityLog.EventDispatchedToReactorSchema, event);
+    }
     /**
      * Builds and publishes one subscriber or reactor dispatch diagnostic.
      *
@@ -3751,9 +5546,10 @@ const RepositoryHandlers = {
                 throw new RepositoryIdentityError("ENTITY_SCHEMA_KIND_MISMATCH", `Repository entity type "${entityType.name}" does not match the supplied handler metadata.`);
             }
             if (metadata.kind !== "process-manager" &&
+                metadata.kind !== "entity" &&
                 (handlersMetadata.commandSubstitutions.length > 0 ||
                     handlersMetadata.commandReactions.length > 0)) {
-                throw new RepositoryIdentityError("UNSUPPORTED_ENTITY_TYPE", "Only Process Manager repositories support @Command handlers.");
+                throw new RepositoryIdentityError("UNSUPPORTED_ENTITY_TYPE", "Only Process Manager and Agent repositories support @Command handlers.");
             }
         }
     },
@@ -4711,24 +6507,64 @@ const RepositoryStorage = {
      * @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.
      */
-    openEntityStorage(factory, input) {
+    openEntityStorage(factory, input, agent = false) {
         const candidate = factory;
-        if (candidate.createEntityStorage === undefined) {
-            throw new Error("StorageFactory does not provide the required atomic Entity commit storage seam.");
-        }
+        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;
+        }
         return {
             ...entity,
             commits,
+            ...ports,
             close: () => {
+                ports?.agentExecution.close();
+                ports?.agentHistory.close();
                 commits.close();
                 entity.close();
             },
         };
     },
+    /**
+     * Opens both mandatory Agent ports and closes the first if the second fails.
+     *
+     * @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.
+     */
+    openAgentPorts(factory, input) {
+        const agentHistory = 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;
+        }
+    },
     /**
      * Returns one shared Entity storage handle per context and state type.
      *
@@ -4742,7 +6578,7 @@ const RepositoryStorage = {
     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);
+        const handle = RepositoryStorage.openEntityStorage(factory, input, repository.entityFamily === "agent");
         if (handles === undefined) {
             handles = new Map();
             repositoryEntityHandles.set(repository, handles);
@@ -5202,21 +7038,40 @@ const DispatchGuards = {
     async dispatchOnce(repository, runtime, event, entityId, eventId, journalEventId, depth, guard, dispatch) {
         if (guard.completed.has(eventId))
             return;
-        const storage = RepositoryStorage.openEntityStorage(runtime.storageFactory, RepositoryStorage.entityStorageInput(repository, RepositoryTenants.storageContextForEvent(runtime.context, event)));
-        let persisted;
-        try {
-            persisted = await storage.events.backward(entityId, depth);
-        }
-        finally {
-            storage.close();
+        if (repository.entityFamily === "agent") {
+            await dispatch();
+            DispatchGuards.rememberGuardCompletion(guard, eventId, depth);
+            return;
         }
-        if (persisted.some((candidate) => candidate.id?.value === journalEventId)) {
+        if (await this.wasDispatched(repository, runtime, event, entityId, journalEventId, depth)) {
             DispatchGuards.rememberGuardCompletion(guard, eventId, depth);
             return;
         }
         await dispatch();
         DispatchGuards.rememberGuardCompletion(guard, eventId, depth);
     },
+    /**
+     * Finds an already dispatched Process Manager Event in retained diagnostic history.
+     *
+     * @param repository Process Manager repository.
+     * @param runtime Repository storage runtime.
+     * @param event Incoming Event envelope.
+     * @param entityId Target Process Manager identifier.
+     * @param journalEventId Target-specific diagnostic identifier.
+     * @param depth Maximum retained history read.
+     * @returns Whether the Event was already dispatched.
+     */
+    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 {
+            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.
      *
@@ -5461,6 +7316,10 @@ const InboxReplay = {
      * @returns Any Command follow-up work that must wait for Inbox completion.
      */
     async replayPmInbox(repository, routing, message, deliveryTenantId) {
+        if (repository.entityFamily === "agent") {
+            await InboxReplay.replayAgentInbox(repository, routing, message, deliveryTenantId);
+            return undefined;
+        }
         if (message.label === "HANDLE_COMMAND") {
             return await InboxReplay.replayProcessManagerCommand(repository, routing, message, deliveryTenantId);
         }
@@ -5470,6 +7329,152 @@ const InboxReplay = {
         }
         throw new Error(`Entity Inbox replay does not handle "${message.label}" messages.`);
     },
+    /**
+     * Persists selected Agent work before the normal Inbox acknowledges delivery.
+     *
+     * @param repository Agent repository receiving the original signal.
+     * @param routing Registered handler routes and schemas.
+     * @param message Original durable Inbox message.
+     * @param deliveryTenantId Tenant selected by delivery.
+     * @returns When the fenced repository operation completes.
+     */
+    async replayAgentInbox(repository, routing, message, deliveryTenantId) {
+        const runtime = repositoryRuntimes.get(repository);
+        if (runtime === undefined)
+            throw new Error("Agent Inbox replay requires a bound runtime.");
+        if (message.label === "HANDLE_COMMAND") {
+            await InboxReplay.replayAgentCommand(repository, routing, runtime, message, deliveryTenantId);
+            return;
+        }
+        if (message.label !== "REACT_UPON_EVENT")
+            throw new Error(`Agent Inbox replay does not handle "${message.label}" messages.`);
+        await InboxReplay.replayAgentEvent(repository, routing, runtime, message, deliveryTenantId);
+    },
+    /**
+     * Admits a Command using its stored target and registered assignee.
+     *
+     * @param repository Agent repository.
+     * @param routing Registered Command routes.
+     * @param runtime Bounded Context services.
+     * @param message Original Inbox row.
+     * @param tenantId Delivery tenant.
+     * @returns When the fenced repository operation completes.
+     */
+    async replayAgentCommand(repository, routing, runtime, message, tenantId) {
+        const command = InboxMessages.readInboxCommand(message);
+        InboxReplay.validateReplayTenant(runtime.context, tenantId, command);
+        InboxReplay.validateReplayedCommandPayload(routing, command);
+        const route = InboxReplay.replayCommandRoute(repository, routing, message, command);
+        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]);
+    },
+    /**
+     * Admits matching Event handlers from the stored target without rerouting.
+     *
+     * @param repository Agent repository.
+     * @param routing Registered Event routes.
+     * @param runtime Bounded Context services.
+     * @param message Original Inbox row.
+     * @param tenantId Delivery tenant.
+     * @returns When the fenced repository operation completes.
+     */
+    async replayAgentEvent(repository, routing, runtime, message, tenantId) {
+        const event = InboxMessages.readPmInboxEvent(message);
+        InboxReplay.validatePmReplayTenant(runtime.context, tenantId, event);
+        InboxReplay.validateReplayedEventPayload(routing, event, "Agent Inbox replay requires an Event payload.");
+        const route = InboxReplay.replayEventRoute(repository, routing, message, event, "Agent Inbox replay");
+        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);
+    },
+    /**
+     * Restores selected Event and Command reactions from the original payload.
+     *
+     * @param routing Registered generated handler routing metadata.
+     * @param typeName Generated message type name.
+     * @param event Original typed Event envelope.
+     * @returns Generated reactions selected for the accepted Event.
+     */
+    agentEventHandlers(routing, typeName, 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(typeName, value, external),
+            ...routing.commandReactions(typeName, value, external),
+        ];
+    },
+    /**
+     * Opens the actual tenant handle and records a selected invocation before handoff.
+     *
+     * @param repository Registered Agent repository.
+     * @param runtime Bounded Context services including the effective registry.
+     * @param message Durable Inbox receipt.
+     * @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,
+            signal,
+            actor,
+            inbox: message,
+            handlers,
+            codeRevision: revisions.codeRevision,
+            schemaRevision: revisions.schema,
+            policyRevision: revisions.policy,
+        }));
+        runtime.wakeAcceptedAgent(repository, tenantId);
+    },
+    /**
+     * Opens the actual tenant's mandatory execution handle.
+     *
+     * @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.
+     */
+    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;
+    },
+    /**
+     * Records the registered code, schema, and AI policy before Inbox handoff.
+     *
+     * @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),
+        };
+    },
     /**
      * Dispatches a stored Process Manager Command after tenant and payload validation.
      *
@@ -5780,9 +7785,10 @@ const InboxHandoff = {
      * @param runtime Inbox, storage, tenant mode, and delivery strategy.
      * @param command Command envelope to retain and deliver.
      * @returns Completion of Inbox receipt and its selected delivery operation.
+     * @param acceptedRoute Recipient route saved when the signal was accepted.
      */
-    async handoffEntityCommand(repository, runtime, command) {
-        const route = await repository.routeCommand(command);
+    async handoffEntityCommand(repository, runtime, command, acceptedRoute) {
+        const route = acceptedRoute ?? (await repository.routeCommand(command));
         const commandId = RepositorySignals.requireCommandId(command);
         const keepUntil = new Date(Time.currentTimeMillis() + inboxDedupMs);
         const deliveryTenantId = RepositoryTenants.requireCommandTenant(runtime.context, command);
@@ -5903,6 +7909,182 @@ 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.
  */
@@ -5931,12 +8113,13 @@ const RepositoryDispatch = {
      * @returns The dispatcher, or undefined when no Command schema is registered.
      */
     commandDispatcher(repository, routing) {
-        return routing.commandSchemas.length === 0
-            ? undefined
-            : Object.freeze({
-                messageSchemas: () => routing.commandSchemas,
-                dispatch: (command) => RepositoryDispatch.dispatchRepositoryCommand(repository, routing, command),
-            });
+        if (routing.commandSchemas.length === 0)
+            return undefined;
+        const dispatcher = Object.freeze({
+            messageSchemas: () => routing.commandSchemas,
+            dispatch: (command) => RepositoryDispatch.dispatchRepositoryCommand(repository, routing, command),
+        });
+        return SavedDispatcherBindings.command(dispatcher, SavedRepositoryDispatch.commandBinding(repository, routing));
     },
     /**
      * Creates an Event dispatcher that preserves routes computed during acceptance.
@@ -5961,7 +8144,8 @@ const RepositoryDispatch = {
                 return RepositoryDispatch.dispatchRepositoryEvent(repository, routing, event, route);
             },
         });
-        return EventDispatcherOriginSchemas.define(dispatcher, routing.domesticEventSchemas, routing.externalEventSchemas);
+        const originAware = EventDispatcherOriginSchemas.define(dispatcher, routing.domesticEventSchemas, routing.externalEventSchemas);
+        return originAware;
     },
     /**
      * Creates a system-Event dispatcher for registered Entity-state subscriptions.
@@ -6010,7 +8194,9 @@ const RepositoryDispatch = {
      * @returns The Inbox target and supported operation labels, when applicable.
      */
     createEntityInboxTarget(repository, routing) {
-        if ((repository.entityFamily !== "aggregate" && repository.entityFamily !== "process-manager") ||
+        if ((repository.entityFamily !== "aggregate" &&
+            repository.entityFamily !== "process-manager" &&
+            repository.entityFamily !== "agent") ||
             (routing.commandSchemas.length === 0 && routing.eventSchemas.length === 0)) {
             return undefined;
         }
@@ -6018,7 +8204,9 @@ const RepositoryDispatch = {
             targetTypeUrl: TypeUrls.derive(repository.stateSchema),
             labels: Object.freeze([
                 ...(routing.commandSchemas.length === 0 ? [] : ["HANDLE_COMMAND"]),
-                ...(repository.entityFamily === "process-manager" && routing.eventSchemas.length > 0
+                ...((repository.entityFamily === "process-manager" ||
+                    repository.entityFamily === "agent") &&
+                    routing.eventSchemas.length > 0
                     ? ["REACT_UPON_EVENT"]
                     : []),
             ]),
@@ -6082,6 +8270,7 @@ const RepositoryDispatch = {
                 await RepositoryDispatch.dispatchAggregateEvent(repository, routing, runtime, event, route);
                 return;
             case "process-manager":
+            case "agent":
                 await new ProcessManagerEventExecution(repository, routing, runtime, event).run(route);
                 return;
             case "projection":
@@ -6146,7 +8335,7 @@ const RepositoryDispatch = {
             await InboxHandoff.handoffEntityCommand(repository, runtime, command);
             return;
         }
-        if (repository.entityFamily === "process-manager") {
+        if (repository.entityFamily === "process-manager" || repository.entityFamily === "agent") {
             await InboxHandoff.handoffEntityCommand(repository, runtime, command);
             return;
         }