@dsh-enhanced/assistant-delivery 0.1.23 → 0.1.30

package/lib/service.js

@@ -3,18 +3,22 @@ import { isAbsolute } from 'node:path';
 import { createHash, randomUUID } from 'node:crypto';
 import { Context, Service } from '@deepseek-ai/cordis';
 import Schema from '@deepseek-ai/schemastery';
+import { acceptanceCanonicalJson } from '@dsh-enhanced/task-acceptance-contract';
 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 { DeliverySessionLeases } from './session-lease-runtime.js';
+import { NativeWebOwner } from './native-web-owner.js';
+import { validateOwnerGoalOutcomeFeedbackLocator, validateOwnerGoalOutcomeFeedbackProof, } from './goal-wake-types.js';
 import { InboundImageMaterializer } from './inbound-images.js';
 import { registerDeliveryTools } from './tools.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 { feedbackSignalInput, parseFeedbackCommand, 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');
@@ -46,6 +50,17 @@ const automationObjectiveFeedbackFooter = [
     '任务结果反馈：直接回复本消息并发送 `/feedback achieved`、`/feedback partial` 或 `/feedback not-achieved`。',
     '`helpful` 等只记录偏好，不会被当成任务成败。',
 ].join('\n');
+const goalOutcomeFeedbackFooter = [
+    '',
+    '---',
+    '目标结果反馈：直接回复本消息并发送 `/feedback achieved`、`/feedback partial` 或 `/feedback not-achieved`。',
+    '`helpful` 等只记录偏好，不会被当成目标成败。',
+].join('\n');
+function isGoalOutcomeFeedbackAuthority(value) {
+    return typeof value === 'object' && value !== null
+        && typeof value.issueOwnerGoalOutcomeFeedbackTarget === 'function'
+        && typeof value.resolveOwnerGoalOutcomeFeedbackTarget === 'function';
+}
 function isAutomationDeliveryEvidenceResolver(value) {
     return typeof value === 'object' && value !== null
         && typeof value.resolveDeliveryEvidence === 'function';
@@ -246,6 +261,7 @@ const configSchema = Schema.object({
     agentModel: Schema.string().min(1).default('deepseek-v4-flash'),
     agentMaxOutputTokens: Schema.number().step(1).min(1).default(8_192),
     agentMaxAutoContinuationTurns: Schema.number().step(1).min(0).max(8).default(2),
+    agentGoalContinuationTimeoutMs: Schema.number().step(1).min(0).max(300_000).default(0),
     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),
@@ -351,7 +367,7 @@ const permissionEventTypes = [
 const approvalOutcomes = ['allowed-once', 'rejected', 'cancelled', 'unavailable'];
 function currentPermissionEvents(agent) {
     const latest = new Map();
-    for (const event of agent.session.events) {
+    for (const event of agent.session.snapshotEvents()) {
         const type = String(event.type);
         if (!permissionEventTypes.includes(type))
             continue;
@@ -362,70 +378,6 @@ function currentPermissionEvents(agent) {
 function signalAborted(signal) {
     return signal?.aborted === true;
 }
-const userQuestionTombstoneLimit = 1_024;
-function isUserQuestionApiProxy(value) {
-    if (value === null || typeof value !== 'object')
-        return false;
-    const candidate = value;
-    return candidate.events !== null && typeof candidate.events === 'object'
-        && typeof candidate.events.mux === 'function'
-        && typeof candidate.respond === 'function';
-}
-function requestedUserQuestionFrame(value) {
-    if (value === null || typeof value !== 'object' || Array.isArray(value))
-        return undefined;
-    const envelope = value;
-    if (typeof envelope.rpcId !== 'string' || envelope.rpcId.length === 0
-        || envelope.payload === null || typeof envelope.payload !== 'object'
-        || Array.isArray(envelope.payload))
-        return undefined;
-    const payload = envelope.payload;
-    if (payload.type !== 'question/requested' || typeof payload.sessionId !== 'string'
-        || payload.sessionId.length === 0 || !Array.isArray(payload.questions))
-        return undefined;
-    return {
-        rpcId: envelope.rpcId,
-        sessionId: payload.sessionId,
-        questions: Object.freeze([...payload.questions]),
-    };
-}
-function resolvedUserQuestionFrame(value) {
-    if (value === null || typeof value !== 'object' || Array.isArray(value))
-        return undefined;
-    const envelope = value;
-    if (envelope.payload === null || typeof envelope.payload !== 'object' || Array.isArray(envelope.payload)) {
-        return undefined;
-    }
-    const payload = envelope.payload;
-    if (payload.type !== 'question/resolved' || typeof payload.questionRpcId !== 'string'
-        || payload.questionRpcId.length === 0
-        || (payload.outcome !== 'answered' && payload.outcome !== 'cancelled'))
-        return undefined;
-    return { questionRpcId: payload.questionRpcId };
-}
-function userQuestionRequestHash(sessionId, questions) {
-    try {
-        const encoded = JSON.stringify([sessionId, questions]);
-        return typeof encoded === 'string' ? createHash('sha256').update(encoded).digest('hex') : undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
-function cancelledUserQuestionResponse(rpcId) {
-    return {
-        type: 'client-response',
-        rpcId,
-        result: {
-            ok: false,
-            error: {
-                code: 'cancelled',
-                message: 'the user cancelled ask_user_question',
-                details: {},
-            },
-        },
-    };
-}
 function sameUserQuestionAuthority(left, right) {
     return right !== undefined
         && right.adapter === left.adapter
@@ -438,6 +390,40 @@ function sameUserQuestionAuthority(left, right) {
         && JSON.stringify(right.binding.conversation) === JSON.stringify(left.binding.conversation)
         && JSON.stringify(right.binding.principal) === JSON.stringify(left.binding.principal);
 }
+function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function validUserQuestionAnswer(questions, value) {
+    if (!isRecord(value) || Object.getPrototypeOf(value) !== Object.prototype
+        || Object.keys(value).some(key => key !== 'answers')
+        || !Array.isArray(value.answers) || value.answers.length !== questions.length)
+        return false;
+    return value.answers.every((answer, index) => {
+        const question = questions[index];
+        if (question === undefined || !isRecord(answer) || Object.getPrototypeOf(answer) !== Object.prototype
+            || Object.keys(answer).some(key => !['id', 'selected', 'custom'].includes(key))
+            || answer.id !== question.id || !Array.isArray(answer.selected)
+            || answer.selected.some(item => typeof item !== 'string')
+            || new Set(answer.selected).size !== answer.selected.length)
+            return false;
+        const optionLabels = new Set((question.options ?? []).map(option => option.label));
+        if (answer.selected.some(item => !optionLabels.has(item)))
+            return false;
+        const custom = answer.custom;
+        if (custom !== undefined && (typeof custom !== 'string' || custom.trim() === ''))
+            return false;
+        if (question.multiSelect !== true && (answer.selected.length > 1
+            || (answer.selected.length !== 0 && custom !== undefined)))
+            return false;
+        return true;
+    });
+}
+function userQuestionError(message, code, cause) {
+    return Object.assign(new Error(message, cause === undefined ? undefined : { cause }), {
+        name: 'UserQuestionError',
+        code,
+    });
+}
 function sameToolApprovalAuthority(left, right) {
     return right !== undefined
         && right.adapter === left.adapter
@@ -516,13 +502,16 @@ export class AssistantDeliveryService extends Service {
     config;
     ownerRoutes;
     ownerRouteGuard;
+    nativeWebBound = false;
+    nativeWebOwner;
+    nativeWebRuntime;
     ownerId = `assistant-delivery-${randomUUID()}`;
     bindingFlights = new Map();
     conversationTransitions = new Map();
     agentApprovalBindings = new WeakMap();
     toolApprovalControllers = new Set();
     drainingUserQuestionAdapters = new WeakSet();
-    userQuestionBridge;
+    userQuestionAttempts = new Set();
     modelSelectionWaiters = new Map();
     preferenceFeedbackSink;
     evaluationSink;
@@ -532,11 +521,19 @@ export class AssistantDeliveryService extends Service {
     activePresentationRegistrations = new WeakSet();
     evaluationProducerGeneration = `assistant-delivery:${randomUUID()}`;
     preferenceProducerGeneration = `assistant-delivery-preference:${randomUUID()}`;
+    acceptanceProducerGeneration = `assistant-delivery-acceptance:${randomUUID()}`;
+    acceptanceSink;
+    /** Once a live verifier required acceptance, loss of that verifier must not silently bypass it. */
+    acceptanceRequired = false;
     preferenceTurns = new WeakMap();
+    goalWakeResults = new WeakMap();
     modelSelectionFlight;
     presentationFlight;
     workflowTraceFlight;
     preferenceProjectionFlight;
+    inboundAdmissionRecoveryFlight;
+    inboundAdmissionRecoveryAfterSequence = 0;
+    inboundAdmissionRecoveryController = new AbortController();
     workflowTraceRetryTimer;
     preferenceProjectionRetryTimer;
     modelSelectionRetryTimer;
@@ -623,18 +620,36 @@ export class AssistantDeliveryService extends Service {
             ownerId: this.ownerId, leaseMs: config.leaseMs, maxAttempts: config.maxAttempts,
             maxConcurrency: config.maxConcurrency, retryBaseMs: config.retryBaseMs, retryMaxMs: config.retryMaxMs,
             ownerRouteGuard: this.ownerRouteGuard,
+            notificationGuard: record => this.#notificationGuard(record),
         });
         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 });
         ctx.inject(['agents', 'sessions', 'llm'], runtimeCtx => {
+            const sessionLeases = new DeliverySessionLeases(runtimeCtx, {
+                requiresLease: sessionId => this.deliveryStore.requiresSessionLease(sessionId),
+                leaseMs: Math.min(config.leaseMs, 300_000),
+                claim: (target, holderId, leaseMs) => this.deliveryStore.claimSessionLease(target, holderId, leaseMs),
+                dispatch: lease => this.deliveryStore.markSessionLeaseDispatched(lease),
+                valid: lease => this.deliveryStore.hasSessionLease(lease),
+                renew: (lease, leaseMs) => this.deliveryStore.renewSessionLease(lease, leaseMs),
+                finish: (lease, input) => this.deliveryStore.finishSessionLease(lease, input),
+            });
+            const webRuntime = { ctx: runtimeCtx, leases: sessionLeases };
+            this.nativeWebRuntime = webRuntime;
+            runtimeCtx.effect(() => () => { if (this.nativeWebRuntime === webRuntime)
+                this.nativeWebRuntime = undefined; });
             const unregister = this.registerInboundRuntime(new DshDeliveryRuntime(runtimeCtx, policy, {
+                sessionLeases,
                 sessionNamespace: this.deliveryStore.instanceId(),
                 workspace: config.defaultWorkspace, agentPreset: config.defaultAgentPreset, policyRef: config.policyRef,
                 getAgentPresets: () => runtimeCtx.get('agentPresets'),
                 provider: config.agentProvider, model: config.agentModel, maxOutputTokens: config.agentMaxOutputTokens,
                 maxAutoContinuationTurns: config.agentMaxAutoContinuationTurns,
+                goalContinuationTimeoutMs: config.agentGoalContinuationTimeoutMs,
                 maxTextBytes: config.maxTextBytes,
+                prepareForegroundTaskAcceptance: (binding, envelope) => this.prepareForegroundTaskAcceptance(binding, envelope),
+                completeForegroundTaskAcceptance: (handle, input) => this.completeForegroundTaskAcceptance(handle, input),
                 modelPickerTtlMs: config.modelPickerTtlMs,
                 permissionPickerTtlMs: config.permissionPickerTtlMs,
                 getModelSelection: conversation => this.deliveryStore.getModelSelection(conversation),
@@ -677,15 +692,10 @@ export class AssistantDeliveryService extends Service {
         });
         ctx.inject(['approval'], approvalCtx => approvalCtx.on('approval/request', (request, next) => this.requestToolApproval(approvalCtx, request, next)));
         ctx.inject(['tools'], toolsCtx => registerDeliveryTools(toolsCtx, this));
-        // ApiProxy owns the only `userQuestions` provider. Delivery merely bridges
-        // its server-request mux frames to an authenticated channel adapter and
-        // echoes a client response; it must never register a competing provider.
-        ctx.inject(['apiProxy'], apiCtx => {
-            const apiProxy = apiCtx.apiProxy;
-            if (!isUserQuestionApiProxy(apiProxy))
-                return;
-            return this.attachUserQuestionApiProxy(apiProxy);
-        });
+        // rc.1 exposes questions as an Agent-scoped waterfall. Delivery is one
+        // answerer in that chain, so Web and other frontends may call `next()` and
+        // coexist without a competing service provider or a private ApiProxy seam.
+        ctx.inject(['userQuestions'], questionCtx => questionCtx.on('user-questions/request', (request, next) => this.answerUserQuestion(request, next), { prepend: true }));
         // 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.
@@ -713,14 +723,19 @@ export class AssistantDeliveryService extends Service {
             this.start();
         ctx.effect(() => async () => {
             this.active = false;
+            // The isolated Web owner may already be unwinding concurrently. Await
+            // its memoized drain while the delivery Store is still available so a
+            // successfully disposed Agent can record its quiescent lease release.
+            await this.nativeWebOwner?.dispose();
             trustedDeliveryPreferenceProducers.delete(this);
             this.preferenceFeedbackSink = undefined;
+            this.acceptanceSink = undefined;
             this.evaluationSink = undefined;
             this.workflowTraceSink = undefined;
             this.automationPresentationBinding?.dispose();
             this.evolutionPresentationBinding?.dispose();
             this.cancelModelSelectionWaiters();
-            this.stopUserQuestionBridge(new Error('assistant-delivery is stopping'));
+            this.abortUserQuestionAttempts(new Error('assistant-delivery is stopping'));
             for (const controller of this.toolApprovalControllers) {
                 controller.abort(new Error('assistant-delivery is stopping'));
             }
@@ -1220,11 +1235,272 @@ export class AssistantDeliveryService extends Service {
                 this.runtime = undefined;
         };
     }
+    /** Versioned capability: idle wake Agents remain alive through exact goal settlement. */
+    goalWakeSettlementVersion = () => { this.assertActive(); return 1; };
+    goalWakeResultVersion = () => { this.assertActive(); return 1; };
+    /** Only the live Goals service can mint this process-local wake capability. */
+    async resumeScheduledGoal(input) {
+        this.assertActive();
+        const runtime = this.runtime;
+        const denied = () => { throw new AssistantDeliveryError('policy-denied', 'scheduled goal authority is no longer current'); };
+        const current = () => {
+            this.assertActive();
+            // Cordis creates contextual service proxies on read; proxy identity is
+            // not a generation proof. The currently installed service must own the
+            // exact process-local capability on every boundary.
+            const producer = this.ctx.get('assistantGoals', false);
+            if (this.runtime !== runtime || !(runtime instanceof DshDeliveryRuntime)
+                || producer?.ownsWakeExecution?.(input) !== true)
+                return denied();
+            input.signal.throwIfAborted();
+            if (!Number.isSafeInteger(input.deadlineAt) || Date.now() >= input.deadlineAt)
+                return denied();
+            const expected = input.attestation;
+            const resolved = this.deliveryStore.getPreferencePrincipalForSession({ sessionId: expected.sessionId,
+                workspace: expected.scope.workspace, preset: expected.scope.preset });
+            if (resolved === undefined)
+                return denied();
+            const { binding, principal } = resolved;
+            if (binding.id !== expected.bindingId || binding.version !== expected.bindingVersion
+                || binding.generation !== expected.bindingGeneration || binding.sessionId !== expected.sessionId
+                || externalPrincipalId(binding.principal) !== expected.principalId
+                || principal.id !== expected.principalLineage.principalRecordId
+                || principal.version !== expected.principalLineage.principalVersion)
+                return denied();
+            const decision = this.policy.authorize({ subject: { kind: 'background', id: 'assistant-goals-wake/v1',
+                    workspace: binding.workspace, principal: expected.principalId }, action: 'wake',
+                resource: { kind: 'goal', id: 'business-context' }, context: { initiator: 'background' } });
+            if (decision.effect !== 'allow')
+                return denied();
+            return binding;
+        };
+        const binding = current();
+        if (typeof input.settle !== 'function')
+            return denied();
+        const result = await runtime.resumeScheduledGoal(binding, Object.freeze({ ...input,
+            assertCurrent: (agent, phase) => {
+                current();
+                if (String(agent.session.id) !== binding.sessionId || agent.session.header.cwd !== binding.workspace
+                    || agent.session.header.agentPreset !== binding.agentPreset)
+                    return denied();
+                input.assertCurrent(agent, phase);
+                current();
+            },
+            beforeResume: (agent) => { current(); input.beforeResume(agent); current(); },
+            settle: async (agent, signal) => { current(); signal.throwIfAborted(); await input.settle(agent, signal); signal.throwIfAborted(); current(); },
+        }));
+        if (result.outcome === 'succeeded') {
+            current();
+            if (input.includeOutput === true && result.quiescent && result.output?.trim()) {
+                const text = result.output;
+                this.goalWakeResults.set(input, () => {
+                    // Re-read the exact owner, binding generation and Session at enqueue,
+                    // after the caller has rechecked its Goal/source authority.
+                    const target = current();
+                    if (target.conversation.channel === 'web') {
+                        const owner = this.nativeWebOwner;
+                        // This finalizes the existing, flushed native Session reply. It does
+                        // not create a second send or claim that the reply was read.
+                        if (!this.nativeWebBound || owner === undefined)
+                            return denied();
+                        try {
+                            owner.assertSession(target.sessionId);
+                        }
+                        catch {
+                            return denied();
+                        }
+                        return Object.freeze({ kind: 'native-session', sessionId: target.sessionId });
+                    }
+                    return this.publishScheduledGoalResult(input, text, current, denied);
+                });
+            }
+        }
+        return result;
+    }
+    /** Finalize the captured native reply, or publish it only for a still-owned external channel. */
+    enqueueScheduledGoalResult(input) {
+        this.assertActive();
+        const publish = this.goalWakeResults.get(input);
+        if (publish === undefined)
+            throw new AssistantDeliveryError('policy-denied', 'scheduled goal result is unavailable');
+        return publish();
+    }
+    publishScheduledGoalResult(input, text, current, denied) {
+        current();
+        let resolved;
+        try {
+            resolved = input.resolveOutcomeFeedbackTarget();
+        }
+        catch {
+            return denied();
+        }
+        const afterResolve = current();
+        let locator;
+        let proof;
+        try {
+            locator = validateOwnerGoalOutcomeFeedbackLocator(resolved.locator);
+            proof = validateOwnerGoalOutcomeFeedbackProof(resolved.proof);
+        }
+        catch {
+            return denied();
+        }
+        const goals = this.ctx.get('assistantGoals', false);
+        if (!isGoalOutcomeFeedbackAuthority(goals))
+            return denied();
+        let capabilityProof;
+        try {
+            capabilityProof = validateOwnerGoalOutcomeFeedbackProof(goals.resolveOwnerGoalOutcomeFeedbackTarget(resolved.capability));
+        }
+        catch {
+            return denied();
+        }
+        const finalBinding = current();
+        const owner = this.deliveryStore.getPrincipal(finalBinding.principal);
+        if (acceptanceCanonicalJson(locator) !== acceptanceCanonicalJson(proof.locator)
+            || acceptanceCanonicalJson(proof) !== acceptanceCanonicalJson(capabilityProof)
+            || finalBinding.id !== afterResolve.id || locator.bindingId !== finalBinding.id
+            || locator.bindingVersion !== finalBinding.version
+            || locator.bindingGeneration !== finalBinding.generation
+            || locator.sessionId !== finalBinding.sessionId || locator.workspace !== finalBinding.workspace
+            || locator.preset !== finalBinding.agentPreset
+            || locator.principalId !== externalPrincipalId(finalBinding.principal)
+            || owner?.status !== 'active' || owner.role !== 'owner'
+            || locator.principalRecordId !== owner.id || locator.principalVersion !== owner.version
+            || proof.goal.nativeGoalId !== input.native.goalId
+            || proof.receipt.completedAt > Date.now() || proof.receipt.validUntil <= Date.now())
+            return denied();
+        let route;
+        try {
+            route = this.resolveOwnerRoute(locator.ownerRouteId);
+        }
+        catch {
+            return denied();
+        }
+        if (route.binding.id !== finalBinding.id || route.binding.version !== finalBinding.version
+            || route.binding.generation !== finalBinding.generation
+            || route.binding.sessionId !== finalBinding.sessionId)
+            return denied();
+        const decision = this.policy.authorize({
+            subject: { kind: 'background', id: 'assistant-goals-wake/v1',
+                workspace: finalBinding.workspace, principal: locator.principalId },
+            action: 'send', resource: { kind: 'message', id: finalBinding.id }, context: { initiator: 'background' },
+        }, { idempotencyKey: `message-send:goal-outcome:${proof.proofDigest}:${finalBinding.id}` });
+        if (decision.effect !== 'allow')
+            throw policyDenied(decision);
+        const rendered = `${text}${goalOutcomeFeedbackFooter}`;
+        if (Buffer.byteLength(rendered, 'utf8') > this.config.maxTextBytes) {
+            throw new AssistantDeliveryError('runtime-conflict', 'scheduled goal result exceeds the delivery text limit');
+        }
+        const situation = `goal:${locator.goalId}:definition:${proof.goal.definitionVersion}`;
+        return this.deliveryStore.enqueueGoalOutcomeTarget({
+            locator, proof,
+            intent: {
+                idempotencyKey: `goal-outcome:${proof.proofDigest}:${finalBinding.id}`,
+                bindingId: finalBinding.id,
+                target: { conversation: finalBinding.conversation, principal: finalBinding.principal },
+                text: rendered, format: 'markdown',
+                metadata: Object.freeze({
+                    'dsh.learning.schemaVersion': '3', 'dsh.learning.kind': 'goal-outcome',
+                    'dsh.learning.goalId': locator.goalId, 'dsh.learning.assessmentId': locator.assessmentId,
+                    'dsh.learning.runId': proof.runId, 'dsh.learning.situation': situation,
+                    'dsh.learning.occurredAt': String(proof.receipt.completedAt),
+                    'dsh.learning.objectiveStatus': proof.receipt.objectiveStatus,
+                    'dsh.learning.proofDigest': proof.proofDigest,
+                }),
+            },
+        });
+    }
+    /** Private verifier producer generation; invalidated with this service. */
+    trustedAcceptanceProducerGeneration = () => {
+        this.assertActive();
+        return this.acceptanceProducerGeneration;
+    };
+    registerTaskAcceptanceSink = (registration) => {
+        this.assertActive();
+        const verifier = this.ctx.get('assistantVerifier', false);
+        if (registration.protocol !== 'assistant-verifier/host-producer/v1'
+            || registration.generation !== this.acceptanceProducerGeneration
+            || typeof registration.prepare !== 'function' || typeof registration.completed !== 'function'
+            || typeof registration.requiresAcceptance !== 'boolean'
+            || typeof verifier?.ownsTaskAcceptanceRegistration !== 'function'
+            || verifier.ownsTaskAcceptanceRegistration(registration) !== true) {
+            throw new AssistantDeliveryError('runtime-conflict', 'task acceptance registration is invalid');
+        }
+        if (this.acceptanceSink !== undefined) {
+            if (this.acceptanceSink.registration === registration)
+                return this.removeTaskAcceptanceSink(this.acceptanceSink.token);
+            throw new AssistantDeliveryError('runtime-conflict', 'task acceptance sink is already registered');
+        }
+        const token = Symbol('assistant-delivery.task-acceptance');
+        if (registration.requiresAcceptance)
+            this.acceptanceRequired = true;
+        this.acceptanceSink = Object.freeze({ token, registration });
+        return this.removeTaskAcceptanceSink(token);
+    };
+    inspectAcceptedExecution = async (contract) => {
+        this.assertActive();
+        return this.deliveryStore.inspectForegroundAcceptedExecution(contract);
+    };
+    removeTaskAcceptanceSink(token) {
+        let live = true;
+        return () => {
+            if (!live)
+                return;
+            live = false;
+            if (this.acceptanceSink?.token === token)
+                this.acceptanceSink = undefined;
+        };
+    }
+    prepareForegroundTaskAcceptance(binding, envelope) {
+        const sink = this.acceptanceSink;
+        if (sink === undefined) {
+            if (this.acceptanceRequired) {
+                throw new AssistantDeliveryError('runtime-conflict', 'required task acceptance verifier is unavailable');
+            }
+            return undefined;
+        }
+        const owner = this.ownerLineageForBinding(binding);
+        const inbox = this.deliveryStore.getInboxByProviderEvent(envelope.channel, envelope.account, envelope.eventId);
+        const exactInbox = inbox !== undefined && inbox.status === 'claimed' && inbox.bindingId === binding.id
+            && JSON.stringify(inbox.envelope) === JSON.stringify(envelope);
+        if (owner === undefined || !exactInbox) {
+            if (this.acceptanceRequired) {
+                throw new AssistantDeliveryError('missing-binding', 'required task acceptance lacks an authenticated owner inbox');
+            }
+            return undefined;
+        }
+        const task = Object.freeze({ kind: 'foreground-turn', ref: inbox.id });
+        const prepared = sink.registration.prepare(Object.freeze({
+            scope: Object.freeze({ workspace: binding.workspace, preset: binding.agentPreset }),
+            owner: Object.freeze({ principalRecordId: owner.principalRecordId, principalVersion: owner.principalVersion }),
+            task,
+            // Preserve the original inbound objective byte-for-byte.
+            objective: envelope.text,
+        }));
+        if (prepared === null) {
+            if (this.acceptanceRequired) {
+                throw new AssistantDeliveryError('runtime-conflict', 'required task acceptance profile did not produce a contract');
+            }
+            return undefined;
+        }
+        this.deliveryStore.bindForegroundTaskAcceptance({ inboxId: inbox.id, contractId: prepared.contractId,
+            contractDigest: prepared.contractDigest, scope: { workspace: binding.workspace, preset: binding.agentPreset },
+            owner, binding, dispatchedAt: Date.now() });
+        return prepared;
+    }
+    async completeForegroundTaskAcceptance(handle, input) {
+        const sink = this.acceptanceSink;
+        this.deliveryStore.finishForegroundTaskAcceptance({ contractId: handle.contractId, ...input, completedAt: Date.now() });
+        if (sink === undefined && this.acceptanceRequired) {
+            throw new AssistantDeliveryError('runtime-conflict', 'required task acceptance verifier is unavailable after Host completion');
+        }
+        if (sink !== undefined)
+            await sink.registration.completed(handle);
+    }
     registerAdapter(adapter) {
         this.assertActive();
         return this.registry.register(adapter).then(unregister => {
             this.drainingUserQuestionAdapters.delete(adapter);
-            this.dispatchPendingUserQuestions();
             let registered = true;
             return async () => {
                 if (!registered)
@@ -1233,283 +1509,109 @@ export class AssistantDeliveryService extends Service {
                 this.drainingUserQuestionAdapters.add(adapter);
                 this.abortUserQuestionAttemptsForAdapter(adapter, new Error('delivery adapter is unregistering'));
                 await unregister();
-                this.dispatchPendingUserQuestions();
             };
         });
     }
-    attachUserQuestionApiProxy(proxy) {
-        this.stopUserQuestionBridge(new Error('ApiProxy question bridge replaced'));
-        if (!this.active)
-            return () => { };
-        const bridge = {
-            proxy,
-            controller: new AbortController(),
-            pending: new Map(),
-            completed: new Set(),
-        };
-        this.userQuestionBridge = bridge;
-        void this.consumeUserQuestionMux(bridge);
-        let attached = true;
-        return () => {
-            if (!attached)
-                return;
-            attached = false;
-            this.stopUserQuestionBridge(new Error('ApiProxy question bridge disposed'), bridge);
-        };
-    }
-    stopUserQuestionBridge(reason, expected) {
-        const bridge = expected ?? this.userQuestionBridge;
-        if (bridge === undefined || this.userQuestionBridge !== bridge)
-            return;
-        this.userQuestionBridge = undefined;
-        bridge.controller.abort(reason);
-        for (const pending of bridge.pending.values()) {
-            const attempt = pending.attempt;
-            attempt?.detachBridgeAbort();
-            attempt?.controller.abort(reason);
-            delete pending.attempt;
-        }
-        bridge.pending.clear();
-        bridge.completed.clear();
-    }
-    async consumeUserQuestionMux(bridge) {
-        try {
-            const stream = bridge.proxy.events.mux({
-                rpcId: randomUUID(),
-                payload: {},
-            }, bridge.controller.signal);
-            if (stream === null || typeof stream !== 'object'
-                || typeof stream[Symbol.asyncIterator] !== 'function')
-                return;
-            for await (const frame of stream) {
-                if (!this.active || this.userQuestionBridge !== bridge || bridge.controller.signal.aborted)
-                    return;
-                const resolved = resolvedUserQuestionFrame(frame);
-                if (resolved !== undefined) {
-                    this.resolvePendingUserQuestion(bridge, resolved.questionRpcId);
-                    continue;
-                }
-                const requested = requestedUserQuestionFrame(frame);
-                if (requested !== undefined)
-                    this.requestUserQuestionFromMux(bridge, requested);
-            }
-        }
-        catch {
-            // ApiProxy is an in-process service. If its stream is torn down, its
-            // Cordis injection disposer will replace this bridge; never leak a
-            // rejected iterator into the Host lifecycle.
-        }
-        finally {
-            if (this.userQuestionBridge === bridge && !bridge.controller.signal.aborted) {
-                this.stopUserQuestionBridge(new Error('ApiProxy question mux ended'), bridge);
-            }
-        }
-    }
-    requestUserQuestionFromMux(bridge, frame) {
-        if (bridge.completed.has(frame.rpcId))
-            return;
-        const requestHash = userQuestionRequestHash(frame.sessionId, frame.questions);
-        if (requestHash === undefined)
-            return;
-        const existing = bridge.pending.get(frame.rpcId);
-        if (existing !== undefined) {
-            if (existing.sessionId !== frame.sessionId || existing.requestHash !== requestHash) {
-                this.queueUserQuestionResponse(bridge, existing, cancelledUserQuestionResponse(existing.rpcId));
-            }
-            else {
-                this.dispatchUserQuestion(bridge, existing);
-            }
-            return;
+    abortUserQuestionAttemptsForAdapter(adapter, reason) {
+        for (const attempt of this.userQuestionAttempts) {
+            if (attempt.authority.adapter === adapter)
+                attempt.controller.abort(reason);
         }
-        const pending = {
-            rpcId: frame.rpcId,
-            sessionId: frame.sessionId,
-            questions: frame.questions,
-            requestHash,
-            state: 'waiting',
-            responseAttempts: 0,
-        };
-        bridge.pending.set(pending.rpcId, pending);
-        this.dispatchUserQuestion(bridge, pending);
     }
-    resolvePendingUserQuestion(bridge, rpcId) {
-        this.markUserQuestionCompleted(bridge, rpcId);
-        const pending = bridge.pending.get(rpcId);
-        if (pending === undefined)
-            return;
-        bridge.pending.delete(rpcId);
-        const attempt = pending.attempt;
-        attempt?.detachBridgeAbort();
-        attempt?.controller.abort(new Error('ApiProxy question request resolved'));
-        delete pending.attempt;
-    }
-    markUserQuestionCompleted(bridge, rpcId) {
-        if (bridge.completed.size >= userQuestionTombstoneLimit) {
-            const oldest = bridge.completed.values().next().value;
-            if (oldest !== undefined)
-                bridge.completed.delete(oldest);
-        }
-        bridge.completed.add(rpcId);
-    }
-    dispatchPendingUserQuestions() {
-        const bridge = this.userQuestionBridge;
-        if (!this.active || bridge === undefined || bridge.controller.signal.aborted)
-            return;
-        for (const pending of bridge.pending.values())
-            this.dispatchUserQuestion(bridge, pending);
+    abortUserQuestionAttempts(reason) {
+        for (const attempt of this.userQuestionAttempts)
+            attempt.controller.abort(reason);
     }
-    dispatchUserQuestion(bridge, pending) {
-        if (!this.active || this.userQuestionBridge !== bridge || bridge.controller.signal.aborted
-            || bridge.pending.get(pending.rpcId) !== pending || pending.state !== 'waiting')
-            return;
-        if (pending.response !== undefined) {
-            this.sendUserQuestionResponse(bridge, pending);
-            return;
-        }
-        const route = this.resolveUserQuestionRoute(pending.sessionId);
+    async answerUserQuestion(request, next) {
+        const agent = request.agent;
+        if (!this.active || agent === undefined)
+            return next();
+        const route = this.resolveUserQuestionRoute(String(agent.session.id), agent);
         if (route.state === 'deferred')
-            return;
+            return next();
         if (route.state === 'invalid') {
-            this.queueUserQuestionResponse(bridge, pending, cancelledUserQuestionResponse(pending.rpcId));
-            return;
+            throw userQuestionError('delivery user-question authority is no longer valid', 'ASK_ABORTED');
         }
         const controller = new AbortController();
-        const abortForBridge = () => controller.abort(bridge.controller.signal.reason);
-        if (bridge.controller.signal.aborted)
-            abortForBridge();
+        const abortForRequest = () => controller.abort(request.signal?.reason);
+        if (request.signal?.aborted)
+            abortForRequest();
         else
-            bridge.controller.signal.addEventListener('abort', abortForBridge, { once: true });
+            request.signal?.addEventListener('abort', abortForRequest, { once: true });
         const attempt = {
             controller,
             authority: route.authority,
-            detachBridgeAbort: () => bridge.controller.signal.removeEventListener('abort', abortForBridge),
+            detachRequestAbort: () => request.signal?.removeEventListener('abort', abortForRequest),
         };
-        pending.state = 'dispatching';
-        pending.attempt = attempt;
+        this.userQuestionAttempts.add(attempt);
         const input = Object.freeze({
-            operationId: pending.rpcId,
+            operationId: randomUUID(),
             bindingId: route.authority.binding.id,
             bindingVersion: route.authority.binding.version,
             bindingGeneration: route.authority.binding.generation,
-            sessionId: pending.sessionId,
+            sessionId: String(agent.session.id),
             target: Object.freeze({
                 conversation: Object.freeze({ ...route.authority.binding.conversation }),
                 principal: Object.freeze({ ...route.authority.binding.principal }),
             }),
-            questions: pending.questions,
+            questions: Object.freeze([...request.questions]),
         });
-        void Promise.resolve()
-            .then(() => route.authority.adapter.requestUserQuestion(input, controller.signal))
-            .then(outcome => this.completeUserQuestionAttempt(bridge, pending, attempt, outcome), () => this.completeUserQuestionAttempt(bridge, pending, attempt, { outcome: 'unavailable' }));
-    }
-    completeUserQuestionAttempt(bridge, pending, attempt, outcome) {
-        if (this.userQuestionBridge !== bridge || bridge.pending.get(pending.rpcId) !== pending
-            || pending.attempt !== attempt)
-            return;
-        delete pending.attempt;
-        attempt.detachBridgeAbort();
-        if (attempt.controller.signal.aborted) {
-            pending.state = 'waiting';
-            this.dispatchUserQuestion(bridge, pending);
-            return;
-        }
-        if (!this.active || bridge.controller.signal.aborted)
-            return;
-        const route = this.resolveUserQuestionRoute(pending.sessionId);
-        if (route.state === 'deferred') {
-            pending.state = 'waiting';
-            return;
-        }
-        if (route.state === 'invalid' || !sameUserQuestionAuthority(attempt.authority, route.authority)) {
-            this.queueUserQuestionResponse(bridge, pending, cancelledUserQuestionResponse(pending.rpcId));
-            return;
-        }
-        if (outcome !== null && typeof outcome === 'object'
-            && outcome.outcome === 'answered'
-            && typeof outcome.answer === 'object'
-            && outcome.answer !== null) {
-            const answer = outcome.answer;
-            this.queueUserQuestionResponse(bridge, pending, {
-                type: 'client-response',
-                rpcId: pending.rpcId,
-                result: { ok: true, value: { sessionId: pending.sessionId, answer } },
-            });
-            return;
-        }
-        this.queueUserQuestionResponse(bridge, pending, cancelledUserQuestionResponse(pending.rpcId));
-    }
-    queueUserQuestionResponse(bridge, pending, response) {
-        if (this.userQuestionBridge !== bridge || bridge.pending.get(pending.rpcId) !== pending)
-            return;
-        const attempt = pending.attempt;
-        attempt?.detachBridgeAbort();
-        attempt?.controller.abort(new Error('ApiProxy question response is being sent'));
-        delete pending.attempt;
-        pending.response = response;
-        pending.responseAttempts = 0;
-        pending.state = 'responding';
-        this.sendUserQuestionResponse(bridge, pending);
-    }
-    async sendUserQuestionResponse(bridge, pending) {
-        const response = pending.response;
-        if (response === undefined || this.userQuestionBridge !== bridge
-            || bridge.pending.get(pending.rpcId) !== pending || pending.state !== 'responding')
-            return;
-        let receipt;
         try {
-            receipt = await bridge.proxy.respond(response);
-        }
-        catch {
-            if (this.userQuestionBridge === bridge && bridge.pending.get(pending.rpcId) === pending) {
-                pending.responseAttempts += 1;
-                const retry = setTimeout(() => {
-                    void this.sendUserQuestionResponse(bridge, pending);
-                }, Math.min(250 * 2 ** Math.min(pending.responseAttempts - 1, 5), 5_000));
-                retry.unref();
+            let outcome;
+            try {
+                outcome = await route.authority.adapter.requestUserQuestion(input, controller.signal);
             }
-            return;
-        }
-        if (this.userQuestionBridge !== bridge || bridge.pending.get(pending.rpcId) !== pending)
-            return;
-        if (!receipt.accepted && receipt.reason === 'bad-response') {
-            if (response.result.ok) {
-                pending.response = cancelledUserQuestionResponse(pending.rpcId);
-                pending.responseAttempts = 0;
-                void this.sendUserQuestionResponse(bridge, pending);
+            catch (error) {
+                if (!controller.signal.aborted)
+                    return next();
+                throw userQuestionError('ask_user_question was aborted before the user answered', 'ASK_ABORTED', controller.signal.reason ?? error);
             }
-            else {
-                delete pending.response;
-                pending.state = 'waiting';
+            if (controller.signal.aborted) {
+                throw userQuestionError('ask_user_question was aborted before the user answered', 'ASK_ABORTED', controller.signal.reason);
             }
-            return;
+            const current = this.resolveUserQuestionRoute(String(agent.session.id), agent);
+            if (current.state !== 'ready' || !sameUserQuestionAuthority(route.authority, current.authority)) {
+                throw userQuestionError('delivery user-question authority changed before the answer returned', 'ASK_ABORTED');
+            }
+            if (isRecord(outcome) && outcome.outcome === 'answered') {
+                return validUserQuestionAnswer(request.questions, outcome.answer) ? outcome.answer : next();
+            }
+            if (isRecord(outcome) && outcome.outcome === 'unavailable')
+                return next();
+            if (!isRecord(outcome) || outcome.outcome !== 'cancelled')
+                return next();
+            throw userQuestionError('the user cancelled ask_user_question', 'ASK_CANCELLED');
         }
-        bridge.pending.delete(pending.rpcId);
-        this.markUserQuestionCompleted(bridge, pending.rpcId);
-    }
-    abortUserQuestionAttemptsForAdapter(adapter, reason) {
-        const bridge = this.userQuestionBridge;
-        if (bridge === undefined)
-            return;
-        for (const pending of bridge.pending.values()) {
-            if (pending.attempt?.authority.adapter === adapter)
-                pending.attempt.controller.abort(reason);
+        finally {
+            this.userQuestionAttempts.delete(attempt);
+            attempt.detachRequestAbort();
         }
     }
-    resolveUserQuestionRoute(sessionId) {
+    resolveUserQuestionRoute(sessionId, agent) {
         try {
-            return this.resolveUserQuestionRouteFromStore(sessionId);
+            return this.resolveUserQuestionRouteFromStore(sessionId, agent);
         }
         catch {
             // A transient local store failure is not proof that the owner or binding
-            // was revoked. Keep the ApiProxy request pending for replay/re-registration.
+            // was revoked. Decline this answerer and let the waterfall continue.
             return { state: 'deferred' };
         }
     }
-    resolveUserQuestionRouteFromStore(sessionId) {
+    resolveUserQuestionRouteFromStore(sessionId, agent) {
+        if (agent !== undefined) {
+            const agents = this.context.get('agents');
+            if (agents === undefined)
+                return { state: 'invalid' };
+            const live = agents.get(agent.id);
+            if (live !== agent || live.session !== agent.session || String(agent.session.id) !== sessionId) {
+                return { state: 'invalid' };
+            }
+            if (!agents.roots().includes(agent))
+                return { state: 'invalid' };
+        }
         const binding = this.deliveryStore.getBindingBySession(sessionId);
-        // The mux carries every Web session. Absence from Delivery is not a
-        // revocation signal and must never let this optional bridge cancel a
-        // question owned only by the Web UI.
+        // Absence from Delivery means this question may belong to another UI
+        // answerer; decline without converting it into a cancellation.
         if (binding === undefined)
             return { state: 'deferred' };
         const active = this.deliveryStore.getActiveBinding(binding.conversation);
@@ -1535,6 +1637,61 @@ export class AssistantDeliveryService extends Service {
                 ownerVersion: owner.version,
             } };
     }
+    /** Trusted Host configuration only; the returned capability fixes a pre-paired Web owner and scope. */
+    bindNativeWebOwner = (ctx, config) => {
+        this.assertActive();
+        const runtime = this.nativeWebRuntime;
+        if (runtime === undefined)
+            throw new AssistantDeliveryError('runtime-conflict', 'native Web runtime is unavailable');
+        if (this.nativeWebBound)
+            throw new AssistantDeliveryError('runtime-conflict', 'native Web owner Controller is already bound');
+        let access;
+        access = new NativeWebOwner(ctx, this.deliveryStore, runtime.leases, this.policy, {
+            assertActive: () => {
+                this.assertActive();
+                if (this.nativeWebRuntime !== runtime)
+                    throw new AssistantDeliveryError('runtime-conflict', 'native Web runtime changed');
+            },
+            released: () => { if (this.nativeWebOwner === access) {
+                this.nativeWebOwner = undefined;
+                this.nativeWebBound = false;
+            } },
+            policyRef: this.config.policyRef,
+            leaseMs: this.config.leaseMs,
+            prepare: (binding, envelope) => this.prepareForegroundTaskAcceptance(binding, envelope),
+            complete: (handle, input) => this.completeForegroundTaskAcceptance(handle, input),
+            claimed: (agent, envelope, turn) => this.capturePreferenceTurn(agent, { kind: 'delivery', channel: envelope.channel, account: envelope.account, eventId: envelope.eventId }, turn),
+            notifications: binding => this.deliveryStore.listOutbox({ bindingId: binding.id, limit: 50 }).filter(record => record.status === 'accepted'
+                && record.intent.metadata?.['dsh.native-notice'] === 'v1' && this.#notificationGuard(record) === undefined)
+                .map(record => ({ id: record.id, text: record.intent.text, createdAt: record.createdAt })),
+        }, config);
+        this.nativeWebOwner = access;
+        this.nativeWebBound = true;
+        const noticeAdapter = {
+            channel: 'web', account: config.principal.account,
+            capabilities: Object.freeze({ reconcileUnknownSend: true, receipts: [], formats: ['plain'] }),
+            async start() { },
+            send: async (intent) => {
+                if (this.#nativeNoticeGuard(intent) !== undefined)
+                    return { outcome: 'not-sent', failureCode: 'native-notice-invalid', retryable: false };
+                return { outcome: 'accepted', providerMessageId: this.#notificationProviderId(intent) };
+            },
+            reconcileUnknownSend: async (record) => { return record.intent.metadata?.['dsh.native-notice'] === 'v1' && this.#notificationGuard(record) === undefined ? { outcome: 'accepted', providerMessageId: this.#notificationProviderId(record.intent) } : { outcome: 'not-sent', failureCode: 'native-notice-invalid', retryable: false }; },
+        };
+        ctx.effect(() => {
+            const registration = this.registry.register(noticeAdapter);
+            void registration.catch(() => { ctx.logger.warn('assistant-delivery: native Web notification adapter registration failed'); });
+            return async () => {
+                try {
+                    const remove = await registration;
+                    await remove();
+                }
+                catch { /* Registration failure is already reported; there is no adapter to remove. */ }
+            };
+        }, 'assistant-delivery.native-web-notices');
+        runtime.ctx.effect(() => () => access.dispose(), 'assistant-delivery.native-web-runtime');
+        return access;
+    };
     currentPreferenceTurn(agent) {
         this.assertActive();
         const attestation = this.preferenceTurns.get(agent);
@@ -1554,8 +1711,8 @@ export class AssistantDeliveryService extends Service {
             || 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);
+        const started = agent.session.snapshotEvents().some(event => event.type === 'turn/start' && event.data.turn === attestation.turn);
+        const ended = agent.session.snapshotEvents().some(event => event.type === 'turn/end' && event.data.turn === attestation.turn);
         return started && !ended ? attestation : undefined;
     }
     preferencePrincipalForAgent(agent) {
@@ -2420,7 +2577,9 @@ export class AssistantDeliveryService extends Service {
      * Evolution re-proves the immutable production run; the later Inbox is a
      * separate evidence reference, never copied as prose.
      */
-    async dispatchObjectiveFeedback(binding, envelope, objectiveStatus) {
+    async dispatchObjectiveFeedback(binding, envelope, command) {
+        const parsed = typeof command === 'string' ? { kind: 'objective', objectiveStatus: command } : command;
+        const objectiveStatus = parsed.kind === 'objective-status' ? 'achieved' : parsed.objectiveStatus;
         const replyTarget = envelope.metadata?.replyToProviderMessageId;
         if (typeof replyTarget !== 'string')
             return 'invalid-target';
@@ -2435,7 +2594,23 @@ export class AssistantDeliveryService extends Service {
             || JSON.stringify(target.intent.target.principal) !== JSON.stringify(binding.principal)) {
             return 'invalid-target';
         }
+        const hostCommand = parseDeliveryCommand(inbox.envelope);
+        if (hostCommand?.name !== 'feedback' || (inbox.envelope.attachments?.length ?? 0) !== 0
+            || JSON.stringify(parseFeedbackCommand(hostCommand.rawInput)) !== JSON.stringify(parsed))
+            return 'invalid-target';
         const metadata = target.intent.metadata;
+        let goalOutcomeTarget;
+        try {
+            goalOutcomeTarget = this.deliveryStore.getGoalOutcomeTarget(target.id);
+        }
+        catch {
+            return 'invalid-target';
+        }
+        if (goalOutcomeTarget !== undefined || metadata?.['dsh.learning.kind'] === 'goal-outcome') {
+            if (goalOutcomeTarget === undefined)
+                return 'invalid-target';
+            return await this.dispatchGoalOutcomeFeedback(binding, inbox, target, parsed, goalOutcomeTarget);
+        }
         // 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
@@ -2449,17 +2624,82 @@ export class AssistantDeliveryService extends Service {
             const sourceInbox = this.deliveryStore.getInboxByProviderEvent(envelope.channel, envelope.account, sourceEventId);
             if (sourceInbox === undefined)
                 return 'invalid-target';
+            const lineage = this.ownerLineageForBinding(binding);
+            const accepted = lineage === undefined ? null : this.deliveryStore.inspectForegroundAcceptedExecutionForOwner({
+                inboxId: sourceInbox.id,
+                scope: { workspace: binding.workspace, preset: binding.agentPreset },
+                owner: lineage,
+                bindingId: binding.id,
+            });
+            const canonicalForeground = accepted !== null;
+            const projectForegroundOwner = async (inspectOnly) => {
+                const sink = this.evaluationSink;
+                if (sink === undefined || lineage === undefined)
+                    return undefined;
+                if ((parsed.kind !== 'objective' || inspectOnly) && (!['owner-objective-revision/v1', 'owner-objective-revision/v2']
+                    .includes(String(sink.registration.ownerRevisionProtocol))
+                    || typeof sink.registration.inspect !== 'function'))
+                    return undefined;
+                const operationId = `owner-feedback:${createHash('sha256').update(JSON.stringify([inbox.id, inbox.envelopeHash])).digest('hex')}`;
+                const digest = createHash('sha256').update('assistant-delivery-foreground-objective-feedback-v1\0')
+                    .update(JSON.stringify([binding.workspace, binding.agentPreset, sourceInbox.id, target.id]))
+                    .digest('hex');
+                const claims = Object.freeze({
+                    scope: Object.freeze({ workspace: binding.workspace, preset: binding.agentPreset }),
+                    situation: `foreground:${sourceInbox.id}`,
+                    subjectKind: 'foreground-turn', subjectRef: sourceInbox.id, runId: sourceInbox.id, outboxId: target.id,
+                    chatId: binding.conversation.chat, principalId: externalPrincipalId(binding.principal), bindingId: binding.id,
+                    objectiveStatus, ownerCommand: { ...lineage, operationId,
+                        action: parsed.kind === 'objective-revision' ? parsed.action : 'initial',
+                        ...(parsed.kind === 'objective-revision' ? { expectedVersion: parsed.expectedVersion, previousStatus: parsed.previousStatus } : {}), },
+                    occurredAt: inbox.receivedAt,
+                    initialIdempotencyKey: `assistant-delivery:foreground-objective-feedback-v1:${digest}`,
+                    idempotencyKey: parsed.kind === 'objective-revision' ? operationId : `assistant-delivery:foreground-objective-feedback-v1:${digest}`,
+                });
+                const capabilityReceipt = sink.registration.issueCapability(claims);
+                if (this.evaluationSink?.token !== sink.token)
+                    return undefined;
+                if (inspectOnly)
+                    return sink.registration.inspect?.(capabilityReceipt);
+                const receipt = await Promise.resolve(sink.registration.append({
+                    capabilityReceipt, runId: sourceInbox.id, outboxId: target.id, chatId: binding.conversation.chat,
+                    principalId: externalPrincipalId(binding.principal), bindingId: binding.id, idempotencyKey: claims.idempotencyKey,
+                }));
+                return typeof receipt === 'object' && receipt !== null
+                    && typeof receipt.ownerFeedbackState === 'object'
+                    ? receipt.ownerFeedbackState
+                    : undefined;
+            };
+            if (parsed.kind === 'objective-status') {
+                if (!canonicalForeground)
+                    return this.deliveryStore.verifiedWorkflowObjectiveState(target.id, lineage) ?? 'recorded';
+                try {
+                    return await projectForegroundOwner(true) ?? 'unavailable';
+                }
+                catch {
+                    return 'unknown';
+                }
+            }
+            if (canonicalForeground && this.evaluationSink === undefined)
+                return 'unavailable';
             try {
-                const recorded = this.deliveryStore.commitVerifiedWorkflowTraceFeedback({
+                // Evaluation commits first for accepted foreground tasks. If the sink
+                // is unavailable, never acknowledge a Delivery-only success; a replay
+                // can safely repeat the opaque command and then repair local workflow
+                // evidence after the canonical owner revision is durable.
+                const canonical = canonicalForeground ? await projectForegroundOwner(false) : undefined;
+                if (canonicalForeground && canonical === undefined)
+                    return 'unavailable';
+                const result = this.deliveryStore.commitVerifiedWorkflowTraceFeedback({
                     binding,
                     feedbackInboxId: inbox.id,
                     sourceInboxId: sourceInbox.id,
                     sourceOutboxId: target.id,
                     objectiveStatus,
+                    ...(parsed.kind === 'objective-revision' ? { command: parsed } : {}),
                 });
-                if (recorded.outcome === 'trace-recorded')
-                    void this.drainWorkflowTraces();
-                return 'recorded';
+                await this.drainWorkflowTraces();
+                return canonical ?? result.ownerFeedbackState ?? 'recorded';
             }
             catch (error) {
                 if (error instanceof DeliveryStoreError) {
@@ -2471,6 +2711,9 @@ export class AssistantDeliveryService extends Service {
                         || error.code === 'not-found')
                         return 'invalid-target';
                 }
+                if (typeof error === 'object' && error !== null && 'code' in error
+                    && ['idempotency-conflict', 'version-conflict'].includes(String(error.code)))
+                    return 'conflict';
                 return 'invalid-target';
             }
         }
@@ -2525,6 +2768,10 @@ export class AssistantDeliveryService extends Service {
         const sink = this.evaluationSink;
         if (sink === undefined)
             return 'unavailable';
+        if (parsed.kind !== 'objective' && (!['owner-objective-revision/v1', 'owner-objective-revision/v2']
+            .includes(String(sink.registration.ownerRevisionProtocol))
+            || typeof sink.registration.inspect !== 'function'))
+            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
@@ -2532,22 +2779,32 @@ export class AssistantDeliveryService extends Service {
         const digest = createHash('sha256').update('assistant-delivery-objective-feedback-v2\0')
             .update(JSON.stringify([binding.workspace, binding.agentPreset, target.id, runId]))
             .digest('hex');
+        const lineage = this.ownerLineageForBinding(binding);
+        if (lineage === undefined)
+            return 'invalid-target';
+        const operationId = `owner-feedback:${createHash('sha256').update(JSON.stringify([inbox.id, inbox.envelopeHash])).digest('hex')}`;
         const claims = Object.freeze({
             scope: Object.freeze({ workspace: binding.workspace, preset: binding.agentPreset }),
             situation,
             objectiveStatus,
+            ownerCommand: { ...lineage, operationId,
+                action: parsed.kind === 'objective-revision' ? parsed.action : 'initial',
+                ...(parsed.kind === 'objective-revision' ? { expectedVersion: parsed.expectedVersion, previousStatus: parsed.previousStatus } : {}), },
             runId,
             outboxId: target.id,
             chatId: binding.conversation.chat,
             principalId: externalPrincipalId(binding.principal),
             bindingId: binding.id,
             occurredAt,
-            idempotencyKey: `assistant-delivery:objective-feedback-v2:${digest}`,
+            initialIdempotencyKey: `assistant-delivery:objective-feedback-v2:${digest}`,
+            idempotencyKey: parsed.kind === 'objective-revision' ? operationId : `assistant-delivery:objective-feedback-v2:${digest}`,
         });
         try {
             const capabilityReceipt = sink.registration.issueCapability(claims);
             if (this.evaluationSink?.token !== sink.token)
                 return 'unknown';
+            if (parsed.kind === 'objective-status')
+                return sink.registration.inspect?.(capabilityReceipt) ?? 'recorded';
             const receipt = await Promise.resolve(sink.registration.append({
                 capabilityReceipt,
                 runId,
@@ -2558,15 +2815,126 @@ export class AssistantDeliveryService extends Service {
                 idempotencyKey: claims.idempotencyKey,
             }));
             if (typeof receipt !== 'object' || receipt === null
-                || receipt.idempotencyKey !== claims.idempotencyKey) {
+                || typeof receipt.idempotencyKey !== 'string') {
                 return 'unknown';
             }
-            return 'recorded';
+            return receipt.ownerFeedbackState ?? 'recorded';
+        }
+        catch (error) {
+            if (typeof error === 'object' && error !== null && 'code' in error
+                && ['idempotency-conflict', 'version-conflict'].includes(String(error.code)))
+                return 'conflict';
+            return 'unknown';
+        }
+    }
+    async dispatchGoalOutcomeFeedback(binding, inbox, target, parsed, durable) {
+        const metadata = target.intent.metadata;
+        const locator = durable.locator;
+        const immutableProof = durable.proof;
+        const situation = `goal:${locator.goalId}:definition:${immutableProof.goal.definitionVersion}`;
+        if (metadata?.['dsh.learning.schemaVersion'] !== '3'
+            || metadata['dsh.learning.kind'] !== 'goal-outcome'
+            || metadata['dsh.learning.goalId'] !== locator.goalId
+            || metadata['dsh.learning.assessmentId'] !== locator.assessmentId
+            || metadata['dsh.learning.runId'] !== immutableProof.runId
+            || metadata['dsh.learning.situation'] !== situation
+            || metadata['dsh.learning.occurredAt'] !== String(immutableProof.receipt.completedAt)
+            || metadata['dsh.learning.objectiveStatus'] !== immutableProof.receipt.objectiveStatus
+            || metadata['dsh.learning.proofDigest'] !== immutableProof.proofDigest
+            || !target.intent.text.endsWith(goalOutcomeFeedbackFooter))
+            return 'invalid-target';
+        const owner = this.deliveryStore.getPrincipal(binding.principal);
+        if (locator.bindingId !== binding.id || locator.bindingVersion !== binding.version
+            || locator.bindingGeneration !== binding.generation || locator.sessionId !== binding.sessionId
+            || locator.workspace !== binding.workspace || locator.preset !== binding.agentPreset
+            || locator.principalId !== externalPrincipalId(binding.principal)
+            || owner?.status !== 'active' || owner.role !== 'owner'
+            || locator.principalRecordId !== owner.id || locator.principalVersion !== owner.version)
+            return 'invalid-target';
+        let route;
+        try {
+            route = this.resolveOwnerRoute(locator.ownerRouteId);
+        }
+        catch {
+            return 'invalid-target';
+        }
+        if (route.binding.id !== binding.id || route.binding.version !== binding.version
+            || route.binding.generation !== binding.generation || route.binding.sessionId !== binding.sessionId) {
+            return 'invalid-target';
+        }
+        const issuer = this.context.get('assistantGoals', false);
+        if (!isGoalOutcomeFeedbackAuthority(issuer))
+            return 'unavailable';
+        let goalOutcomeCapability;
+        try {
+            goalOutcomeCapability = issuer.issueOwnerGoalOutcomeFeedbackTarget(locator);
+        }
+        catch {
+            return 'invalid-target';
+        }
+        const resolver = this.context.get('assistantGoals', false);
+        if (!isGoalOutcomeFeedbackAuthority(resolver))
+            return 'unavailable';
+        let currentProof;
+        try {
+            currentProof = validateOwnerGoalOutcomeFeedbackProof(resolver.resolveOwnerGoalOutcomeFeedbackTarget(goalOutcomeCapability));
+        }
+        catch {
+            return 'invalid-target';
+        }
+        // Expiry is not an identity change: the owner is allowed to label the
+        // immutable result after its verifier freshness window has elapsed.
+        if (acceptanceCanonicalJson(currentProof) !== acceptanceCanonicalJson(immutableProof))
+            return 'invalid-target';
+        const sink = this.evaluationSink;
+        const registration = sink?.registration;
+        if (sink === undefined || registration?.ownerRevisionProtocol !== 'owner-objective-revision/v2'
+            || typeof registration.inspect !== 'function')
+            return 'unavailable';
+        const objectiveStatus = parsed.kind === 'objective-status' ? 'achieved' : parsed.objectiveStatus;
+        const operationId = `owner-feedback:${createHash('sha256')
+            .update(JSON.stringify([inbox.id, inbox.envelopeHash])).digest('hex')}`;
+        const digest = createHash('sha256').update('assistant-delivery-goal-outcome-feedback-v1\0')
+            .update(JSON.stringify([binding.workspace, binding.agentPreset, locator.goalId, locator.assessmentId, target.id]))
+            .digest('hex');
+        const idempotencyKey = parsed.kind === 'objective-revision'
+            ? operationId : `assistant-delivery:goal-outcome-feedback-v1:${digest}`;
+        const claims = Object.freeze({
+            scope: Object.freeze({ workspace: binding.workspace, preset: binding.agentPreset }),
+            situation, subjectKind: 'goal-outcome', subjectRef: locator.assessmentId,
+            runId: locator.assessmentId, outboxId: target.id, chatId: binding.conversation.chat,
+            principalId: locator.principalId, bindingId: binding.id, objectiveStatus, goalOutcomeCapability,
+            ownerCommand: { principalRecordId: locator.principalRecordId, principalVersion: locator.principalVersion,
+                operationId, action: parsed.kind === 'objective-revision' ? parsed.action : 'initial',
+                ...(parsed.kind === 'objective-revision'
+                    ? { expectedVersion: parsed.expectedVersion, previousStatus: parsed.previousStatus }
+                    : {}), },
+            occurredAt: immutableProof.receipt.completedAt,
+            initialIdempotencyKey: `assistant-delivery:goal-outcome-feedback-v1:${digest}`,
+            idempotencyKey,
+        });
+        try {
+            const capabilityReceipt = registration.issueCapability(claims);
+            if (this.evaluationSink?.token !== sink.token)
+                return 'unknown';
+            if (parsed.kind === 'objective-status')
+                return registration.inspect(capabilityReceipt) ?? 'recorded';
+            const receipt = await Promise.resolve(registration.append({
+                capabilityReceipt, runId: locator.assessmentId, outboxId: target.id,
+                chatId: binding.conversation.chat, principalId: locator.principalId,
+                bindingId: binding.id, idempotencyKey,
+            }));
+            if (typeof receipt !== 'object' || receipt === null
+                || typeof receipt.idempotencyKey !== 'string')
+                return 'unknown';
+            return receipt
+                .ownerFeedbackState ?? 'recorded';
         }
         catch (error) {
             if (typeof error === 'object' && error !== null && 'code' in error
-                && error.code === 'idempotency-conflict')
+                && ['idempotency-conflict', 'version-conflict'].includes(String(error.code))) {
                 return 'conflict';
+            }
             return 'unknown';
         }
     }
@@ -2632,7 +3000,7 @@ export class AssistantDeliveryService extends Service {
         const agents = ctx.get('agents');
         const sessions = ctx.get('sessions');
         const agent = request.agent;
-        const events = agent.session.events;
+        const events = agent.session.snapshotEvents();
         const reviewer = approvalReviewerOf(events);
         const reviewRoute = reviewer === 'user'
             ? 'user'
@@ -2706,7 +3074,7 @@ export class AssistantDeliveryService extends Service {
             ['owner', owner.id, owner.version, owner.role, owner.status, owner.linkedToId ?? null,
                 [owner.principal.channel, owner.principal.account, owner.principal.tenant, owner.principal.user]],
             ['session', header.version, sessionId, header.createdAt, header.cwd ?? null,
-                header.parentSession ?? null, header.seedLength ?? null, header.origin ?? null,
+                header.parentSession ?? null, header.isSeeded, agent.session.inheritedEventCount, header.origin ?? null,
                 header.delegationDepth ?? null, header.agentPreset ?? null],
             ['route-kind', route.kind],
             ['review-route', reviewRoute],
@@ -2737,7 +3105,7 @@ export class AssistantDeliveryService extends Service {
             return next();
         let reviewer;
         try {
-            reviewer = approvalReviewerOf(request.agent.session.events);
+            reviewer = approvalReviewerOf(request.agent.session.snapshotEvents());
         }
         catch {
             return 'unavailable';
@@ -2861,7 +3229,7 @@ export class AssistantDeliveryService extends Service {
         }
         return approvalOutcomes.includes(outcome) ? outcome : 'unavailable';
     }
-    async acceptInbound(envelope) {
+    async acceptInbound(envelope, recoverySignal) {
         this.assertActive();
         const accepted = this.deliveryStore.acceptInbound(envelope);
         let record = accepted.record;
@@ -2882,7 +3250,7 @@ export class AssistantDeliveryService extends Service {
         const sessionCommand = parseDeliveryCommand(envelope);
         if (isExactDeliveryCommand(sessionCommand, 'new', 'clear')) {
             return await this.runConversationTransition(envelope.conversation, async () => {
-                await this.recoverPendingInbound(envelope, record.id);
+                await this.recoverPendingInbound(envelope, record.id, recoverySignal);
                 // A provider retry can arrive while the first copy is waiting for the
                 // old generation to drain. Re-read after acquiring the transition:
                 // once that copy queued the command, its rotation is already complete
@@ -2896,7 +3264,7 @@ export class AssistantDeliveryService extends Service {
                     };
                 }
                 record = currentRecord;
-                const binding = await this.bindingForInbound(envelope, record.id);
+                const binding = await this.bindingForInbound(envelope, record.id, recoverySignal);
                 if (binding === undefined) {
                     const failed = this.deliveryStore.getInbox(record.id);
                     return { duplicate: accepted.duplicate, inboxId: failed.id, status: failed.status };
@@ -2911,7 +3279,7 @@ export class AssistantDeliveryService extends Service {
                 });
                 await this.runtime?.cancelActive?.(binding, 'new');
                 await this.inbound.cancelUndispatchedClaims(fence.claimedInboxIds, 'new');
-                const rotated = await this.rotateBinding(envelope, binding, record.id);
+                const rotated = await this.rotateBinding(envelope, binding, record.id, recoverySignal);
                 record = this.deliveryStore.getInbox(record.id);
                 if (record.status !== 'queued' || record.bindingId !== rotated.id) {
                     throw new AssistantDeliveryError('runtime-conflict', 'new-session binding committed without its command Inbox');
@@ -2921,7 +3289,7 @@ export class AssistantDeliveryService extends Service {
         }
         if (isExactDeliveryCommand(sessionCommand, 'stop')) {
             return await this.runConversationTransition(envelope.conversation, async () => {
-                await this.recoverPendingInbound(envelope, record.id);
+                await this.recoverPendingInbound(envelope, record.id, recoverySignal);
                 const currentRecord = this.deliveryStore.getInbox(record.id);
                 if (!['received', 'authorized'].includes(currentRecord.status)) {
                     return {
@@ -2931,7 +3299,7 @@ export class AssistantDeliveryService extends Service {
                     };
                 }
                 record = currentRecord;
-                const binding = await this.bindingForInbound(envelope, record.id);
+                const binding = await this.bindingForInbound(envelope, record.id, recoverySignal);
                 if (binding === undefined) {
                     const failed = this.deliveryStore.getInbox(record.id);
                     return { duplicate: accepted.duplicate, inboxId: failed.id, status: failed.status };
@@ -2953,7 +3321,7 @@ export class AssistantDeliveryService extends Service {
         // It serializes only durable admission (not Agent execution), and makes a
         // queued `/stop` or `/new` an unambiguous boundary for later arrivals.
         return await this.runConversationTransition(envelope.conversation, async () => {
-            await this.recoverPendingInbound(envelope, record.id);
+            await this.recoverPendingInbound(envelope, record.id, recoverySignal);
             const currentRecord = this.deliveryStore.getInbox(record.id);
             if (!['received', 'authorized'].includes(currentRecord.status)) {
                 return {
@@ -2963,7 +3331,7 @@ export class AssistantDeliveryService extends Service {
                 };
             }
             record = currentRecord;
-            const binding = await this.bindingForInbound(envelope, record.id);
+            const binding = await this.bindingForInbound(envelope, record.id, recoverySignal);
             if (binding === undefined) {
                 const failed = this.deliveryStore.getInbox(record.id);
                 return { duplicate: accepted.duplicate, inboxId: failed.id, status: failed.status };
@@ -2974,9 +3342,12 @@ 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');
+        if (containsReservedLearningMetadata(input.metadata) || Object.keys(input.metadata ?? {}).some(key => key.startsWith('dsh.native-notice'))) {
+            throw new AssistantDeliveryError('runtime-conflict', 'reserved metadata requires its typed delivery interface');
         }
+        return this.enqueueBackgroundAuthorized(input);
+    }
+    enqueueBackgroundAuthorized(input) {
         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');
@@ -2997,6 +3368,126 @@ export class AssistantDeliveryService extends Service {
             format: input.format ?? 'plain',
             ...(input.metadata === undefined ? {} : { metadata: input.metadata }) });
     }
+    #notificationGuard(record) {
+        const metadata = record.intent.metadata;
+        const nativeKeys = Object.keys(metadata ?? {}).filter(key => key.startsWith('dsh.native-notice'));
+        if (nativeKeys.length > 0) {
+            // Native adapter sends receive only an intent, so never bind a fabricated
+            // outbox id into the goal-outcome sidecar lookup. A persisted record still
+            // rejects any sidecar collision before native authority is considered.
+            if (containsReservedLearningMetadata(metadata))
+                return { outcome: 'not-sent', failureCode: 'native-notice-invalid', retryable: false };
+            if (typeof record.id === 'string') {
+                try {
+                    if (this.deliveryStore.getGoalOutcomeTarget(record.id) !== undefined)
+                        return { outcome: 'not-sent', failureCode: 'native-notice-invalid', retryable: false };
+                }
+                catch {
+                    return { outcome: 'not-sent', failureCode: 'goal-outcome-target-invalid', retryable: false };
+                }
+            }
+            return this.#nativeNoticeGuard(record.intent);
+        }
+        let goalTarget;
+        try {
+            goalTarget = this.deliveryStore.getGoalOutcomeTarget(record.id);
+        }
+        catch {
+            return { outcome: 'not-sent', failureCode: 'goal-outcome-target-invalid', retryable: false };
+        }
+        if (goalTarget !== undefined || metadata?.['dsh.learning.kind'] === 'goal-outcome') {
+            if (goalTarget === undefined) {
+                return { outcome: 'not-sent', failureCode: 'goal-outcome-target-missing', retryable: false };
+            }
+            const locator = goalTarget.locator;
+            const proof = goalTarget.proof;
+            const binding = this.deliveryStore.getBinding(record.intent.bindingId);
+            const owner = binding === undefined ? undefined : this.deliveryStore.getPrincipal(binding.principal);
+            try {
+                if (proof.receipt.completedAt > Date.now() || proof.receipt.validUntil <= Date.now()) {
+                    throw new Error('goal outcome receipt expired');
+                }
+                // One captured service reference must both issue and resolve the
+                // process-local capability. A replacement cannot inherit authority.
+                const goals = this.context.get('assistantGoals', false);
+                if (!isGoalOutcomeFeedbackAuthority(goals))
+                    throw new Error('Goals unavailable');
+                const capability = goals.issueOwnerGoalOutcomeFeedbackTarget(locator);
+                const currentGoals = this.context.get('assistantGoals', false);
+                if (!isGoalOutcomeFeedbackAuthority(currentGoals))
+                    throw new Error('current Goals unavailable');
+                const currentProof = validateOwnerGoalOutcomeFeedbackProof(currentGoals.resolveOwnerGoalOutcomeFeedbackTarget(capability));
+                if (acceptanceCanonicalJson(currentProof) !== acceptanceCanonicalJson(proof)) {
+                    throw new Error('goal outcome proof changed');
+                }
+                const route = this.resolveOwnerRoute(locator.ownerRouteId);
+                if (binding?.status !== 'active' || route.binding.id !== binding.id
+                    || route.binding.version !== locator.bindingVersion
+                    || route.binding.generation !== locator.bindingGeneration
+                    || route.binding.sessionId !== locator.sessionId || binding.workspace !== locator.workspace
+                    || binding.agentPreset !== locator.preset || externalPrincipalId(binding.principal) !== locator.principalId
+                    || owner?.status !== 'active' || owner.role !== 'owner'
+                    || owner.id !== locator.principalRecordId || owner.version !== locator.principalVersion) {
+                    throw new Error('goal outcome route changed');
+                }
+                const permission = this.policy.evaluate({ subject: { kind: 'background', id: 'assistant-goals-wake/v1',
+                        workspace: locator.workspace, principal: locator.principalId }, action: 'send',
+                    resource: { kind: 'message', id: binding.id }, context: { initiator: 'background' } });
+                if (permission.effect !== 'allow')
+                    throw new Error('goal outcome send denied');
+            }
+            catch {
+                return { outcome: 'not-sent', failureCode: 'goal-outcome-authority-revoked', retryable: false };
+            }
+            return undefined;
+        }
+        return undefined;
+    }
+    #nativeNoticeGuard(intent) {
+        const metadata = intent.metadata;
+        const nativeKeys = Object.keys(metadata ?? {}).filter(key => key.startsWith('dsh.native-notice'));
+        if (nativeKeys.length === 0 || containsReservedLearningMetadata(metadata))
+            return { outcome: 'not-sent', failureCode: 'native-notice-invalid', retryable: false };
+        if (metadata?.['dsh.native-notice'] !== 'v1')
+            return { outcome: 'not-sent', failureCode: 'native-notice-invalid', retryable: false };
+        const expiresAt = Number(metadata['dsh.native-notice.expiresAt']);
+        const binding = this.deliveryStore.getBinding(intent.bindingId);
+        const owner = binding === undefined ? undefined : this.deliveryStore.getPrincipal(binding.principal);
+        if (!Number.isSafeInteger(expiresAt) || Date.now() >= expiresAt || binding?.status !== 'active' || owner?.status !== 'active' || owner.role !== 'owner'
+            || owner.id !== metadata['dsh.native-notice.ownerRecordId'] || String(owner.version) !== metadata['dsh.native-notice.ownerVersion']
+            || String(binding.version) !== metadata['dsh.native-notice.bindingVersion'] || String(binding.generation) !== metadata['dsh.native-notice.bindingGeneration'] || binding.sessionId !== metadata['dsh.native-notice.sessionId'])
+            return { outcome: 'not-sent', failureCode: 'native-notice-authority-expired', retryable: false };
+        try {
+            const sourceId = canonicalBackgroundSourceId(metadata['dsh.native-notice.sourceId']);
+            const current = this.resolveOwnerRoute(metadata['dsh.native-notice.ownerRouteId']).binding;
+            if (current.id !== binding.id || current.version !== binding.version || current.generation !== binding.generation || current.sessionId !== binding.sessionId)
+                throw new Error('route changed');
+            const permission = this.policy.evaluate({ subject: { kind: 'background', id: sourceId, workspace: binding.workspace, principal: externalPrincipalId(binding.principal) }, action: 'send', resource: { kind: 'message', id: binding.id }, context: { initiator: 'background' } });
+            if (permission.effect !== 'allow')
+                throw new Error('send denied');
+        }
+        catch {
+            return { outcome: 'not-sent', failureCode: 'native-notice-policy-revoked', retryable: false };
+        }
+        return undefined;
+    }
+    #notificationProviderId(intent) { return `native-notice:${createHash('sha256').update(intent.idempotencyKey).update('\u0000').update(intent.bindingId).update('\u0000').update(intent.text).digest('hex')}`; }
+    /** Queue a typed owner notice. Accepted means queued; it never asserts user read. */
+    enqueueOwnerNotification(input) {
+        this.assertActive();
+        if (!Number.isSafeInteger(input.expiresAt) || input.expiresAt <= Date.now() || typeof input.text !== 'string' || input.text.length === 0 || input.text.length > 16_384)
+            throw new AssistantDeliveryError('policy-denied', 'owner notification is invalid or expired');
+        const resolved = this.resolveOwnerRoute(input.ownerRouteId);
+        const binding = resolved.binding;
+        const owner = this.deliveryStore.getPrincipal(binding.principal);
+        if (binding.sessionId !== input.sessionId || binding.workspace !== input.scope.workspace || binding.agentPreset !== input.scope.preset
+            || externalPrincipalId(binding.principal) !== input.scope.principalId || owner?.id !== input.scope.principalRecordId || owner.version !== input.scope.principalVersion)
+            throw new AssistantDeliveryError('policy-denied', 'owner notification authority is no longer current');
+        return this.enqueueBackgroundAuthorized({ sourceId: input.sourceId, workspace: binding.workspace, bindingId: binding.id, idempotencyKey: input.idempotencyKey, text: input.text, format: 'plain', metadata: {
+                'dsh.native-notice': 'v1', 'dsh.native-notice.sourceId': input.sourceId, 'dsh.native-notice.ownerRouteId': input.ownerRouteId, 'dsh.native-notice.expiresAt': String(input.expiresAt), 'dsh.native-notice.ownerRecordId': owner.id,
+                'dsh.native-notice.ownerVersion': String(owner.version), 'dsh.native-notice.bindingVersion': String(binding.version), 'dsh.native-notice.bindingGeneration': String(binding.generation), 'dsh.native-notice.sessionId': binding.sessionId,
+            } });
+    }
     /**
      * Dedicated Automation result lane. Every learning field is derived from an
      * authoritative Automations receipt; callers cannot supply metadata,
@@ -3402,6 +3893,7 @@ export class AssistantDeliveryService extends Service {
     }
     async tick() {
         this.assertActive();
+        await this.drainInboundAdmissions();
         await this.inbound.tick();
         await this.drainModelSelectionSettlements();
         this.drainApprovalDispatches();
@@ -3419,6 +3911,7 @@ export class AssistantDeliveryService extends Service {
             this.presentationFlight,
             this.preferenceProjectionFlight,
             this.workflowTraceFlight,
+            this.inboundAdmissionRecoveryFlight,
         ]);
     }
     start() {
@@ -3433,7 +3926,7 @@ export class AssistantDeliveryService extends Service {
         this.assertActive();
         await this.stopInternal();
     }
-    async ensureBinding(envelope) {
+    async ensureBinding(envelope, signal) {
         const key = JSON.stringify(envelope.conversation);
         const existing = this.bindingFlights.get(key);
         if (existing !== undefined)
@@ -3442,11 +3935,15 @@ export class AssistantDeliveryService extends Service {
         if (runtime === undefined)
             throw new AssistantDeliveryError('runtime-unavailable', 'inbound runtime is unavailable');
         const promise = (async () => {
+            signal?.throwIfAborted();
             const current = this.deliveryStore.getActiveBinding(envelope.conversation);
             if (current !== undefined)
                 return current;
             const generation = this.deliveryStore.nextBindingGeneration(envelope.conversation);
-            const created = await runtime.createSession({ envelope, generation, signal: new AbortController().signal });
+            const created = await runtime.createSession({
+                envelope, generation, signal: signal ?? new AbortController().signal,
+            });
+            signal?.throwIfAborted();
             this.assertActive();
             return this.deliveryStore.createBinding({ conversation: envelope.conversation, principal: envelope.principal,
                 workspace: created.workspace, agentPreset: created.agentPreset, sessionId: created.sessionId,
@@ -3455,14 +3952,68 @@ export class AssistantDeliveryService extends Service {
         this.bindingFlights.set(key, promise);
         return promise;
     }
-    async bindingForInbound(envelope, inboxId) {
+    drainInboundAdmissions() {
+        if (this.inboundAdmissionRecoveryFlight !== undefined)
+            return this.inboundAdmissionRecoveryFlight;
+        const flight = this.runInboundAdmissionRecovery()
+            .finally(() => { if (this.inboundAdmissionRecoveryFlight === flight)
+            this.inboundAdmissionRecoveryFlight = undefined; });
+        this.inboundAdmissionRecoveryFlight = flight;
+        return flight;
+    }
+    async runInboundAdmissionRecovery() {
+        if (this.runtime === undefined)
+            return;
+        let pending = this.deliveryStore.listRecoverableInboundAdmissions({
+            afterSequence: this.inboundAdmissionRecoveryAfterSequence,
+            limit: 100,
+        });
+        if (pending.length === 0 && this.inboundAdmissionRecoveryAfterSequence !== 0) {
+            this.inboundAdmissionRecoveryAfterSequence = 0;
+            pending = this.deliveryStore.listRecoverableInboundAdmissions({ limit: 100 });
+        }
+        for (const admission of pending) {
+            if (!this.active || this.runtime === undefined)
+                return;
+            this.inboundAdmissionRecoveryController.signal.throwIfAborted();
+            this.inboundAdmissionRecoveryAfterSequence = admission.admissionCursor.sequence;
+            try {
+                const current = this.deliveryStore.getInbox(admission.id);
+                if (current === undefined || !['received', 'authorized'].includes(current.status))
+                    continue;
+                await this.acceptInbound(current.envelope, this.inboundAdmissionRecoveryController.signal);
+            }
+            catch (error) {
+                if (!this.active)
+                    return;
+                this.context.logger.warn(`assistant-delivery: deferred recovery of Inbox ${admission.id}: ${String(error)}`);
+            }
+        }
+    }
+    async bindingForInbound(envelope, inboxId, signal) {
+        const admission = this.deliveryStore.getInbox(inboxId);
+        if (admission === undefined || !['received', 'authorized'].includes(admission.status)) {
+            return undefined;
+        }
         let binding = this.deliveryStore.getActiveBinding(envelope.conversation);
+        if (admission.status === 'authorized') {
+            const recorded = admission.bindingId === undefined
+                ? undefined
+                : this.deliveryStore.getBinding(admission.bindingId);
+            if (recorded === undefined || binding?.id !== recorded.id
+                || binding.version !== recorded.version || binding.generation !== recorded.generation
+                || binding.sessionId !== recorded.sessionId) {
+                this.deliveryStore.deadLetterInbox(inboxId, 'inbound-binding-superseded');
+                return undefined;
+            }
+            binding = recorded;
+        }
         if (binding === undefined) {
             if (this.runtime === undefined) {
                 this.deliveryStore.deadLetterInbox(inboxId, 'runtime-unavailable');
                 return undefined;
             }
-            binding = await this.ensureBinding(envelope);
+            binding = await this.ensureBinding(envelope, signal);
         }
         if (externalPrincipalId(binding.principal) !== externalPrincipalId(envelope.principal)) {
             this.deliveryStore.deadLetterInbox(inboxId, 'binding-principal-mismatch');
@@ -3477,8 +4028,9 @@ export class AssistantDeliveryService extends Service {
      * original durable Inbox order. This includes ordinary messages that were
      * already persisted behind a blocked `/stop` or `/new` transition.
      */
-    async recoverPendingInbound(boundary, beforeInboxId) {
+    async recoverPendingInbound(boundary, beforeInboxId, signal) {
         while (true) {
+            signal?.throwIfAborted();
             const pending = this.deliveryStore.findPendingInboundBefore({
                 conversation: boundary.conversation,
                 principal: boundary.principal,
@@ -3503,7 +4055,8 @@ export class AssistantDeliveryService extends Service {
             const command = parseDeliveryCommand(pending.envelope);
             const reset = isExactDeliveryCommand(command, 'new', 'clear');
             const stop = isExactDeliveryCommand(command, 'stop');
-            const binding = await this.bindingForInbound(pending.envelope, pending.id);
+            const binding = await this.bindingForInbound(pending.envelope, pending.id, signal);
+            signal?.throwIfAborted();
             if (binding === undefined)
                 continue;
             if (!reset && !stop) {
@@ -3517,9 +4070,11 @@ export class AssistantDeliveryService extends Service {
             });
             const cancellationCommand = reset ? 'new' : 'stop';
             await this.runtime?.cancelActive?.(binding, cancellationCommand);
+            signal?.throwIfAborted();
             await this.inbound.cancelUndispatchedClaims(fence.claimedInboxIds, cancellationCommand);
+            signal?.throwIfAborted();
             if (reset) {
-                await this.rotateBinding(pending.envelope, binding, pending.id);
+                await this.rotateBinding(pending.envelope, binding, pending.id, signal);
             }
             else {
                 this.deliveryStore.queueInbox(pending.id, binding.id);
@@ -3543,7 +4098,7 @@ export class AssistantDeliveryService extends Service {
                 this.conversationTransitions.delete(key);
         }
     }
-    async rotateBinding(envelope, previous, commandInboxId) {
+    async rotateBinding(envelope, previous, commandInboxId, signal) {
         const key = `${JSON.stringify(envelope.conversation)}:/new:${envelope.eventId}`;
         const existing = this.bindingFlights.get(key);
         if (existing !== undefined)
@@ -3552,6 +4107,7 @@ export class AssistantDeliveryService extends Service {
         if (runtime === undefined)
             throw new AssistantDeliveryError('runtime-unavailable', 'inbound runtime is unavailable');
         const promise = (async () => {
+            signal?.throwIfAborted();
             const current = this.deliveryStore.getActiveBinding(envelope.conversation);
             if (current === undefined)
                 throw new AssistantDeliveryError('missing-binding', 'active binding disappeared during /new');
@@ -3562,7 +4118,8 @@ export class AssistantDeliveryService extends Service {
                 throw new AssistantDeliveryError('runtime-conflict', 'binding generation changed before /new session creation');
             }
             const created = await runtime.createSession({ envelope, generation,
-                previous: current, signal: new AbortController().signal });
+                previous: current, signal: signal ?? new AbortController().signal });
+            signal?.throwIfAborted();
             this.assertActive();
             return this.deliveryStore.rotateBindingAndQueueCommand({
                 bindingId: current.id,
@@ -3588,9 +4145,20 @@ export class AssistantDeliveryService extends Service {
         this.workflowTraceRetryTimer = undefined;
         this.preferenceProjectionRetryTimer = undefined;
         this.cancelModelSelectionWaiters();
+        this.inboundAdmissionRecoveryController.abort(new Error('assistant-delivery is stopping'));
+        const admissionRecovery = this.inboundAdmissionRecoveryFlight === undefined
+            ? undefined
+            : Promise.race([
+                this.inboundAdmissionRecoveryFlight,
+                new Promise(resolve => {
+                    const timeout = setTimeout(resolve, Math.max(1, Math.floor(this.config.leaseMs / 3)));
+                    timeout.unref?.();
+                }),
+            ]);
         await Promise.all([
             this.inbound.stop(),
             this.outbound.stop(),
+            admissionRecovery,
             this.modelSelectionFlight,
             this.presentationFlight,
             this.preferenceProjectionFlight,