@dsh-enhanced/assistant-delivery 0.1.6 → 0.1.12

package/lib/service.js

@@ -4,13 +4,220 @@ import { createHash, randomUUID } from 'node:crypto';
 import { Context, Service } from '@deepseek-ai/cordis';
 import Schema from '@deepseek-ai/schemastery';
 import { approvalReviewerOf, isAutoReviewEscalation, } from '@dsh-enhanced/assistant-policy';
+import { TRUSTED_EVALUATION_PRODUCER_PROTOCOL, } from '@dsh-enhanced/assistant-evaluation';
+import { ASSISTANT_GROWTH_CONTRACT_VERSION, growthObjectDigest, validateResolvedWorkflowAutomationTemplate, validateWorkflowAutomationTemplate, validateWorkflowScope, validateWorkflowTraceProjectionReceipt, workflowArgumentShapeDigest, } from '@dsh-enhanced/assistant-growth-contract';
 import { DeliveryAdapterRegistry, DeliveryCoordinator, InboundCoordinator, } from './coordinator.js';
 import { DeliveryStore, DeliveryStoreError } from './store.js';
 import { DshDeliveryRuntime } from './agent-runtime.js';
 import { InboundImageMaterializer } from './inbound-images.js';
 import { registerDeliveryTools } from './tools.js';
-import { canonicalConversation, externalPrincipalId } from './canonical.js';
+import { bindingMatchesOwnerRoute, canonicalBackgroundSourceId as canonicalHostBackgroundSourceId, canonicalConversation, canonicalLocalOperatorId, canonicalOwnerRouteAuthority, externalPrincipalId, ownerRouteAuthorityHash, ownerRouteBindingSnapshot, } from './canonical.js';
 import { isExactDeliveryCommand, parseDeliveryCommand } from './session-commands.js';
+import { deliveryT1PreferenceKeys, deliveryT1PreferenceValues } from './learning-command.js';
+import { feedbackSignalInput, classifyNaturalPreferenceDirective, observedResponseLanguage, } from './feedback-command.js';
+import { DELIVERY_PREFERENCE_PROJECTION_PROTOCOL, TRUSTED_DELIVERY_PRESENTATION_PRODUCER_PROTOCOL, } from './types.js';
+const trustedDeliveryPreferenceProducers = new WeakSet();
+const deliveryPreferenceProducerProbe = Symbol('assistant-delivery.preference-producer-probe');
+/**
+ * Process-local authenticity against accidental service-slot collisions. The
+ * private symbol is never exported, so copying the public method shape is not
+ * enough to solicit a genuine registration. This is not an OS/process sandbox
+ * boundary against code already executing inside the trusted Host process.
+ */
+export function isTrustedDeliveryPreferenceProducer(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    try {
+        const probe = value[deliveryPreferenceProducerProbe];
+        if (typeof probe !== 'function')
+            return false;
+        const exact = probe();
+        return typeof exact === 'object' && exact !== null
+            && trustedDeliveryPreferenceProducers.has(exact);
+    }
+    catch {
+        return false;
+    }
+}
+const learningMetadataPrefix = 'dsh.learning.';
+const automationObjectiveFeedbackFooter = [
+    '',
+    '---',
+    '任务结果反馈：直接回复本消息并发送 `/feedback achieved`、`/feedback partial` 或 `/feedback not-achieved`。',
+    '`helpful` 等只记录偏好，不会被当成任务成败。',
+].join('\n');
+function isAutomationDeliveryEvidenceResolver(value) {
+    return typeof value === 'object' && value !== null
+        && typeof value.resolveDeliveryEvidence === 'function';
+}
+function registrationOwnedByEvaluation(registration) {
+    const candidate = registration;
+    try {
+        return typeof candidate.owner === 'object' && candidate.owner !== null
+            && typeof candidate.owner.ownsTrustedDeliveryEvaluationRegistration === 'function'
+            && candidate.owner.ownsTrustedDeliveryEvaluationRegistration(registration);
+    }
+    catch {
+        return false;
+    }
+}
+function registrationOwnedByPreference(registration) {
+    try {
+        return typeof registration.owner === 'object' && registration.owner !== null
+            && typeof registration.owner.ownsDeliveryPreferenceRegistration === 'function'
+            && registration.owner.ownsDeliveryPreferenceRegistration(registration);
+    }
+    catch {
+        return false;
+    }
+}
+function isTrustedDeliveryPresentationProducer(value) {
+    return typeof value === 'object' && value !== null
+        && typeof value
+            .trustedDeliveryPresentationProducerGeneration === 'function'
+        && typeof value
+            .registerTrustedDeliveryPresentationSink === 'function';
+}
+function validatePreferenceProjectionReceipts(receipts, events) {
+    if (!Array.isArray(receipts) || receipts.length !== events.length) {
+        throw Object.assign(new Error('preference projection receipt batch is invalid'), {
+            code: 'invalid-receipt',
+        });
+    }
+    const expected = new Set(events.map(event => event.idempotencyKey));
+    const received = new Set();
+    for (const receipt of receipts) {
+        if (receipt?.status !== 'recorded' || typeof receipt.idempotencyKey !== 'string'
+            || !expected.has(receipt.idempotencyKey) || received.has(receipt.idempotencyKey)) {
+            throw Object.assign(new Error('preference projection receipt is invalid'), {
+                code: 'invalid-receipt',
+            });
+        }
+        received.add(receipt.idempotencyKey);
+    }
+}
+function validateLearningControlReceipt(value, request) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value)
+        || Object.getPrototypeOf(value) !== Object.prototype) {
+        throw new Error('learning control receipt is invalid');
+    }
+    const receipt = value;
+    if (receipt.action !== request.action || receipt.idempotencyKey !== request.idempotencyKey) {
+        throw new Error('learning control receipt identity is invalid');
+    }
+    if (receipt.outcome === 'stale') {
+        if (Object.keys(receipt).sort().join(',') !== 'action,idempotencyKey,outcome') {
+            throw new Error('learning stale receipt contains untrusted fields');
+        }
+        return;
+    }
+    if (receipt.outcome !== 'applied' || typeof receipt.replayed !== 'boolean'
+        || typeof receipt.state !== 'object' || receipt.state === null) {
+        throw new Error('learning control receipt outcome is invalid');
+    }
+    const expectedReceiptKeys = ['action', 'idempotencyKey', 'outcome', 'replayed', 'state'];
+    if (request.action === 'forget')
+        expectedReceiptKeys.push('deletedHypotheses', 'deletedSignals');
+    if (request.action === 'explain')
+        expectedReceiptKeys.push('explanation');
+    if (request.action === 'export')
+        expectedReceiptKeys.push('exportDocument');
+    if (request.action === 'rollback') {
+        expectedReceiptKeys.push('rolledBack');
+        if (receipt.rolledBack === true)
+            expectedReceiptKeys.push('rolledBackVersion');
+    }
+    if (Object.keys(receipt).sort().join(',') !== expectedReceiptKeys.sort().join(',')) {
+        throw new Error('learning control receipt contains untrusted fields');
+    }
+    const state = receipt.state;
+    if (Array.isArray(state) || Object.getPrototypeOf(state) !== Object.prototype
+        || Object.keys(state).sort().join(',') !== [
+            'activeOverlays', 'administrativelyEnabled', 'collectionMode',
+            'effectiveActiveOverlays', 'hypotheses', 'mode', 'shadowHypotheses',
+            'signals', 'storedActiveOverlays',
+        ].join(',')
+        || !['active', 'disabled', 'paused'].includes(state.mode)
+        || typeof state.administrativelyEnabled !== 'boolean'
+        || !['active', 'paused'].includes(state.collectionMode)
+        || [state.signals, state.hypotheses, state.storedActiveOverlays,
+            state.effectiveActiveOverlays, state.activeOverlays, state.shadowHypotheses]
+            .some(count => !Number.isSafeInteger(count) || count < 0)) {
+        throw new Error('learning control receipt state is invalid');
+    }
+    const expectedMode = state.administrativelyEnabled ? state.collectionMode : 'disabled';
+    const expectedEffective = state.administrativelyEnabled && state.collectionMode === 'active'
+        ? state.storedActiveOverlays
+        : 0;
+    if (state.mode !== expectedMode || state.effectiveActiveOverlays !== expectedEffective
+        || state.activeOverlays !== expectedEffective) {
+        throw new Error('learning control receipt state gates are inconsistent');
+    }
+    if (request.action === 'forget'
+        && (!Number.isSafeInteger(receipt.deletedSignals) || receipt.deletedSignals < 0
+            || !Number.isSafeInteger(receipt.deletedHypotheses) || receipt.deletedHypotheses < 0)) {
+        throw new Error('learning forget receipt is invalid');
+    }
+    if (request.action === 'explain') {
+        if (!Array.isArray(receipt.explanation))
+            throw new Error('learning explain receipt is invalid');
+        for (const item of receipt.explanation) {
+            if (typeof item !== 'object' || item === null
+                || typeof item.key !== 'string' || typeof item.value !== 'string'
+                || !['active', 'inactive', 'rolled-back', 'shadow', 'suppressed'].includes(item.state)
+                || !Number.isSafeInteger(item.version) || item.version < 1
+                || [item.supportingSignals, item.contradictingSignals, item.evidenceMass]
+                    .some(count => !Number.isSafeInteger(count) || count < 0)) {
+                throw new Error('learning explain receipt is invalid');
+            }
+        }
+    }
+    if (request.action === 'export') {
+        const document = receipt.exportDocument;
+        if (typeof document !== 'object' || document === null || Array.isArray(document)
+            || Object.getPrototypeOf(document) !== Object.prototype
+            || Object.keys(document).sort().join(',') !== 'format,records,version'
+            || document.format !== 'dsh-preference-learning' || document.version !== 1
+            || !Array.isArray(document.records)
+            || document.records.length > Object.values(deliveryT1PreferenceValues)
+                .reduce((total, values) => total + values.length, 0)) {
+            throw new Error('learning export receipt is invalid');
+        }
+        let previousIdentity;
+        for (const item of document.records) {
+            if (typeof item !== 'object' || item === null || Array.isArray(item)
+                || Object.getPrototypeOf(item) !== Object.prototype
+                || Object.keys(item).sort().join(',') !== [
+                    'contradictingSignals', 'evidenceMass', 'key', 'state',
+                    'supportingSignals', 'value', 'version',
+                ].join(',')
+                || !deliveryT1PreferenceKeys.includes(item.key)
+                || !deliveryT1PreferenceValues[item.key]
+                    ?.includes(item.value)
+                || !['active', 'inactive', 'rolled-back', 'shadow', 'suppressed'].includes(item.state)
+                || !Number.isSafeInteger(item.version) || item.version < 1
+                || [item.supportingSignals, item.contradictingSignals, item.evidenceMass]
+                    .some(count => !Number.isSafeInteger(count) || count < 0)) {
+                throw new Error('learning export receipt is invalid');
+            }
+            const identity = `${item.key}\0${item.value}`;
+            if (previousIdentity !== undefined && identity <= previousIdentity) {
+                throw new Error('learning export receipt is not canonically ordered');
+            }
+            previousIdentity = identity;
+        }
+    }
+    if (request.action === 'rollback'
+        && (typeof receipt.rolledBack !== 'boolean'
+            || (receipt.rolledBack
+                ? !Number.isSafeInteger(receipt.rolledBackVersion) || receipt.rolledBackVersion < 2
+                : receipt.rolledBackVersion !== undefined))) {
+        throw new Error('learning rollback receipt is invalid');
+    }
+}
+function containsReservedLearningMetadata(metadata) {
+    return metadata !== undefined && Object.keys(metadata).some(key => key.startsWith(learningMetadataPrefix));
+}
 export class AssistantDeliveryError extends Error {
     code;
     constructor(code, message) {
@@ -41,10 +248,70 @@ const configSchema = Schema.object({
     modelPickerTtlMs: Schema.number().step(1).min(60_000).max(86_400_000).default(900_000),
     permissionPickerTtlMs: Schema.number().step(1).min(60_000).max(86_400_000).default(900_000),
     toolApprovalTtlMs: Schema.number().step(1).min(1_000).max(300_000).default(300_000),
+    ownerRoutes: Schema.array(Schema.object({
+        id: Schema.string().min(1).required(),
+        conversation: Schema.object({
+            channel: Schema.string().min(1).required(),
+            account: Schema.string().min(1).required(),
+            tenant: Schema.string().min(1).required(),
+            kind: Schema.union(['dm', 'group']).required(),
+            chat: Schema.string().min(1).required(),
+            thread: Schema.string(),
+        }).required(),
+        principal: Schema.object({
+            channel: Schema.string().min(1).required(),
+            account: Schema.string().min(1).required(),
+            tenant: Schema.string().min(1).required(),
+            user: Schema.string().min(1).required(),
+        }).required(),
+        workspace: Schema.string().min(1).required(),
+        agentPreset: Schema.string().min(1).required(),
+        policyRef: Schema.string().min(1).required(),
+        minimumGeneration: Schema.number().step(1).min(1).max(Number.MAX_SAFE_INTEGER).required(),
+    })).default([]),
 });
 function policyDenied(decision) {
     return new AssistantDeliveryError('policy-denied', `assistant-delivery policy denied operation: ${decision.reasonCode}`);
 }
+function canonicalBackgroundSourceId(input) {
+    try {
+        return canonicalHostBackgroundSourceId(input);
+    }
+    catch {
+        throw new AssistantDeliveryError('runtime-conflict', 'background source identity is invalid');
+    }
+}
+function canonicalOwnerRouteId(input) {
+    const id = canonicalBackgroundSourceId(input);
+    if (!/^[A-Za-z0-9][A-Za-z0-9._/-]{0,127}$/u.test(id)) {
+        throw new AssistantDeliveryError('missing-binding', 'owner route authority id is invalid');
+    }
+    return id;
+}
+function canonicalRouteIdempotencyKey(input) {
+    if (typeof input !== 'string') {
+        throw new AssistantDeliveryError('runtime-conflict', 'owner route idempotency key is invalid');
+    }
+    const normalized = input.trim();
+    const hasControl = [...normalized].some(character => {
+        const code = character.codePointAt(0);
+        return code <= 0x1f || code === 0x7f;
+    });
+    if (normalized === '' || normalized.length > 512 || hasControl) {
+        throw new AssistantDeliveryError('runtime-conflict', 'owner route idempotency key is invalid');
+    }
+    return normalized;
+}
+/** One exact Policy identity shared by enqueue admission and dispatch rechecks. */
+function authorizeOwnerRoute(policy, authority, sourceId, idempotencyKey) {
+    const operationDigest = createHash('sha256').update(JSON.stringify([
+        sourceId, authority.id, ownerRouteAuthorityHash(authority), idempotencyKey,
+    ])).digest('hex');
+    return policy.authorize({ subject: { kind: 'background', id: sourceId,
+            workspace: authority.workspace, principal: externalPrincipalId(authority.principal) }, action: 'send',
+        resource: { kind: 'message', id: `route:${authority.id}` },
+        context: { initiator: 'background' } }, { idempotencyKey: `message-route-send:${operationDigest}` });
+}
 function pickerIncludesRoute(picker, route) {
     const model = picker.models.find(candidate => candidate.provider === route.provider && candidate.id === route.model);
     return model !== undefined && (route.reasoningEffort === undefined || model.effortIds.includes(route.reasoningEffort));
@@ -164,24 +431,49 @@ function exactToolApprovalCall(events, openTurn, callId, toolName) {
 export class AssistantDeliveryService extends Service {
     static Config = configSchema;
     deliveryStore;
+    context;
     policy;
     registry;
     outbound;
     inbound;
     config;
+    ownerRoutes;
+    ownerRouteGuard;
     ownerId = `assistant-delivery-${randomUUID()}`;
     bindingFlights = new Map();
     conversationTransitions = new Map();
     agentApprovalBindings = new WeakMap();
     toolApprovalControllers = new Set();
     modelSelectionWaiters = new Map();
+    preferenceFeedbackSink;
+    evaluationSink;
+    workflowTraceSink;
+    automationPresentationBinding;
+    evolutionPresentationBinding;
+    activePresentationRegistrations = new WeakSet();
+    evaluationProducerGeneration = `assistant-delivery:${randomUUID()}`;
+    preferenceProducerGeneration = `assistant-delivery-preference:${randomUUID()}`;
+    preferenceTurns = new WeakMap();
     modelSelectionFlight;
+    presentationFlight;
+    workflowTraceFlight;
+    preferenceProjectionFlight;
+    workflowTraceRetryTimer;
+    preferenceProjectionRetryTimer;
     modelSelectionRetryTimer;
     runtime;
     timer;
     active = true;
     constructor(ctx, input) {
         super(ctx, 'assistantDelivery');
+        trustedDeliveryPreferenceProducers.add(this);
+        Object.defineProperty(this, deliveryPreferenceProducerProbe, {
+            value: () => this,
+            enumerable: false,
+            configurable: false,
+            writable: false,
+        });
+        this.context = ctx;
         let config;
         try {
             config = AssistantDeliveryService.Config(input);
@@ -197,9 +489,40 @@ export class AssistantDeliveryService extends Service {
             throw new Error('assistant-delivery: assistantPolicy service is required');
         mkdirSync(config.spoolPath, { recursive: true, mode: 0o700 });
         chmodSync(config.spoolPath, 0o700);
-        this.config = config;
+        let ownerRoutes;
+        try {
+            ownerRoutes = config.ownerRoutes.map(route => canonicalOwnerRouteAuthority(route));
+        }
+        catch (error) {
+            throw new Error(`assistant-delivery: invalid owner route authority: ${String(error)}`, { cause: error });
+        }
+        if (new Set(ownerRoutes.map(route => route.id)).size !== ownerRoutes.length) {
+            throw new Error('assistant-delivery: invalid owner route authority: duplicate id');
+        }
+        const frozenOwnerRoutes = Object.freeze(ownerRoutes.map(route => Object.freeze({
+            ...route,
+            conversation: Object.freeze({ ...route.conversation }),
+            principal: Object.freeze({ ...route.principal }),
+        })));
+        this.config = { ...config, ownerRoutes: frozenOwnerRoutes };
+        this.ownerRoutes = new Map(frozenOwnerRoutes.map(route => [route.id, route]));
         this.policy = policy;
+        const ownerRouteGuard = {
+            ownerRoutes: [...this.ownerRoutes.values()],
+            authorize: ({ authority, sourceId, idempotencyKey }) => authorizeOwnerRoute(this.policy, authority, sourceId, idempotencyKey).effect === 'allow',
+        };
+        this.ownerRouteGuard = Object.freeze(ownerRouteGuard);
         this.deliveryStore = new DeliveryStore({ path: config.databasePath, maxTextBytes: config.maxTextBytes });
+        ctx.on('agent/inbox/claimed', ({ agent, message, turn }) => {
+            this.capturePreferenceTurn(agent, message.source, turn);
+        });
+        ctx.on('agent/inbox/discarded', ({ agent }) => {
+            this.preferenceTurns.delete(agent);
+        });
+        ctx.on('agent/status', ({ agent, status }) => {
+            if (status === 'idle')
+                this.preferenceTurns.delete(agent);
+        });
         this.registry = new DeliveryAdapterRegistry({
             accept: async (envelope) => {
                 const result = await this.acceptInbound(envelope);
@@ -219,7 +542,9 @@ export class AssistantDeliveryService extends Service {
         });
         this.outbound = new DeliveryCoordinator({ store: this.deliveryStore, registry: this.registry,
             ownerId: this.ownerId, leaseMs: config.leaseMs, maxAttempts: config.maxAttempts,
-            maxConcurrency: config.maxConcurrency, retryBaseMs: config.retryBaseMs, retryMaxMs: config.retryMaxMs });
+            maxConcurrency: config.maxConcurrency, retryBaseMs: config.retryBaseMs, retryMaxMs: config.retryMaxMs,
+            ownerRouteGuard: this.ownerRouteGuard,
+        });
         this.inbound = new InboundCoordinator({ store: this.deliveryStore, processor: () => this.runtime,
             ownerId: this.ownerId, leaseMs: config.leaseMs, maxAttempts: config.maxAttempts,
             maxConcurrency: config.maxConcurrency, retryBaseMs: config.retryBaseMs, retryMaxMs: config.retryMaxMs });
@@ -236,6 +561,13 @@ export class AssistantDeliveryService extends Service {
                 imageMaterializer,
                 isInboundAuthorized: (binding, envelope) => this.isInboundAuthorized(binding, envelope),
                 isPermissionController: (binding, envelope) => this.isPermissionController(binding, envelope),
+                isOwnerFeedbackController: (binding, envelope) => this.isOwnerFeedbackController(binding, envelope),
+                authorizeOwnerPreferenceFeedback: (binding, envelope, selections) => this.authorizeOwnerPreferenceFeedback(binding, envelope, selections),
+                dispatchPreferenceFeedback: events => this.dispatchPreferenceFeedback(events),
+                replyCompletedPreferenceTurn: (agent, binding, envelope, reply) => this.replyCompletedPreferenceTurn(agent, binding, envelope, reply),
+                dispatchObjectiveFeedback: (binding, envelope, objectiveStatus) => this.dispatchObjectiveFeedback(binding, envelope, objectiveStatus),
+                dispatchWorkflowCommand: (binding, envelope, command) => this.dispatchWorkflowCommand(binding, envelope, command),
+                dispatchLearningCommand: (binding, envelope, action, preferenceKey) => this.dispatchLearningCommand(binding, envelope, action, preferenceKey),
                 authorizePermissionReply: (binding, envelope) => this.authorizePermissionReply(binding, envelope),
                 beginModelCommand: conversation => this.deliveryStore.beginModelCommand(conversation),
                 commitModelCommand: input => this.deliveryStore.commitModelCommand(input),
@@ -258,26 +590,45 @@ export class AssistantDeliveryService extends Service {
                         ...(reply.permissionPicker === undefined ? {} : { permissionPicker: reply.permissionPicker }),
                     });
                 },
-                reply: (agent, eventId, reply) => {
-                    this.reply(agent, {
-                        idempotencyKey: `inbound:${eventId}:reply`,
-                        text: reply.text,
-                        replyToEventId: eventId,
-                        ...(reply.format === undefined ? {} : { format: reply.format }),
-                        ...(reply.modelPicker === undefined ? {} : { modelPicker: reply.modelPicker }),
-                        ...(reply.permissionPicker === undefined ? {} : { permissionPicker: reply.permissionPicker }),
-                    });
-                },
             }));
             void this.drainModelSelectionSettlements();
             return unregister;
         });
         ctx.inject(['approval'], approvalCtx => approvalCtx.on('approval/request', (request, next) => this.requestToolApproval(approvalCtx, request, next)));
         ctx.inject(['tools'], toolsCtx => registerDeliveryTools(toolsCtx, this));
+        // Presentation writes are intentionally reverse-bound. Delivery creates
+        // the publisher closure and hands it only to the exact live domain service;
+        // a public service-slot caller can no longer forge a terminal projection.
+        const currentAutomations = ctx.get('assistantAutomations');
+        if (isTrustedDeliveryPresentationProducer(currentAutomations)) {
+            this.bindPresentationProducer('assistant-automations', currentAutomations);
+        }
+        ctx.inject(['assistantAutomations'], automationsCtx => {
+            const producer = automationsCtx.get('assistantAutomations');
+            if (!isTrustedDeliveryPresentationProducer(producer))
+                return;
+            return this.bindPresentationProducer('assistant-automations', producer);
+        });
+        const currentEvolution = ctx.get('assistantEvolution');
+        if (isTrustedDeliveryPresentationProducer(currentEvolution)) {
+            this.bindPresentationProducer('assistant-evolution', currentEvolution);
+        }
+        ctx.inject(['assistantEvolution'], evolutionCtx => {
+            const producer = evolutionCtx.get('assistantEvolution');
+            if (!isTrustedDeliveryPresentationProducer(producer))
+                return;
+            return this.bindPresentationProducer('assistant-evolution', producer);
+        });
         if (config.schedulerEnabled)
             this.start();
         ctx.effect(() => async () => {
             this.active = false;
+            trustedDeliveryPreferenceProducers.delete(this);
+            this.preferenceFeedbackSink = undefined;
+            this.evaluationSink = undefined;
+            this.workflowTraceSink = undefined;
+            this.automationPresentationBinding?.dispose();
+            this.evolutionPresentationBinding?.dispose();
             this.cancelModelSelectionWaiters();
             for (const controller of this.toolApprovalControllers) {
                 controller.abort(new Error('assistant-delivery is stopping'));
@@ -743,16 +1094,26 @@ export class AssistantDeliveryService extends Service {
     }
     resolveDeadLetter(input) {
         this.assertActive();
-        const decision = this.policy.authorize({ subject: { kind: 'external', id: `local:${input.operatorId}` },
+        let operatorId;
+        try {
+            operatorId = canonicalLocalOperatorId(input.operatorId);
+        }
+        catch {
+            throw new AssistantDeliveryError('runtime-conflict', 'dead-letter operator identity is invalid');
+        }
+        const operationDigest = createHash('sha256').update(JSON.stringify([
+            operatorId, input.kind, input.id, input.expectedAttemptCount, input.resolution,
+        ])).digest('hex');
+        const decision = this.policy.authorize({ subject: { kind: 'external', id: `local:${operatorId}` },
             action: 'delivery.resolve', resource: { kind: 'message', id: `${input.kind}:${input.id}` },
-            context: { initiator: 'foreground' } }, { idempotencyKey: `delivery-resolve:${input.kind}:${input.id}:${input.expectedAttemptCount}:${input.resolution}` });
+            context: { initiator: 'foreground' } }, { idempotencyKey: `delivery-resolve:${operationDigest}` });
         if (decision.effect !== 'allow')
             throw policyDenied(decision);
         return input.kind === 'inbox'
             ? this.deliveryStore.resolveInbox({ inboxId: input.id, expectedAttemptCount: input.expectedAttemptCount,
-                resolution: input.resolution })
+                resolution: input.resolution, operatorId })
             : this.deliveryStore.resolveOutbox({ outboxId: input.id, expectedAttemptCount: input.expectedAttemptCount,
-                resolution: input.resolution });
+                resolution: input.resolution, operatorId });
     }
     registerInboundRuntime(runtime) {
         this.assertActive();
@@ -772,10 +1133,452 @@ export class AssistantDeliveryService extends Service {
         this.assertActive();
         return this.registry.register(adapter);
     }
+    currentPreferenceTurn(agent) {
+        this.assertActive();
+        const attestation = this.preferenceTurns.get(agent);
+        if (attestation === undefined
+            || String(agent.session.id) !== attestation.sessionId
+            || agent.session.header.cwd !== attestation.scope.workspace
+            || agent.session.header.agentPreset !== attestation.scope.preset)
+            return undefined;
+        const binding = this.deliveryStore.getBinding(attestation.bindingId);
+        const inbox = this.deliveryStore.getInbox(attestation.sourceInboxId);
+        const lineage = binding === undefined ? undefined : this.ownerLineageForBinding(binding);
+        if (binding?.status !== 'active' || binding.version !== attestation.bindingVersion
+            || binding.sessionId !== attestation.sessionId
+            || inbox?.status !== 'claimed' || inbox.bindingId !== binding.id
+            || inbox.envelope.eventId !== attestation.sourceEventId
+            || lineage?.principalRecordId !== attestation.principalLineage.principalRecordId
+            || lineage?.principalVersion !== attestation.principalLineage.principalVersion
+            || !this.isOwnerFeedbackController(binding, inbox.envelope))
+            return undefined;
+        const started = agent.session.events.some(event => event.type === 'turn/start' && event.data.turn === attestation.turn);
+        const ended = agent.session.events.some(event => event.type === 'turn/end' && event.data.turn === attestation.turn);
+        return started && !ended ? attestation : undefined;
+    }
+    preferencePrincipalForAgent(agent) {
+        this.assertActive();
+        const sessionId = String(agent.session.id);
+        const resolved = this.deliveryStore.getPreferencePrincipalForSession({
+            sessionId, workspace: agent.session.header.cwd, preset: agent.session.header.agentPreset,
+        });
+        if (resolved === undefined)
+            return undefined;
+        const { binding, principal } = resolved;
+        return Object.freeze({
+            scope: Object.freeze({ workspace: binding.workspace, preset: binding.agentPreset }),
+            principalId: externalPrincipalId(binding.principal),
+            principalLineage: Object.freeze({
+                principalRecordId: principal.id,
+                principalVersion: principal.version,
+            }),
+            bindingId: binding.id,
+            bindingVersion: binding.version,
+            bindingGeneration: binding.generation,
+            sessionId,
+        });
+    }
+    capturePreferenceTurn(agent, sourceInput, turnInput) {
+        if (!this.active || typeof sourceInput !== 'object' || sourceInput === null
+            || !Number.isSafeInteger(turnInput) || turnInput < 0)
+            return;
+        const source = sourceInput;
+        if (source.kind !== 'delivery' || typeof source.channel !== 'string'
+            || typeof source.account !== 'string' || typeof source.eventId !== 'string')
+            return;
+        const sessionId = String(agent.session.id);
+        const binding = this.deliveryStore.getBindingBySession(sessionId);
+        const inbox = this.deliveryStore.getInboxByProviderEvent(source.channel, source.account, source.eventId);
+        const lineage = binding === undefined ? undefined : this.ownerLineageForBinding(binding);
+        if (binding?.status !== 'active' || inbox?.status !== 'claimed' || inbox.bindingId !== binding.id
+            || binding.sessionId !== sessionId || binding.workspace !== agent.session.header.cwd
+            || binding.agentPreset !== agent.session.header.agentPreset
+            || lineage === undefined
+            || !this.isOwnerFeedbackController(binding, inbox.envelope))
+            return;
+        this.preferenceTurns.set(agent, Object.freeze({
+            scope: Object.freeze({ workspace: binding.workspace, preset: binding.agentPreset }),
+            principalId: externalPrincipalId(binding.principal),
+            principalLineage: lineage,
+            bindingId: binding.id,
+            bindingVersion: binding.version,
+            sessionId,
+            sourceEventId: source.eventId,
+            sourceInboxId: inbox.id,
+            turn: turnInput,
+        }));
+    }
+    trustedPreferenceProducerGeneration() {
+        this.assertActive();
+        return this.preferenceProducerGeneration;
+    }
+    /** Exact process-local Preference owner registration; copied or self-asserted sinks fail. */
+    registerTrustedPreferenceSink(registration) {
+        this.assertActive();
+        if (registration.protocol !== DELIVERY_PREFERENCE_PROJECTION_PROTOCOL
+            || registration.producer !== 'preference-learning'
+            || registration.generation !== this.preferenceProducerGeneration
+            || typeof registration.append !== 'function'
+            || (registration.appendSynchronously !== undefined
+                && typeof registration.appendSynchronously !== 'function')
+            || !registrationOwnedByPreference(registration)) {
+            throw new AssistantDeliveryError('runtime-conflict', 'trusted Preference registration is invalid');
+        }
+        if (this.preferenceFeedbackSink !== undefined) {
+            if (this.preferenceFeedbackSink.registration === registration) {
+                return this.preferenceFeedbackSink.dispose;
+            }
+            throw new AssistantDeliveryError('runtime-conflict', 'trusted Preference sink is already registered');
+        }
+        const token = Symbol('assistant-delivery.trusted-preference');
+        let active = true;
+        const dispose = () => {
+            if (!active)
+                return;
+            active = false;
+            if (this.preferenceFeedbackSink?.token === token)
+                this.preferenceFeedbackSink = undefined;
+        };
+        this.preferenceFeedbackSink = Object.freeze({ token, registration, dispose });
+        this.deliveryStore.requeuePreferenceProjections();
+        void this.drainPreferenceProjections();
+        return dispose;
+    }
+    trustedEvaluationProducerGeneration() {
+        this.assertActive();
+        return this.evaluationProducerGeneration;
+    }
+    registerTrustedDeliveryEvaluationSink(registration) {
+        this.assertActive();
+        if (registration.protocol !== TRUSTED_EVALUATION_PRODUCER_PROTOCOL
+            || registration.producer !== 'assistant-delivery'
+            || registration.generation !== this.evaluationProducerGeneration
+            || typeof registration.issueCapability !== 'function'
+            || typeof registration.append !== 'function'
+            || !registrationOwnedByEvaluation(registration)) {
+            throw new AssistantDeliveryError('runtime-conflict', 'trusted Evaluation registration is invalid');
+        }
+        if (this.evaluationSink !== undefined) {
+            throw new AssistantDeliveryError('runtime-conflict', 'trusted Evaluation sink is already registered');
+        }
+        const token = Symbol('assistant-delivery.trusted-evaluation');
+        this.evaluationSink = Object.freeze({ token, registration });
+        let active = true;
+        return () => {
+            if (!active)
+                return;
+            active = false;
+            if (this.evaluationSink?.token === token)
+                this.evaluationSink = undefined;
+        };
+    }
+    /**
+     * Register Growth's exact private sink. Replaying current is deliberately
+     * queued after this method returns so a registration receipt can never be
+     * confused with synchronous projection success.
+     */
+    registerWorkflowTraceSink(input) {
+        this.assertActive();
+        if (typeof input !== 'object' || input === null
+            || Object.keys(input).sort().join(',') !== 'contractVersion,sink'
+            || input.contractVersion !== ASSISTANT_GROWTH_CONTRACT_VERSION
+            || typeof input.sink !== 'object' || input.sink === null
+            || typeof input.sink.projectWorkflowTraceRevision !== 'function') {
+            throw new AssistantDeliveryError('runtime-conflict', 'workflow trace sink registration is invalid');
+        }
+        if (this.workflowTraceSink !== undefined) {
+            throw new AssistantDeliveryError('runtime-conflict', 'workflow trace sink is already registered');
+        }
+        const token = Symbol('assistant-delivery.workflow-trace');
+        this.workflowTraceSink = Object.freeze({ token, sink: input.sink });
+        const source = this.deliveryStore.workflowTraceSourceAttestation();
+        let registered = true;
+        const receipt = Object.freeze({
+            contractVersion: ASSISTANT_GROWTH_CONTRACT_VERSION,
+            ...source,
+            dispose: () => {
+                if (!registered)
+                    return;
+                registered = false;
+                if (this.workflowTraceSink?.token === token)
+                    this.workflowTraceSink = undefined;
+            },
+        });
+        queueMicrotask(() => {
+            if (!this.active || this.workflowTraceSink?.token !== token)
+                return;
+            this.deliveryStore.requeueCurrentWorkflowTraces();
+            void this.drainWorkflowTraces();
+        });
+        return receipt;
+    }
+    resolveWorkflowAutomationTemplate(input) {
+        this.assertActive();
+        if (typeof input !== 'object' || input === null
+            || Object.keys(input).sort().join(',') !== 'contractVersion,ownerBindingId,scope,template'
+            || input.contractVersion !== ASSISTANT_GROWTH_CONTRACT_VERSION
+            || typeof input.ownerBindingId !== 'string') {
+            throw new AssistantDeliveryError('runtime-conflict', 'workflow template resolution request is invalid');
+        }
+        const template = validateWorkflowAutomationTemplate(input.template);
+        const scope = validateWorkflowScope(input.scope);
+        const stored = this.deliveryStore.getWorkflowAutomationTemplate(template);
+        const binding = this.deliveryStore.getBinding(input.ownerBindingId);
+        const owner = binding === undefined ? undefined : this.deliveryStore.getPrincipal(binding.principal);
+        const principalId = binding === undefined ? undefined : externalPrincipalId(binding.principal);
+        if (stored === undefined || stored.status !== 'active'
+            || stored.resolved.ownerBindingId !== input.ownerBindingId
+            || stored.resolved.scope.workspace !== scope.workspace
+            || stored.resolved.scope.preset !== scope.preset
+            || binding?.status !== 'active' || binding.workspace !== scope.workspace
+            || binding.agentPreset !== scope.preset || owner?.status !== 'active' || owner.role !== 'owner'
+            || stored.review.bindingId !== binding.id
+            || stored.review.bindingVersion !== binding.version
+            || stored.review.bindingGeneration !== binding.generation
+            || stored.review.principalId !== owner.id
+            || stored.resolved.principalId !== principalId) {
+            throw new AssistantDeliveryError('missing-binding', 'workflow template owner review is stale');
+        }
+        const decision = this.policy.authorize({
+            subject: { kind: 'background', id: 'assistant-growth-experiments',
+                workspace: scope.workspace, principal: externalPrincipalId(binding.principal) },
+            action: 'inspect',
+            resource: { kind: 'evolution', id: `workflow-template:${template.templateRef}` },
+            context: { initiator: 'background' },
+        }, { idempotencyKey: `workflow-template-resolve:${template.templateDigest}:${binding.version}` });
+        if (decision.effect !== 'allow')
+            throw policyDenied(decision);
+        // Policy evaluation is not a lock. Re-read the mutable route immediately
+        // before returning private prompt material.
+        const currentBinding = this.deliveryStore.getBinding(binding.id);
+        const currentOwner = currentBinding === undefined
+            ? undefined
+            : this.deliveryStore.getPrincipal(currentBinding.principal);
+        const currentTemplate = this.deliveryStore.getWorkflowAutomationTemplate(template);
+        if (currentBinding?.status !== 'active' || currentBinding.version !== binding.version
+            || currentBinding.generation !== binding.generation
+            || currentOwner?.status !== 'active' || currentOwner.role !== 'owner'
+            || currentTemplate?.status !== 'active' || currentTemplate.version !== stored.version
+            || currentTemplate.review.bindingId !== currentBinding.id
+            || currentTemplate.review.bindingVersion !== currentBinding.version
+            || currentTemplate.review.bindingGeneration !== currentBinding.generation
+            || currentTemplate.review.principalId !== currentOwner.id
+            || currentTemplate.resolved.principalId !== externalPrincipalId(currentBinding.principal)) {
+            throw new AssistantDeliveryError('missing-binding', 'workflow template authority changed during resolution');
+        }
+        return validateResolvedWorkflowAutomationTemplate(currentTemplate.resolved);
+    }
+    /**
+     * Host-only bridge from one exact reviewed workflow template to a v2 Policy
+     * approval route. This method is not registered as an Agent tool.
+     */
+    prepareWorkflowApproval(input) {
+        this.assertActive();
+        if (typeof input !== 'object' || input === null
+            || Object.keys(input).sort().join(',') !== 'contractVersion,ownerBindingId,scope,sourceId,template') {
+            throw new AssistantDeliveryError('runtime-conflict', 'workflow approval route request is invalid');
+        }
+        const sourceId = canonicalBackgroundSourceId(input.sourceId);
+        const resolved = this.resolveWorkflowAutomationTemplate({
+            contractVersion: input.contractVersion,
+            template: input.template,
+            scope: input.scope,
+            ownerBindingId: input.ownerBindingId,
+        });
+        const route = this.deliveryStore.resolveApprovalRouteByBinding({
+            sourceId,
+            bindingId: resolved.ownerBindingId,
+            scope: resolved.scope,
+            principalId: resolved.principalId,
+        });
+        if (route === undefined) {
+            throw new AssistantDeliveryError('missing-binding', 'workflow approval owner route changed');
+        }
+        return route;
+    }
+    /**
+     * Host-only, content-free route minting seam for Preference promotion.
+     * No binding id is accepted from the caller; Delivery resolves the unique
+     * current binding from the exact owner lineage and generation.
+     */
+    prepareOwnerApprovalForPreference(input) {
+        this.assertActive();
+        if (typeof input !== 'object' || input === null || Array.isArray(input)
+            || Object.keys(input).sort().join(',')
+                !== 'ownerGeneration,principalId,principalLineage,scope,sourceId'
+            || typeof input.scope !== 'object' || input.scope === null || Array.isArray(input.scope)
+            || Object.keys(input.scope).sort().join(',') !== 'preset,workspace'
+            || typeof input.principalLineage !== 'object' || input.principalLineage === null
+            || Array.isArray(input.principalLineage)
+            || Object.keys(input.principalLineage).sort().join(',') !== 'principalRecordId,principalVersion') {
+            throw new AssistantDeliveryError('runtime-conflict', 'preference approval owner authority is invalid');
+        }
+        try {
+            const route = this.deliveryStore.resolveOwnerApprovalForPreference(input);
+            return route ?? Object.freeze({ kind: 'stale-owner' });
+        }
+        catch (error) {
+            if (error instanceof DeliveryStoreError && error.code === 'invalid-binding') {
+                throw new AssistantDeliveryError('runtime-conflict', 'preference approval owner authority is invalid');
+            }
+            throw error;
+        }
+    }
     health() {
         this.assertActive();
         return { ...this.deliveryStore.health(), adapters: this.registry.size() };
     }
+    /** Exact process-local proof for a Delivery-minted publisher registration. */
+    ownsTrustedDeliveryPresentationRegistration(registration) {
+        return this.active && typeof registration === 'object' && registration !== null
+            && this.activePresentationRegistrations.has(registration);
+    }
+    getDeliveryPresentation(presentationKey) {
+        this.assertActive();
+        return this.deliveryStore.getDeliveryPresentation(presentationKey);
+    }
+    presentationBinding(producerId) {
+        return producerId === 'assistant-automations'
+            ? this.automationPresentationBinding
+            : this.evolutionPresentationBinding;
+    }
+    setPresentationBinding(producerId, binding) {
+        if (producerId === 'assistant-automations')
+            this.automationPresentationBinding = binding;
+        else
+            this.evolutionPresentationBinding = binding;
+    }
+    presentationProducerGeneration(producer) {
+        let generation;
+        try {
+            generation = producer.trustedDeliveryPresentationProducerGeneration();
+        }
+        catch {
+            throw new AssistantDeliveryError('runtime-conflict', 'presentation producer generation is unavailable');
+        }
+        if (typeof generation !== 'string') {
+            throw new AssistantDeliveryError('runtime-conflict', 'presentation producer generation is invalid');
+        }
+        const normalized = generation.normalize('NFC').trim();
+        const hasControl = [...normalized].some(character => {
+            const code = character.codePointAt(0);
+            return code <= 0x1f || code === 0x7f;
+        });
+        if (!/^[A-Za-z0-9][A-Za-z0-9._:-]{0,255}$/u.test(normalized) || hasControl) {
+            throw new AssistantDeliveryError('runtime-conflict', 'presentation producer generation is invalid');
+        }
+        return normalized;
+    }
+    /**
+     * Delivery owns the registration and its publish closure. The producer only
+     * receives that closure after it has proven this exact in-process object is
+     * its expected Delivery owner; replacement and disposal revoke it eagerly.
+     */
+    bindPresentationProducer(producerId, producer) {
+        const generation = this.presentationProducerGeneration(producer);
+        const current = this.presentationBinding(producerId);
+        // Cordis can expose more than one proxy object for the same service
+        // instance. A producer generation is minted once per concrete producer
+        // lifetime, so it is the stable instance identity across those proxies.
+        // Do not issue a second publisher merely because a later inject callback
+        // reached the same producer through a different proxy.
+        if (current?.generation === generation)
+            return current.dispose;
+        let live = true;
+        let registration;
+        registration = Object.freeze({
+            protocol: TRUSTED_DELIVERY_PRESENTATION_PRODUCER_PROTOCOL,
+            producer: producerId,
+            generation,
+            owner: this,
+            publish: (input) => {
+                this.assertCurrentPresentationProducer(producerId, producer, generation, registration, live);
+                return this.publishTrustedDeliveryPresentation(producerId, input);
+            },
+        });
+        this.activePresentationRegistrations.add(registration);
+        let unregister;
+        let binding;
+        const dispose = () => {
+            if (!live)
+                return;
+            live = false;
+            this.activePresentationRegistrations.delete(registration);
+            if (this.presentationBinding(producerId) === binding) {
+                this.setPresentationBinding(producerId, undefined);
+            }
+            unregister?.();
+        };
+        binding = Object.freeze({ producerId, producer, generation, registration, dispose });
+        this.setPresentationBinding(producerId, binding);
+        try {
+            unregister = producer.registerTrustedDeliveryPresentationSink(registration);
+            if (typeof unregister !== 'function') {
+                throw new AssistantDeliveryError('runtime-conflict', 'presentation producer returned no registration disposer');
+            }
+            // A reload that swaps its generation while registering cannot inherit a
+            // publisher issued to the preceding instance state.
+            if (this.presentationProducerGeneration(producer) !== generation) {
+                throw new AssistantDeliveryError('runtime-conflict', 'presentation producer changed during registration');
+            }
+        }
+        catch (error) {
+            live = false;
+            this.activePresentationRegistrations.delete(registration);
+            if (this.presentationBinding(producerId) === binding) {
+                this.setPresentationBinding(producerId, current);
+            }
+            try {
+                unregister?.();
+            }
+            catch {
+                // Registration never became live, so cleanup cannot replace the
+                // original registration failure.
+            }
+            throw error;
+        }
+        // Do not revoke the old producer until the replacement has accepted the
+        // new publisher; a reentrant durable outbox drain then has one valid owner.
+        current?.dispose();
+        return dispose;
+    }
+    assertCurrentPresentationProducer(producerId, producer, generation, registration, live) {
+        this.assertActive();
+        const current = this.presentationBinding(producerId);
+        if (!live || !this.activePresentationRegistrations.has(registration)
+            || current?.producer !== producer || current.generation !== generation
+            || current.registration !== registration
+            || this.presentationProducerGeneration(producer) !== generation) {
+            throw new AssistantDeliveryError('runtime-conflict', 'stale trusted presentation producer capability');
+        }
+    }
+    publishTrustedDeliveryPresentation(producerId, input) {
+        this.assertActive();
+        if (typeof input !== 'object' || input === null || Array.isArray(input)
+            || typeof input.presentation !== 'object'
+            || input.presentation === null
+            || Array.isArray(input.presentation)) {
+            throw new AssistantDeliveryError('runtime-conflict', 'trusted presentation input is invalid');
+        }
+        const exactApproval = producerId === 'assistant-evolution'
+            && input.presentation.kind === 'approval-application'
+            && input.presentationKey === `approval-application:${input.presentation.policyProposalId}`
+            && input.originalOutboxIdempotencyKey === `approval-card:${input.presentation.policyProposalId}`;
+        const incidentKey = input.presentation.kind === 'automation-incident'
+            ? `automation-incident:${input.presentation.incidentId}:g${input.presentation.lifecycleGeneration}`
+            : undefined;
+        const exactIncident = producerId === 'assistant-automations'
+            && input.presentation.kind === 'automation-incident'
+            && input.presentationKey === incidentKey
+            && input.originalOutboxIdempotencyKey === incidentKey
+            && input.revision === input.presentation.incidentRevision;
+        if (!exactApproval && !exactIncident) {
+            throw new AssistantDeliveryError('runtime-conflict', 'presentation does not target its exact durable provider message');
+        }
+        const stored = this.deliveryStore.publishDeliveryPresentation(input);
+        void this.drainDeliveryPresentations();
+        return stored;
+    }
     isInboundAuthorized(binding, envelope) {
         if (!this.active)
             return false;
@@ -824,6 +1627,547 @@ export class AssistantDeliveryService extends Service {
             context: { initiator: 'external' },
         }).effect === 'allow';
     }
+    isOwnerFeedbackController(binding, envelope) {
+        if (!this.isInboundAuthorized(binding, envelope))
+            return false;
+        const principal = this.deliveryStore.getPrincipal(binding.principal);
+        const inbox = this.deliveryStore.getInboxByProviderEvent(envelope.channel, envelope.account, envelope.eventId);
+        if (principal?.status !== 'active' || principal.role !== 'owner'
+            || inbox?.status !== 'claimed'
+            || inbox.bindingId !== binding.id
+            || JSON.stringify(inbox.envelope) !== JSON.stringify(envelope)) {
+            return false;
+        }
+        return this.policy.evaluate({
+            subject: {
+                kind: 'agent',
+                id: binding.agentPreset,
+                workspace: binding.workspace,
+                principal: externalPrincipalId(binding.principal),
+            },
+            action: 'reply',
+            resource: { kind: 'message', id: binding.id },
+            context: { initiator: 'external' },
+        }).effect === 'allow';
+    }
+    ownerLineageForBinding(binding) {
+        const principal = this.deliveryStore.getPrincipal(binding.principal);
+        if (principal?.status !== 'active' || principal.role !== 'owner'
+            || JSON.stringify(principal.principal) !== JSON.stringify(binding.principal))
+            return undefined;
+        return Object.freeze({
+            principalRecordId: principal.id,
+            principalVersion: principal.version,
+        });
+    }
+    authorizeOwnerPreferenceFeedback(binding, envelope, selections) {
+        if (!this.isOwnerFeedbackController(binding, envelope)
+            || !Array.isArray(selections) || selections.length < 1 || selections.length > 16)
+            return undefined;
+        const inbox = this.deliveryStore.getInboxByProviderEvent(envelope.channel, envelope.account, envelope.eventId);
+        if (inbox?.status !== 'claimed' || inbox.bindingId !== binding.id
+            || JSON.stringify(inbox.envelope) !== JSON.stringify(envelope))
+            return undefined;
+        const principalLineage = this.ownerLineageForBinding(binding);
+        if (principalLineage === undefined)
+            return undefined;
+        const subject = {
+            kind: 'external',
+            id: externalPrincipalId(binding.principal),
+            workspace: binding.workspace,
+        };
+        const requests = selections.map(selection => ({
+            selection,
+            authorization: {
+                subject,
+                action: 'signal',
+                resource: { kind: 'preference', id: `${binding.agentPreset}/${selection.preferenceKey}` },
+                context: { initiator: 'external' },
+            },
+        }));
+        const denied = requests.find(entry => this.policy.evaluate(entry.authorization).effect !== 'allow');
+        if (denied !== undefined) {
+            this.policy.authorize(denied.authorization, {
+                idempotencyKey: this.preferenceSignalAuthorizationKey(binding, envelope, denied.authorization.resource.id, denied.selection.candidateValue),
+                auditDetails: { bindingVersion: binding.version },
+            });
+            return undefined;
+        }
+        for (const { authorization, selection } of requests) {
+            const decision = this.policy.authorize(authorization, {
+                idempotencyKey: this.preferenceSignalAuthorizationKey(binding, envelope, authorization.resource.id, selection.candidateValue),
+                auditDetails: { bindingVersion: binding.version },
+            });
+            if (decision.effect !== 'allow')
+                return undefined;
+        }
+        // Provider clocks are not authoritative. The locally persisted Inbox time
+        // is bounded by the same Host clock as Preference Learning's retention gate.
+        const replyTarget = envelope.metadata?.replyToProviderMessageId;
+        const sourceOutbox = typeof replyTarget === 'string'
+            ? this.deliveryStore.getOutboxByProviderMessage(envelope.channel, envelope.account, replyTarget)
+            : undefined;
+        const sourceEventId = sourceOutbox?.intent.replyToEventId;
+        const sourceInbox = sourceEventId === undefined
+            ? undefined
+            : this.deliveryStore.getInboxByProviderEvent(envelope.channel, envelope.account, sourceEventId);
+        const exposureTarget = sourceOutbox !== undefined
+            && sourceOutbox.providerMessageId === replyTarget
+            && sourceOutbox.intent.bindingId === binding.id
+            && sourceInbox?.status === 'processed'
+            && sourceInbox.bindingId === binding.id
+            && JSON.stringify(sourceOutbox.intent.target.conversation) === JSON.stringify(binding.conversation)
+            && JSON.stringify(sourceOutbox.intent.target.principal) === JSON.stringify(binding.principal)
+            ? Object.freeze({ sourceInboxId: sourceInbox.id, sourceOutboxId: sourceOutbox.id })
+            : undefined;
+        return Object.freeze({
+            occurredAt: inbox.receivedAt,
+            principalLineage,
+            admissionCursor: inbox.admissionCursor,
+            ...(exposureTarget === undefined ? {} : { exposureTarget }),
+        });
+    }
+    preferenceSignalAuthorizationKey(binding, envelope, resourceId, candidateValue) {
+        const digest = createHash('sha256').update('assistant-delivery-preference-authorization-v2\0')
+            .update(JSON.stringify([
+            binding.id,
+            binding.version,
+            envelope.channel,
+            envelope.account,
+            envelope.eventId,
+            resourceId,
+            candidateValue,
+        ]))
+            .digest('hex');
+        return `delivery-pref-auth:${digest}`;
+    }
+    async dispatchPreferenceFeedback(events) {
+        this.deliveryStore.enqueuePreferenceProjection(events);
+        // Preserve the Inbox admission order through the process-local sink. A
+        // later owner control must not overtake an earlier projection from another
+        // binding of the same owner scope.
+        await this.drainPreferenceProjections();
+        return 'recorded';
+    }
+    async dispatchLearningCommand(binding, envelope, action, preferenceKey) {
+        if (!this.isOwnerFeedbackController(binding, envelope))
+            return 'forbidden';
+        const inbox = this.deliveryStore.getInboxByProviderEvent(envelope.channel, envelope.account, envelope.eventId);
+        if (inbox?.status !== 'claimed' || inbox.bindingId !== binding.id
+            || JSON.stringify(inbox.envelope) !== JSON.stringify(envelope))
+            return 'forbidden';
+        const principalLineage = this.ownerLineageForBinding(binding);
+        if (principalLineage === undefined)
+            return 'forbidden';
+        const sink = this.preferenceFeedbackSink;
+        if (sink === undefined
+            || sink.registration.generation !== this.preferenceProducerGeneration
+            || !registrationOwnedByPreference(sink.registration)
+            || typeof sink.registration.control !== 'function')
+            return 'unavailable';
+        const idempotencyKey = `delivery-learning-control-v2:${createHash('sha256')
+            .update('assistant-delivery-learning-control-v2\0')
+            .update(JSON.stringify([
+            binding.id,
+            binding.version,
+            binding.sessionId,
+            principalLineage.principalRecordId,
+            principalLineage.principalVersion,
+            inbox.admissionCursor.epoch,
+            inbox.admissionCursor.sequence,
+            envelope.channel,
+            envelope.account,
+            envelope.eventId,
+            action,
+            preferenceKey ?? null,
+        ]))
+            .digest('hex')}`;
+        const request = Object.freeze({
+            scope: Object.freeze({ workspace: binding.workspace, preset: binding.agentPreset }),
+            principalId: externalPrincipalId(binding.principal),
+            principalLineage,
+            admissionCursor: inbox.admissionCursor,
+            action,
+            ...(preferenceKey === undefined ? {} : { preferenceKey }),
+            occurredAt: inbox.receivedAt,
+            idempotencyKey,
+        });
+        await this.drainPreferenceProjections();
+        if (this.deliveryStore.hasBlockingPreferenceProjectionBefore(request))
+            return 'unknown';
+        try {
+            const receipt = await sink.registration.control(request);
+            validateLearningControlReceipt(receipt, request);
+            return receipt;
+        }
+        catch {
+            return 'unknown';
+        }
+    }
+    completedPreferenceEvents(binding, envelope, reply) {
+        const directive = envelope.kind === 'text'
+            ? classifyNaturalPreferenceDirective(envelope.text)
+            : undefined;
+        const naturalSelection = directive?.kind === 'durable-exact-selection'
+            ? directive.selection
+            : undefined;
+        // A whole-message correction is an instruction, not representative task
+        // language. Keep it as one explicit signal instead of double-counting the
+        // language used to express the correction.
+        const candidateValue = envelope.kind === 'text' && directive?.kind === 'ordinary-content'
+            ? observedResponseLanguage(envelope.text)
+            : undefined;
+        if (!this.isOwnerFeedbackController(binding, envelope))
+            return undefined;
+        const inbox = this.deliveryStore.getInboxByProviderEvent(envelope.channel, envelope.account, envelope.eventId);
+        const durableReply = this.deliveryStore.getOutbox(reply.id);
+        const principalLineage = this.ownerLineageForBinding(binding);
+        if (inbox?.status !== 'claimed' || inbox.bindingId !== binding.id
+            || principalLineage === undefined
+            || durableReply?.id !== reply.id
+            || durableReply.intent.bindingId !== binding.id
+            || durableReply.intent.replyToEventId !== envelope.eventId
+            || durableReply.intent.idempotencyKey !== this.inboundReplyIdempotencyKey(binding, envelope.eventId)
+            || JSON.stringify(durableReply.intent.target.conversation) !== JSON.stringify(binding.conversation)
+            || JSON.stringify(durableReply.intent.target.principal) !== JSON.stringify(binding.principal)) {
+            throw new AssistantDeliveryError('runtime-conflict', 'completed preference turn does not match its durable reply');
+        }
+        const selections = [];
+        if (naturalSelection !== undefined)
+            selections.push(naturalSelection);
+        if (candidateValue !== undefined)
+            selections.push({
+                preferenceKey: 'response.language',
+                candidateValue,
+                interpretationTrust: 'typed-feedback',
+            });
+        const authorization = selections.length === 0
+            ? undefined
+            : this.authorizeOwnerPreferenceFeedback(binding, envelope, selections);
+        const completion = Object.freeze({
+            bindingId: binding.id,
+            bindingVersion: binding.version,
+            sessionId: binding.sessionId,
+            sourceEventId: envelope.eventId,
+            sourceInboxId: inbox.id,
+            replyOutboxId: durableReply.id,
+        });
+        const completionDigest = createHash('sha256')
+            .update('assistant-delivery-completed-preference-binding-v2\0')
+            .update(JSON.stringify([
+            binding.id,
+            binding.version,
+            binding.sessionId,
+            principalLineage.principalRecordId,
+            principalLineage.principalVersion,
+            inbox.admissionCursor.epoch,
+            inbox.admissionCursor.sequence,
+            inbox.id,
+            durableReply.id,
+            envelope.eventId,
+        ]))
+            .digest('hex');
+        const completionEvent = Object.freeze({
+            scope: Object.freeze({ workspace: binding.workspace, preset: binding.agentPreset }),
+            principalId: externalPrincipalId(binding.principal),
+            principalLineage,
+            admissionCursor: inbox.admissionCursor,
+            actorTrust: 'owner-authenticated',
+            source: 'delivery-completion',
+            occurredAt: inbox.receivedAt,
+            idempotencyKey: `delivery-completed-binding-v2:${completionDigest}`,
+            completion,
+        });
+        const events = [];
+        if (naturalSelection !== undefined && authorization !== undefined) {
+            events.push(completionEvent);
+            events.push(feedbackSignalInput(binding, envelope, naturalSelection, authorization));
+        }
+        if (candidateValue !== undefined && authorization !== undefined) {
+            const digest = createHash('sha256')
+                .update('assistant-delivery-completed-preference-turn-v2\0')
+                .update(JSON.stringify([
+                binding.id,
+                binding.version,
+                binding.sessionId,
+                principalLineage.principalRecordId,
+                principalLineage.principalVersion,
+                inbox.admissionCursor.epoch,
+                inbox.admissionCursor.sequence,
+                inbox.id,
+                durableReply.id,
+                envelope.eventId,
+                candidateValue,
+            ]))
+                .digest('hex');
+            const event = Object.freeze({
+                scope: Object.freeze({ workspace: binding.workspace, preset: binding.agentPreset }),
+                principalId: externalPrincipalId(binding.principal),
+                principalLineage,
+                admissionCursor: inbox.admissionCursor,
+                preferenceKey: 'response.language',
+                candidateValue,
+                stance: 'support',
+                actorTrust: 'owner-authenticated',
+                interpretationTrust: 'behavioral-inference',
+                source: 'delivery-observation',
+                occurredAt: inbox.receivedAt,
+                idempotencyKey: `delivery-completed-turn-v2:${digest}`,
+                completion,
+            });
+            events.push(event);
+        }
+        if (events.length === 0)
+            events.push(completionEvent);
+        return Object.freeze(events);
+    }
+    async dispatchWorkflowCommand(binding, envelope, command) {
+        const replyTarget = envelope.metadata?.replyToProviderMessageId;
+        if (typeof replyTarget !== 'string' || !this.isOwnerFeedbackController(binding, envelope)) {
+            return 'invalid-target';
+        }
+        const reviewInbox = this.deliveryStore.getInboxByProviderEvent(envelope.channel, envelope.account, envelope.eventId);
+        const sourceOutbox = this.deliveryStore.getOutboxByProviderMessage(envelope.channel, envelope.account, replyTarget);
+        const sourceEventId = sourceOutbox?.intent.replyToEventId;
+        const sourceInbox = sourceEventId === undefined
+            ? undefined
+            : this.deliveryStore.getInboxByProviderEvent(envelope.channel, envelope.account, sourceEventId);
+        if (reviewInbox?.status !== 'claimed' || reviewInbox.bindingId !== binding.id
+            || sourceInbox?.status !== 'processed' || sourceInbox.bindingId !== binding.id
+            || sourceInbox.envelope.kind !== 'text'
+            || (sourceInbox.envelope.attachments?.length ?? 0) !== 0
+            || sourceOutbox === undefined || sourceOutbox.providerMessageId !== replyTarget
+            || sourceOutbox.intent.bindingId !== binding.id
+            || JSON.stringify(sourceInbox.envelope.conversation) !== JSON.stringify(binding.conversation)
+            || JSON.stringify(sourceInbox.envelope.principal) !== JSON.stringify(binding.principal)
+            || JSON.stringify(sourceOutbox.intent.target.conversation) !== JSON.stringify(binding.conversation)
+            || JSON.stringify(sourceOutbox.intent.target.principal) !== JSON.stringify(binding.principal)) {
+            return 'invalid-target';
+        }
+        const subjectRef = growthObjectDigest({
+            contract: 'assistant-delivery-owner-workflow-subject/v1',
+            workspace: binding.workspace,
+            preset: binding.agentPreset,
+            bindingId: binding.id,
+            sourceInboxId: sourceInbox.id,
+            sourceOutboxId: sourceOutbox.id,
+        });
+        const taskRef = growthObjectDigest({
+            contract: 'assistant-delivery-owner-task-ref/v1',
+            workspace: binding.workspace,
+            preset: binding.agentPreset,
+            sourceInboxId: sourceInbox.id,
+        });
+        const payloadDigest = growthObjectDigest({
+            contract: 'assistant-delivery-owner-workflow-command/v1',
+            action: command.kind === 'save' ? 'upsert' : 'retract',
+            reviewInboxId: reviewInbox.id,
+            sourceInboxId: sourceInbox.id,
+            sourceOutboxId: sourceOutbox.id,
+            subjectRef,
+            ...(command.kind === 'save'
+                ? { name: command.name, cron: command.cron, timezone: command.timezone }
+                : {}),
+        });
+        try {
+            this.deliveryStore.commitOwnerWorkflowTraceCommand({
+                action: command.kind === 'save' ? 'upsert' : 'retract',
+                operationId: `workflow-command:${reviewInbox.id}`,
+                payloadDigest,
+                binding,
+                reviewInboxId: reviewInbox.id,
+                sourceInboxId: sourceInbox.id,
+                sourceOutboxId: sourceOutbox.id,
+                subjectRef,
+                occurredAt: sourceInbox.receivedAt,
+                ...(command.kind === 'save' ? {
+                    taskRef,
+                    templateContent: {
+                        scope: { workspace: binding.workspace, preset: binding.agentPreset },
+                        ownerBindingId: binding.id,
+                        name: command.name,
+                        prompt: sourceInbox.envelope.text,
+                        schedule: { kind: 'cron', expression: command.cron, timezone: command.timezone },
+                        timeoutMs: 60_000,
+                        toolCatalogIds: ['assistant.agent-turn'],
+                        deliveryBindingId: binding.id,
+                    },
+                    steps: [{
+                            catalogId: 'assistant.agent-turn',
+                            argumentSchemaDigest: workflowArgumentShapeDigest({ prompt: sourceInbox.envelope.text }),
+                        }],
+                } : {}),
+            });
+        }
+        catch (error) {
+            if (error instanceof DeliveryStoreError) {
+                if (error.code === 'idempotency-conflict' || error.code === 'version-conflict')
+                    return 'conflict';
+                if (error.code === 'invalid-binding' || error.code === 'unauthorized-principal'
+                    || error.code === 'receipt-mismatch' || error.code === 'conflict')
+                    return 'invalid-target';
+            }
+            return 'invalid-target';
+        }
+        void this.drainWorkflowTraces();
+        return 'recorded';
+    }
+    /**
+     * Convert only an authenticated reply to one exact Automation delivery into
+     * a trusted objective label. The original run timestamp is retained because
+     * Evolution re-proves the immutable production run; the later Inbox is a
+     * separate evidence reference, never copied as prose.
+     */
+    async dispatchObjectiveFeedback(binding, envelope, objectiveStatus) {
+        const replyTarget = envelope.metadata?.replyToProviderMessageId;
+        if (typeof replyTarget !== 'string')
+            return 'invalid-target';
+        if (!this.isOwnerFeedbackController(binding, envelope))
+            return 'invalid-target';
+        const inbox = this.deliveryStore.getInboxByProviderEvent(envelope.channel, envelope.account, envelope.eventId);
+        const target = this.deliveryStore.getOutboxByProviderMessage(envelope.channel, envelope.account, replyTarget);
+        if (inbox?.status !== 'claimed' || inbox.bindingId !== binding.id
+            || target === undefined || target.providerMessageId !== replyTarget
+            || target.intent.bindingId !== binding.id
+            || JSON.stringify(target.intent.target.conversation) !== JSON.stringify(binding.conversation)
+            || JSON.stringify(target.intent.target.principal) !== JSON.stringify(binding.principal)) {
+            return 'invalid-target';
+        }
+        const metadata = target.intent.metadata;
+        // Ordinary Agent replies have no learning metadata.  They are eligible
+        // only for Delivery's local, atomic verified-workflow receipt; the Store
+        // rebuilds the full Inbox/Outbox fence and abstains unless the source text
+        // selects a closed deterministic-deidentification template.  Do not route
+        // these judgements through Evaluation: they are task proof for workflow
+        // repetition, not a cross-plugin quality vote.
+        if (metadata?.['dsh.learning.kind'] !== 'automation-run') {
+            const sourceEventId = target.intent.replyToEventId;
+            if (typeof sourceEventId !== 'string')
+                return 'invalid-target';
+            const sourceInbox = this.deliveryStore.getInboxByProviderEvent(envelope.channel, envelope.account, sourceEventId);
+            if (sourceInbox === undefined)
+                return 'invalid-target';
+            try {
+                const recorded = this.deliveryStore.commitVerifiedWorkflowTraceFeedback({
+                    binding,
+                    feedbackInboxId: inbox.id,
+                    sourceInboxId: sourceInbox.id,
+                    sourceOutboxId: target.id,
+                    objectiveStatus,
+                });
+                if (recorded.outcome === 'trace-recorded')
+                    void this.drainWorkflowTraces();
+                return 'recorded';
+            }
+            catch (error) {
+                if (error instanceof DeliveryStoreError) {
+                    if (error.code === 'idempotency-conflict' || error.code === 'version-conflict') {
+                        return 'conflict';
+                    }
+                    if (error.code === 'invalid-binding' || error.code === 'unauthorized-principal'
+                        || error.code === 'receipt-mismatch' || error.code === 'conflict'
+                        || error.code === 'not-found')
+                        return 'invalid-target';
+                }
+                return 'invalid-target';
+            }
+        }
+        const automationId = metadata?.['dsh.learning.automationId'];
+        const runId = metadata?.['dsh.learning.runId'];
+        const situation = metadata?.['dsh.learning.situation'];
+        const occurredAtText = metadata?.['dsh.learning.occurredAt'];
+        const outputDigest = metadata?.['dsh.learning.outputDigest'];
+        const proofDigest = metadata?.['dsh.learning.proofDigest'];
+        if (metadata?.['dsh.learning.schemaVersion'] !== '2'
+            || metadata['dsh.learning.kind'] !== 'automation-run'
+            || metadata['dsh.learning.executionStatus'] !== 'succeeded'
+            || typeof automationId !== 'string' || typeof runId !== 'string'
+            || typeof situation !== 'string' || situation !== `automation:${automationId}`
+            || typeof outputDigest !== 'string' || !/^[a-f0-9]{64}$/u.test(outputDigest)
+            || typeof proofDigest !== 'string' || !/^[a-f0-9]{64}$/u.test(proofDigest)
+            || typeof occurredAtText !== 'string' || !/^(0|[1-9][0-9]{0,15})$/u.test(occurredAtText)) {
+            return 'invalid-target';
+        }
+        const occurredAt = Number(occurredAtText);
+        if (!Number.isSafeInteger(occurredAt) || occurredAt > inbox.receivedAt)
+            return 'invalid-target';
+        if (!target.intent.text.endsWith(automationObjectiveFeedbackFooter))
+            return 'invalid-target';
+        const outputPreview = target.intent.text.slice(0, -automationObjectiveFeedbackFooter.length);
+        if (createHash('sha256').update(outputPreview).digest('hex') !== outputDigest)
+            return 'invalid-target';
+        const resolver = this.context.get('assistantAutomations');
+        if (!isAutomationDeliveryEvidenceResolver(resolver))
+            return 'unavailable';
+        let proof;
+        try {
+            proof = resolver.resolveDeliveryEvidence({
+                automationId,
+                runId,
+                expectedWorkspace: binding.workspace,
+                expectedBindingId: binding.id,
+                expectedOutputDigest: outputDigest,
+            });
+        }
+        catch {
+            return 'invalid-target';
+        }
+        if (proof === undefined || proof.schemaVersion !== 1 || proof.source !== 'assistant-automations'
+            || proof.executionKind !== 'agent' || proof.executionStatus !== 'succeeded'
+            || proof.automationId !== automationId || proof.runId !== runId
+            || proof.workspace !== binding.workspace || proof.agentPreset !== binding.agentPreset
+            || proof.bindingId !== binding.id || proof.situation !== situation
+            || proof.occurredAt !== occurredAt || proof.outputDigest !== outputDigest
+            || proof.proofDigest !== proofDigest)
+            return 'invalid-target';
+        const sink = this.evaluationSink;
+        if (sink === undefined)
+            return 'unavailable';
+        // One immutable Automation run is one learning subject. The objective
+        // status and Inbox event deliberately do not enter the key: replays and
+        // repeated equal judgements collapse, while an opposite judgement becomes
+        // an explicit conflict instead of a second Evolution vote.
+        const digest = createHash('sha256').update('assistant-delivery-objective-feedback-v2\0')
+            .update(JSON.stringify([binding.workspace, binding.agentPreset, target.id, runId]))
+            .digest('hex');
+        const claims = Object.freeze({
+            scope: Object.freeze({ workspace: binding.workspace, preset: binding.agentPreset }),
+            situation,
+            objectiveStatus,
+            runId,
+            outboxId: target.id,
+            chatId: binding.conversation.chat,
+            principalId: externalPrincipalId(binding.principal),
+            bindingId: binding.id,
+            occurredAt,
+            idempotencyKey: `assistant-delivery:objective-feedback-v2:${digest}`,
+        });
+        try {
+            const capabilityReceipt = sink.registration.issueCapability(claims);
+            if (this.evaluationSink?.token !== sink.token)
+                return 'unknown';
+            const receipt = await Promise.resolve(sink.registration.append({
+                capabilityReceipt,
+                runId,
+                outboxId: target.id,
+                chatId: binding.conversation.chat,
+                principalId: externalPrincipalId(binding.principal),
+                bindingId: binding.id,
+                idempotencyKey: claims.idempotencyKey,
+            }));
+            if (typeof receipt !== 'object' || receipt === null
+                || receipt.idempotencyKey !== claims.idempotencyKey) {
+                return 'unknown';
+            }
+            return 'recorded';
+        }
+        catch (error) {
+            if (typeof error === 'object' && error !== null && 'code' in error
+                && error.code === 'idempotency-conflict')
+                return 'conflict';
+            return 'unknown';
+        }
+    }
     authorizePermissionReply(binding, envelope) {
         if (!this.isPermissionController(binding, envelope))
             return false;
@@ -1228,6 +2572,9 @@ export class AssistantDeliveryService extends Service {
     }
     enqueueBackground(input) {
         this.assertActive();
+        if (containsReservedLearningMetadata(input.metadata)) {
+            throw new AssistantDeliveryError('runtime-conflict', 'reserved learning metadata requires the typed Automation result seam');
+        }
         const binding = this.deliveryStore.getBinding(input.bindingId);
         if (binding === undefined || binding.status !== 'active' || !this.hasActivePrincipal(binding)) {
             throw new AssistantDeliveryError('missing-binding', 'delivery binding does not exist or is revoked');
@@ -1245,15 +2592,198 @@ export class AssistantDeliveryService extends Service {
         }
         return this.deliveryStore.enqueue({ idempotencyKey: input.idempotencyKey, bindingId: binding.id,
             target: { conversation: binding.conversation, principal: binding.principal }, text: input.text,
-            format: input.format ?? 'plain' });
+            format: input.format ?? 'plain',
+            ...(input.metadata === undefined ? {} : { metadata: input.metadata }) });
     }
-    enqueueApproval(input) {
+    /**
+     * Dedicated Automation result lane. Every learning field is derived from an
+     * authoritative Automations receipt; callers cannot supply metadata,
+     * idempotency, source identity, occurrence, timestamp, or feedback text.
+     */
+    enqueueAutomationResult(input) {
         this.assertActive();
+        if (typeof input.outputPreview !== 'string') {
+            throw new AssistantDeliveryError('runtime-conflict', 'Automation result output is invalid');
+        }
+        const outputDigest = createHash('sha256').update(input.outputPreview).digest('hex');
+        const resolver = this.context.get('assistantAutomations');
+        if (!isAutomationDeliveryEvidenceResolver(resolver)) {
+            throw new AssistantDeliveryError('runtime-conflict', 'Automation delivery evidence is unavailable');
+        }
+        let proof;
+        try {
+            proof = resolver.resolveDeliveryEvidence({
+                automationId: input.automationId,
+                runId: input.runId,
+                expectedWorkspace: input.workspace,
+                expectedBindingId: input.bindingId,
+                expectedOutputDigest: outputDigest,
+            });
+        }
+        catch {
+            throw new AssistantDeliveryError('runtime-conflict', 'Automation delivery evidence was rejected');
+        }
+        if (proof === undefined || proof.schemaVersion !== 1 || proof.source !== 'assistant-automations'
+            || proof.executionKind !== 'agent' || proof.executionStatus !== 'succeeded'
+            || proof.automationId !== input.automationId || proof.runId !== input.runId
+            || proof.workspace !== input.workspace || proof.bindingId !== input.bindingId
+            || proof.situation !== `automation:${input.automationId}`
+            || proof.outputDigest !== outputDigest || !/^[a-f0-9]{64}$/u.test(proof.proofDigest)
+            || !Number.isSafeInteger(proof.occurredAt) || proof.occurredAt < 0) {
+            throw new AssistantDeliveryError('runtime-conflict', 'Automation delivery evidence is mismatched');
+        }
         const binding = this.deliveryStore.getBinding(input.bindingId);
+        if (binding === undefined || binding.status !== 'active' || !this.hasActivePrincipal(binding)
+            || binding.workspace !== input.workspace || binding.agentPreset !== proof.agentPreset) {
+            throw new AssistantDeliveryError('missing-binding', 'Automation result binding is unavailable or mismatched');
+        }
+        const decision = this.policy.authorize({
+            subject: { kind: 'background', id: proof.automationId,
+                workspace: proof.workspace, principal: externalPrincipalId(binding.principal) },
+            action: 'send', resource: { kind: 'message', id: binding.id }, context: { initiator: 'background' },
+        }, { idempotencyKey: `message-send:automation:${proof.occurrenceId}:${binding.id}` });
+        if (decision.effect !== 'allow')
+            throw policyDenied(decision);
+        if (!this.hasActivePrincipal(binding)) {
+            throw new AssistantDeliveryError('missing-binding', 'delivery binding principal is no longer active');
+        }
+        const text = `${input.outputPreview}${automationObjectiveFeedbackFooter}`;
+        if (Buffer.byteLength(text, 'utf8') > this.config.maxTextBytes) {
+            throw new AssistantDeliveryError('runtime-conflict', 'Automation result exceeds the delivery text limit');
+        }
+        return this.deliveryStore.enqueue({
+            idempotencyKey: `automation:${proof.occurrenceId}:${binding.id}`,
+            bindingId: binding.id,
+            target: { conversation: binding.conversation, principal: binding.principal },
+            text,
+            format: 'markdown',
+            metadata: Object.freeze({
+                'dsh.learning.schemaVersion': '2',
+                'dsh.learning.kind': 'automation-run',
+                'dsh.learning.automationId': proof.automationId,
+                'dsh.learning.runId': proof.runId,
+                'dsh.learning.situation': proof.situation,
+                'dsh.learning.occurredAt': String(proof.occurredAt),
+                'dsh.learning.executionStatus': proof.executionStatus,
+                'dsh.learning.outputDigest': proof.outputDigest,
+                'dsh.learning.proofDigest': proof.proofDigest,
+            }),
+        });
+    }
+    /** Resolve the current generation of one exact Host-owned owner route. */
+    resolveOwnerRoute(authorityIdInput) {
+        this.assertActive();
+        const authorityId = canonicalOwnerRouteId(authorityIdInput);
+        const authority = this.ownerRoutes.get(authorityId);
+        if (authority === undefined) {
+            throw new AssistantDeliveryError('missing-binding', 'owner route authority is not configured');
+        }
+        const binding = this.deliveryStore.getActiveBinding(authority.conversation);
+        const owner = binding === undefined ? undefined : this.deliveryStore.getPrincipal(binding.principal);
+        if (binding === undefined || binding.status !== 'active'
+            || !bindingMatchesOwnerRoute(binding, authority)
+            || owner?.status !== 'active' || owner.role !== 'owner') {
+            throw new AssistantDeliveryError('missing-binding', 'active binding does not match owner route authority');
+        }
+        return {
+            authorityId,
+            binding,
+            snapshot: ownerRouteBindingSnapshot(authority, binding),
+        };
+    }
+    /**
+     * Revalidate Recovery/other Host work against the live owner route without
+     * exposing a session id, conversation id, user message or delivery content.
+     */
+    validateOwnerRoute(input) {
+        this.assertActive();
+        const resolved = this.resolveOwnerRoute(input.authorityId);
+        const authority = this.ownerRoutes.get(resolved.authorityId);
+        const principalLineage = this.ownerLineageForBinding(resolved.binding);
+        if (principalLineage === undefined) {
+            throw new AssistantDeliveryError('missing-binding', 'owner route principal lineage is unavailable');
+        }
+        const expectedPrincipal = externalPrincipalId(authority.principal);
+        const text = (value, label, maxBytes) => {
+            if (typeof value !== 'string') {
+                throw new AssistantDeliveryError('missing-binding', `owner route ${label} is invalid`);
+            }
+            const normalized = value.normalize('NFC').trim();
+            const hasControl = [...normalized].some(character => {
+                const point = character.codePointAt(0);
+                return point <= 0x1f || point === 0x7f;
+            });
+            if (normalized === '' || Buffer.byteLength(normalized, 'utf8') > maxBytes || hasControl) {
+                throw new AssistantDeliveryError('missing-binding', `owner route ${label} is invalid`);
+            }
+            return normalized;
+        };
+        const principalId = text(input.principalId, 'principal', 1_024);
+        const workspace = text(input.workspace, 'workspace', 4_096);
+        const agentPreset = text(input.agentPreset, 'preset', 200);
+        if (principalId !== expectedPrincipal || workspace !== authority.workspace
+            || agentPreset !== authority.agentPreset) {
+            throw new AssistantDeliveryError('missing-binding', 'owner route authority does not match the requested scope');
+        }
+        return Object.freeze({
+            receiptVersion: 2,
+            authorityId: resolved.authorityId,
+            authorityHash: resolved.snapshot.authorityHash,
+            principalId,
+            principalRecordId: principalLineage.principalRecordId,
+            principalVersion: principalLineage.principalVersion,
+            workspace,
+            agentPreset,
+            bindingVersion: resolved.snapshot.bindingVersion,
+            generation: resolved.snapshot.generation,
+        });
+    }
+    /**
+     * Enqueue against a stable Host-owned route rather than a session binding.
+     * Policy is evaluated against the exact `route:<authorityId>` resource. The
+     * Store re-resolves under its write transaction, so a concurrent `/new`
+     * either wins completely or follows the earlier immutable Outbox receipt.
+     */
+    enqueueBackgroundRoute(input) {
+        this.assertActive();
+        const sourceId = canonicalBackgroundSourceId(input.sourceId);
+        const idempotencyKey = canonicalRouteIdempotencyKey(input.idempotencyKey);
+        if (typeof input.text !== 'string' || Buffer.byteLength(input.text, 'utf8') > this.config.maxTextBytes
+            || (input.format !== undefined && input.format !== 'markdown' && input.format !== 'plain')) {
+            throw new AssistantDeliveryError('runtime-conflict', 'owner route message is invalid');
+        }
+        const resolved = this.resolveOwnerRoute(input.authorityId);
+        const authority = this.ownerRoutes.get(resolved.authorityId);
+        const decision = authorizeOwnerRoute(this.policy, authority, sourceId, idempotencyKey);
+        if (decision.effect !== 'allow')
+            throw policyDenied(decision);
+        try {
+            return this.deliveryStore.enqueueOwnerRoute({
+                authority,
+                sourceId,
+                sourceHash: createHash('sha256').update(sourceId).digest('hex'),
+                idempotencyKey,
+                text: input.text,
+                format: input.format ?? 'plain',
+            });
+        }
+        catch (error) {
+            if (error instanceof DeliveryStoreError && error.code === 'invalid-binding') {
+                throw new AssistantDeliveryError('missing-binding', 'owner route changed during enqueue');
+            }
+            throw error;
+        }
+    }
+    enqueueApproval(input) {
+        this.assertActive();
+        if (input.route?.routeVersion !== 2) {
+            throw new AssistantDeliveryError('missing-binding', 'approval dispatch requires an exact v2 owner route');
+        }
+        const binding = this.deliveryStore.getBinding(input.route.bindingId);
         if (binding === undefined || binding.status !== 'active') {
             throw new AssistantDeliveryError('missing-binding', 'delivery binding does not exist or is revoked');
         }
-        if (binding.workspace !== input.workspace) {
+        if (binding.workspace !== input.route.workspace) {
             throw new AssistantDeliveryError('missing-binding', 'delivery workspace does not match the active binding');
         }
         const owner = this.deliveryStore.getPrincipal(binding.principal);
@@ -1269,14 +2799,23 @@ export class AssistantDeliveryService extends Service {
             || createHash('sha256').update(input.text).digest('hex') !== proposal.diffHash) {
             throw new AssistantDeliveryError('missing-binding', 'approval card does not match its active owner and Policy proposal');
         }
-        const decision = this.policy.authorize({ subject: { kind: 'background', id: input.sourceId,
-                workspace: input.workspace, principal }, action: 'approval.send',
+        const decision = this.policy.authorize({ subject: { kind: 'background', id: input.route.sourceId,
+                workspace: input.route.workspace, principal }, action: 'approval.send',
             resource: { kind: 'message', id: binding.id }, context: { initiator: 'background' } }, { idempotencyKey: `message-approval:${input.idempotencyKey}` });
         if (decision.effect !== 'allow')
             throw policyDenied(decision);
-        return this.deliveryStore.enqueue({ idempotencyKey: input.idempotencyKey, bindingId: binding.id,
-            target: { conversation: binding.conversation, principal: binding.principal }, text: input.text,
-            format: 'approval', approval: input.approval });
+        try {
+            return this.deliveryStore.enqueueApprovalRoute({ route: input.route, intent: {
+                    idempotencyKey: input.idempotencyKey, text: input.text, approval: input.approval,
+                } });
+        }
+        catch (error) {
+            if (error instanceof DeliveryStoreError
+                && (error.code === 'invalid-binding' || error.code === 'invalid-intent')) {
+                throw new AssistantDeliveryError('missing-binding', 'approval route changed or is invalid');
+            }
+            throw error;
+        }
     }
     replyCommand(bindingInput, input) {
         this.assertActive();
@@ -1335,6 +2874,33 @@ export class AssistantDeliveryService extends Service {
         return adapter?.capabilities.formats.includes('markdown') === true ? 'markdown' : 'plain';
     }
     reply(agent, input) {
+        const prepared = this.prepareAgentReply(agent, input);
+        return this.deliveryStore.enqueue(prepared.intent);
+    }
+    async replyCompletedPreferenceTurn(agent, expectedBinding, envelope, input) {
+        const prepared = this.prepareAgentReply(agent, {
+            idempotencyKey: `inbound:${envelope.eventId}:reply`,
+            replyToEventId: envelope.eventId,
+            ...input,
+        });
+        if (prepared.binding.id !== expectedBinding.id
+            || prepared.binding.version !== expectedBinding.version
+            || prepared.binding.sessionId !== expectedBinding.sessionId
+            || JSON.stringify(envelope.conversation) !== JSON.stringify(prepared.binding.conversation)
+            || JSON.stringify(envelope.principal) !== JSON.stringify(prepared.binding.principal)) {
+            throw new AssistantDeliveryError('missing-binding', 'completed turn no longer belongs to its exact Delivery binding');
+        }
+        let projected = false;
+        this.deliveryStore.enqueueReplyWithPreferenceProjection(prepared.intent, reply => {
+            const events = this.completedPreferenceEvents(prepared.binding, envelope, reply);
+            projected = events !== undefined;
+            return events;
+        });
+        if (projected)
+            await this.drainPreferenceProjections();
+        return projected ? 'recorded' : 'unavailable';
+    }
+    prepareAgentReply(agent, input) {
         this.assertActive();
         const binding = agent === undefined ? undefined : this.deliveryStore.getBindingBySession(String(agent.session.id));
         if (agent === undefined || binding === undefined || binding.status !== 'active'
@@ -1355,14 +2921,15 @@ export class AssistantDeliveryService extends Service {
             throw new AssistantDeliveryError('missing-binding', 'Agent delivery principal is no longer active');
         }
         const format = this.replyFormat(binding.conversation, input.format) ?? 'plain';
-        return this.deliveryStore.enqueue({ idempotencyKey, bindingId: binding.id,
+        const intent = { idempotencyKey, bindingId: binding.id,
             target: { conversation: binding.conversation, principal: binding.principal }, text: input.text,
             format,
             ...(input.modelPicker === undefined ? {} : { modelPicker: input.modelPicker }),
             ...(format !== 'permission-picker' || input.permissionPicker === undefined
                 ? {}
                 : { permissionPicker: input.permissionPicker }),
-            ...(input.replyToEventId === undefined ? {} : { replyToEventId: input.replyToEventId }) });
+            ...(input.replyToEventId === undefined ? {} : { replyToEventId: input.replyToEventId }) };
+        return Object.freeze({ binding, intent: Object.freeze(intent) });
     }
     history(agent, input) {
         this.assertActive();
@@ -1419,8 +2986,17 @@ export class AssistantDeliveryService extends Service {
             || agent.session.header.agentPreset !== binding.agentPreset) {
             throw new AssistantDeliveryError('missing-binding', 'Agent session has no authenticated active owner approval route');
         }
-        return Object.freeze({ sourceId, bindingId: binding.id, workspace: binding.workspace,
-            principal: externalPrincipalId(binding.principal) });
+        return Object.freeze({
+            routeVersion: 2,
+            sourceId,
+            bindingId: binding.id,
+            bindingVersion: binding.version,
+            bindingGeneration: binding.generation,
+            workspace: binding.workspace,
+            principal: externalPrincipalId(binding.principal),
+            principalRecordId: owner.id,
+            principalVersion: owner.version,
+        });
     }
     async tick() {
         this.assertActive();
@@ -1428,10 +3004,20 @@ export class AssistantDeliveryService extends Service {
         await this.drainModelSelectionSettlements();
         this.drainApprovalDispatches();
         await this.outbound.tick();
+        await this.drainDeliveryPresentations();
+        await this.drainPreferenceProjections();
+        await this.drainWorkflowTraces();
     }
     async whenIdle() {
         this.assertActive();
-        await Promise.all([this.inbound.whenIdle(), this.outbound.whenIdle(), this.modelSelectionFlight]);
+        await Promise.all([
+            this.inbound.whenIdle(),
+            this.outbound.whenIdle(),
+            this.modelSelectionFlight,
+            this.presentationFlight,
+            this.preferenceProjectionFlight,
+            this.workflowTraceFlight,
+        ]);
     }
     start() {
         this.assertActive();
@@ -1591,10 +3177,183 @@ export class AssistantDeliveryService extends Service {
             clearInterval(this.timer);
         if (this.modelSelectionRetryTimer !== undefined)
             clearTimeout(this.modelSelectionRetryTimer);
+        if (this.workflowTraceRetryTimer !== undefined)
+            clearTimeout(this.workflowTraceRetryTimer);
+        if (this.preferenceProjectionRetryTimer !== undefined)
+            clearTimeout(this.preferenceProjectionRetryTimer);
         this.timer = undefined;
         this.modelSelectionRetryTimer = undefined;
+        this.workflowTraceRetryTimer = undefined;
+        this.preferenceProjectionRetryTimer = undefined;
         this.cancelModelSelectionWaiters();
-        await Promise.all([this.inbound.stop(), this.outbound.stop(), this.modelSelectionFlight]);
+        await Promise.all([
+            this.inbound.stop(),
+            this.outbound.stop(),
+            this.modelSelectionFlight,
+            this.presentationFlight,
+            this.preferenceProjectionFlight,
+            this.workflowTraceFlight,
+        ]);
+    }
+    drainPreferenceProjections() {
+        if (this.preferenceProjectionRetryTimer !== undefined) {
+            clearTimeout(this.preferenceProjectionRetryTimer);
+            this.preferenceProjectionRetryTimer = undefined;
+        }
+        if (this.preferenceProjectionFlight !== undefined)
+            return this.preferenceProjectionFlight;
+        const flight = this.runPreferenceProjection()
+            .finally(() => {
+            if (this.preferenceProjectionFlight === flight)
+                this.preferenceProjectionFlight = undefined;
+        });
+        this.preferenceProjectionFlight = flight;
+        return flight;
+    }
+    async runPreferenceProjection() {
+        const sink = this.preferenceFeedbackSink;
+        if (sink === undefined)
+            return;
+        let attempted = 0;
+        while (attempted < 100) {
+            const entries = this.deliveryStore.listPendingPreferenceProjections(100 - attempted);
+            if (entries.length === 0)
+                break;
+            for (const entry of entries) {
+                if (!this.active || this.preferenceFeedbackSink?.token !== sink.token)
+                    return;
+                attempted += 1;
+                try {
+                    if (sink.registration.appendSynchronously !== undefined) {
+                        this.deliveryStore.projectPreferenceProjectionUnderOwnerFence(entry, current => {
+                            if (!this.active || this.preferenceFeedbackSink?.token !== sink.token
+                                || !registrationOwnedByPreference(sink.registration)) {
+                                throw Object.assign(new Error('stale Preference projection registration'), {
+                                    code: 'stale-registration',
+                                });
+                            }
+                            const receipts = sink.registration.appendSynchronously(current.events);
+                            validatePreferenceProjectionReceipts(receipts, current.events);
+                        });
+                    }
+                    else {
+                        // Rolling-upgrade fallback. It still rechecks immediately before
+                        // sink I/O; current in-process Preference registrations use the
+                        // synchronous path above to close the remaining check/use window.
+                        if (!this.deliveryStore.preferenceProjectionHasCurrentOwner(entry))
+                            continue;
+                        const receipts = await Promise.resolve(sink.registration.append(entry.events));
+                        validatePreferenceProjectionReceipts(receipts, entry.events);
+                        if (!this.active || this.preferenceFeedbackSink?.token !== sink.token)
+                            return;
+                        this.deliveryStore.completePreferenceProjection({
+                            batchKey: entry.batchKey,
+                            payloadDigest: entry.payloadDigest,
+                        });
+                    }
+                }
+                catch (error) {
+                    if (!this.active || this.preferenceFeedbackSink?.token !== sink.token)
+                        return;
+                    const now = Date.now();
+                    const retryAt = now + Math.min(this.config.retryMaxMs, this.config.retryBaseMs * (2 ** Math.min(30, entry.attemptCount)));
+                    const code = typeof error === 'object' && error !== null && 'code' in error
+                        && typeof error.code === 'string'
+                        ? `sink-${error.code}`.slice(0, 64)
+                        : 'sink-projection-failed';
+                    this.deliveryStore.deferPreferenceProjection({
+                        batchKey: entry.batchKey,
+                        payloadDigest: entry.payloadDigest,
+                        now,
+                        retryAt,
+                        failureCode: /^[A-Za-z0-9][A-Za-z0-9._:-]{0,63}$/u.test(code)
+                            ? code
+                            : 'sink-projection-failed',
+                    });
+                }
+            }
+        }
+        const nextRetryAt = this.deliveryStore.nextPreferenceProjectionAttemptAt();
+        if (nextRetryAt !== undefined && this.preferenceFeedbackSink?.token === sink.token
+            && this.preferenceProjectionRetryTimer === undefined) {
+            this.preferenceProjectionRetryTimer = setTimeout(() => {
+                this.preferenceProjectionRetryTimer = undefined;
+                if (this.active)
+                    void this.drainPreferenceProjections();
+            }, Math.max(1, Math.min(2_147_483_647, nextRetryAt - Date.now())));
+            this.preferenceProjectionRetryTimer.unref?.();
+        }
+    }
+    /** Host test/operator seam: project due trace revisions without waiting for the scheduler. */
+    projectWorkflowTraces() {
+        this.assertActive();
+        return this.drainWorkflowTraces();
+    }
+    drainWorkflowTraces() {
+        if (this.workflowTraceRetryTimer !== undefined) {
+            clearTimeout(this.workflowTraceRetryTimer);
+            this.workflowTraceRetryTimer = undefined;
+        }
+        if (this.workflowTraceFlight !== undefined)
+            return this.workflowTraceFlight;
+        const flight = this.runWorkflowTraceProjection()
+            .finally(() => { if (this.workflowTraceFlight === flight)
+            this.workflowTraceFlight = undefined; });
+        this.workflowTraceFlight = flight;
+        return flight;
+    }
+    async runWorkflowTraceProjection() {
+        const registration = this.workflowTraceSink;
+        if (registration === undefined)
+            return;
+        const entries = this.deliveryStore.listPendingWorkflowTraceRevisions(100);
+        let nextRetryAt;
+        for (const entry of entries) {
+            if (!this.active || this.workflowTraceSink?.token !== registration.token)
+                return;
+            try {
+                const candidate = await Promise.resolve(registration.sink.projectWorkflowTraceRevision(entry.revision));
+                validateWorkflowTraceProjectionReceipt(candidate, entry.revision);
+                if (!this.active || this.workflowTraceSink?.token !== registration.token)
+                    return;
+                this.deliveryStore.completeWorkflowTraceRevision({
+                    subjectRef: entry.revision.subjectRef,
+                    version: entry.revision.version,
+                    digest: entry.revision.digest,
+                });
+            }
+            catch (error) {
+                if (!this.active || this.workflowTraceSink?.token !== registration.token)
+                    return;
+                const now = Date.now();
+                const retryDelay = Math.min(this.config.retryMaxMs, this.config.retryBaseMs * (2 ** Math.min(30, entry.attemptCount)));
+                const retryAt = now + retryDelay;
+                const code = typeof error === 'object' && error !== null && 'code' in error
+                    && typeof error.code === 'string'
+                    ? `sink-${error.code}`.slice(0, 64)
+                    : 'sink-projection-failed';
+                this.deliveryStore.deferWorkflowTraceRevision({
+                    subjectRef: entry.revision.subjectRef,
+                    version: entry.revision.version,
+                    digest: entry.revision.digest,
+                    now,
+                    retryAt,
+                    failureCode: /^[A-Za-z0-9][A-Za-z0-9._:-]{0,63}$/u.test(code)
+                        ? code
+                        : 'sink-projection-failed',
+                });
+                nextRetryAt = Math.min(nextRetryAt ?? retryAt, retryAt);
+            }
+        }
+        if (nextRetryAt !== undefined && this.workflowTraceSink?.token === registration.token
+            && this.workflowTraceRetryTimer === undefined) {
+            this.workflowTraceRetryTimer = setTimeout(() => {
+                this.workflowTraceRetryTimer = undefined;
+                if (this.active)
+                    void this.drainWorkflowTraces();
+            }, Math.max(1, Math.min(2_147_483_647, nextRetryAt - Date.now())));
+            this.workflowTraceRetryTimer.unref?.();
+        }
     }
     resolveModelSelectionWaiters(operationId, result) {
         const waiters = this.modelSelectionWaiters.get(operationId);
@@ -1614,10 +3373,20 @@ export class AssistantDeliveryService extends Service {
         const dispatches = this.policy.listPendingApprovalDispatches(100, cursor.after);
         for (const dispatch of dispatches) {
             try {
+                if (dispatch.routeVersion !== 2)
+                    continue;
                 this.enqueueApproval({
-                    sourceId: dispatch.sourceId,
-                    workspace: dispatch.workspace,
-                    bindingId: dispatch.bindingId,
+                    route: {
+                        routeVersion: 2,
+                        sourceId: dispatch.sourceId,
+                        bindingId: dispatch.bindingId,
+                        bindingVersion: dispatch.bindingVersion,
+                        bindingGeneration: dispatch.bindingGeneration,
+                        workspace: dispatch.workspace,
+                        principal: dispatch.principal,
+                        principalRecordId: dispatch.principalRecordId,
+                        principalVersion: dispatch.principalVersion,
+                    },
                     idempotencyKey: `approval-card:${dispatch.proposalId}`,
                     text: dispatch.diff,
                     approval: {
@@ -1652,6 +3421,148 @@ export class AssistantDeliveryService extends Service {
             throw error;
         }
     }
+    drainDeliveryPresentations() {
+        if (this.presentationFlight !== undefined)
+            return this.presentationFlight;
+        const flight = this.runDeliveryPresentations()
+            .finally(() => { if (this.presentationFlight === flight)
+            this.presentationFlight = undefined; });
+        this.presentationFlight = flight;
+        return flight;
+    }
+    async runDeliveryPresentations() {
+        const attemptedPresentationKeys = [];
+        for (let index = 0; index < this.config.maxConcurrency; index += 1) {
+            const claimed = this.deliveryStore.claimDeliveryPresentation({
+                ownerId: this.ownerId,
+                leaseMs: this.config.leaseMs,
+                excludePresentationKeys: attemptedPresentationKeys,
+            });
+            if (claimed === undefined)
+                return;
+            const { presentation, fencingToken } = claimed;
+            attemptedPresentationKeys.push(presentation.presentationKey);
+            const original = this.deliveryStore.getOutboxByIdempotencyKey(presentation.originalOutboxIdempotencyKey);
+            const finishFailure = (failureCode, terminal = false) => {
+                // Presentation is a projection of an already-authoritative terminal
+                // domain receipt. A transient provider failure must never turn that
+                // receipt into a permanent lie simply because the normal message-send
+                // retry budget was exhausted. Only an immutable original or revoked
+                // authority can terminally fence the projection.
+                const outcome = terminal ? 'dead' : 'retry_wait';
+                const retryDelay = Math.min(this.config.retryMaxMs, this.config.retryBaseMs * (2 ** Math.min(30, Math.max(0, presentation.attemptCount - 1))));
+                try {
+                    this.deliveryStore.finishDeliveryPresentation({
+                        presentationKey: presentation.presentationKey,
+                        revision: presentation.revision,
+                        ownerId: this.ownerId,
+                        fencingToken,
+                        outcome,
+                        failureCode,
+                        ...(outcome === 'retry_wait' ? { nextAttemptAt: Date.now() + retryDelay } : {}),
+                    });
+                }
+                catch (error) {
+                    // A newer desired revision superseded this provider attempt. Its
+                    // pending row is authoritative and must not be overwritten by the
+                    // older completion.
+                    if (error instanceof DeliveryStoreError && error.code === 'stale-fence')
+                        return;
+                    throw error;
+                }
+            };
+            if (original === undefined) {
+                // The domain can settle before the Policy dispatch scanner creates the
+                // card. Preserve the desired state without exhausting retries.
+                this.deliveryStore.finishDeliveryPresentation({
+                    presentationKey: presentation.presentationKey,
+                    revision: presentation.revision,
+                    ownerId: this.ownerId,
+                    fencingToken,
+                    outcome: 'retry_wait',
+                    failureCode: 'original-message-not-created',
+                    nextAttemptAt: Date.now() + this.config.retryBaseMs,
+                });
+                continue;
+            }
+            if (original.status === 'dead') {
+                finishFailure('original-message-dead', true);
+                continue;
+            }
+            if (original.providerMessageId === undefined) {
+                this.deliveryStore.finishDeliveryPresentation({
+                    presentationKey: presentation.presentationKey,
+                    revision: presentation.revision,
+                    ownerId: this.ownerId,
+                    fencingToken,
+                    outcome: 'retry_wait',
+                    failureCode: 'original-provider-message-pending',
+                    nextAttemptAt: Date.now() + this.config.retryBaseMs,
+                });
+                continue;
+            }
+            if (presentation.presentation.kind === 'automation-incident') {
+                const route = this.deliveryStore.validatePresentationOwnerRoute(original, this.ownerRouteGuard);
+                if (route.kind === 'deferred') {
+                    finishFailure(route.failureCode);
+                    continue;
+                }
+                if (route.kind !== 'authorized') {
+                    finishFailure(route.kind === 'denied'
+                        ? route.failureCode
+                        : 'presentation-owner-route-required', true);
+                    continue;
+                }
+            }
+            else {
+                const binding = this.deliveryStore.getBinding(original.intent.bindingId);
+                const principal = binding === undefined ? undefined : this.deliveryStore.getPrincipal(binding.principal);
+                if (binding?.status !== 'active' || principal?.status !== 'active' || principal.role !== 'owner') {
+                    finishFailure('presentation-route-revoked', true);
+                    continue;
+                }
+            }
+            const adapter = this.registry.get(original.intent.target.conversation.channel, original.intent.target.conversation.account);
+            if (adapter?.updatePresentation === undefined) {
+                finishFailure('presentation-adapter-unavailable');
+                continue;
+            }
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(new Error('delivery presentation lease elapsed')), this.config.leaseMs);
+            timeout.unref?.();
+            let updateError;
+            try {
+                await adapter.updatePresentation(original.providerMessageId, presentation.presentation, controller.signal);
+            }
+            catch (error) {
+                updateError = error;
+            }
+            finally {
+                clearTimeout(timeout);
+            }
+            if (updateError !== undefined) {
+                const code = updateError instanceof Error
+                    ? `presentation-${updateError.name.normalize('NFC').toLowerCase().replaceAll(/[^a-z0-9]+/gu, '-').slice(0, 80)}`
+                    : 'presentation-unknown-error';
+                finishFailure(code);
+                continue;
+            }
+            try {
+                this.deliveryStore.finishDeliveryPresentation({
+                    presentationKey: presentation.presentationKey,
+                    revision: presentation.revision,
+                    ownerId: this.ownerId,
+                    fencingToken,
+                    outcome: 'presented',
+                    providerMessageId: original.providerMessageId,
+                });
+            }
+            catch (error) {
+                if (!(error instanceof DeliveryStoreError) || error.code !== 'stale-fence')
+                    throw error;
+            }
+        }
+    }
     drainModelSelectionSettlements() {
         if (this.modelSelectionRetryTimer !== undefined) {
             clearTimeout(this.modelSelectionRetryTimer);