@dsh-enhanced/assistant-delivery 0.1.48 → 0.1.49

package/lib/service.js

@@ -4,16 +4,16 @@ import { createHash, randomUUID } from 'node:crypto';
 import { Context, Service } from '@deepseek-ai/cordis';
 import Schema from '@deepseek-ai/schemastery';
 import { acceptanceCanonicalJson, goalDefinitionSituation } from '@dsh-enhanced/task-acceptance-contract';
-import { approvalReviewerOf, isAutoReviewEscalation, } from '@dsh-enhanced/assistant-policy';
+import { approvalReviewerOf, } from '@dsh-enhanced/assistant-policy';
 // Cross-package wire literal, kept locally so this bundle can load without the
 // optional assistant-evaluation peer installed (a value import would defeat
 // peerDependenciesMeta.optional at module link time).  Must stay identical to
 // TRUSTED_EVALUATION_PRODUCER_PROTOCOL in assistant-evaluation.
 const TRUSTED_EVALUATION_PRODUCER_PROTOCOL = 'assistant-evaluation/trusted-producer/v1';
-import { ASSISTANT_GROWTH_CONTRACT_VERSION, growthObjectDigest, validateResolvedWorkflowAutomationTemplate, validateWorkflowAutomationTemplate, validateWorkflowScope, validateWorkflowTraceProjectionReceipt, workflowArgumentShapeDigest, } from '@dsh-enhanced/assistant-growth-contract';
+import { ASSISTANT_GROWTH_CONTRACT_VERSION, growthObjectDigest, isSourceOwnerContinuation, 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 { DshDeliveryRuntime, redactOwnerLearningReply } 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';
@@ -24,7 +24,7 @@ import { bindingMatchesOwnerRoute, canonicalBackgroundSourceId as canonicalHostB
 import { isExactDeliveryCommand, parseDeliveryCommand } from './session-commands.js';
 import { deliveryT1PreferenceKeys, deliveryT1PreferenceValues } from './learning-command.js';
 import { assertReplyReplayAllowed, blockAgentRepliesForReplay as createReplyReplayBlock, } from './reply-replay.js';
-import { feedbackSignalInput, parseFeedbackCommand, classifyNaturalPreferenceDirective, observedResponseLanguage, } from './feedback-command.js';
+import { feedbackSignalInput, parseFeedbackCommand, parseNaturalObjectiveFeedback, 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');
@@ -491,7 +491,7 @@ function exactToolApprovalCall(events, openTurn, callId, toolName) {
                     callId, event.data.name, event.data.arguments],
             });
         }
-        if (event.type === 'tool/code-dispatch-start' && String(event.data.subCallId) === callId) {
+        if (event.type === 'tool/ptc-dispatch-start' && String(event.data.subCallId) === callId) {
             const rootCallId = String(event.data.rootCallId);
             const parentCallId = String(event.data.parentCallId);
             const argumentsJson = serializeCodeDispatchArguments(event.data.arguments);
@@ -503,14 +503,14 @@ function exactToolApprovalCall(events, openTurn, callId, toolName) {
                 seq: event.seq,
                 name: event.data.name,
                 arguments: argumentsJson,
-                hashIdentity: ['tool/code-dispatch-start', event.seq, rootCallId, parentCallId,
+                hashIdentity: ['tool/ptc-dispatch-start', event.seq, rootCallId, parentCallId,
                     callId, event.data.name, argumentsJson],
             });
         }
         if (event.type === 'tool/result'
             && String(event.data.message.source.callId) === callId)
             settled = true;
-        if (event.type === 'tool/code-dispatch'
+        if (event.type === 'tool/ptc-dispatch'
             && String(event.data.subCallId) === callId)
             settled = true;
     }
@@ -560,6 +560,7 @@ export class AssistantDeliveryService extends Service {
     modelSelectionFlight;
     presentationFlight;
     workflowTraceFlight;
+    naturalObjectiveFlight;
     preferenceProjectionFlight;
     inboundAdmissionRecoveryFlight;
     inboundAdmissionRecoveryAfterSequence = 0;
@@ -696,6 +697,7 @@ export class AssistantDeliveryService extends Service {
                 dispatchPreferenceFeedback: events => this.dispatchPreferenceFeedback(events),
                 replyCompletedPreferenceTurn: (agent, binding, envelope, reply) => this.replyCompletedPreferenceTurn(agent, binding, envelope, reply),
                 dispatchObjectiveFeedback: (binding, envelope, objectiveStatus) => this.dispatchObjectiveFeedback(binding, envelope, objectiveStatus),
+                dispatchNaturalObjectiveFeedback: (binding, envelope) => this.dispatchNaturalObjectiveFeedback(binding, envelope),
                 dispatchWorkflowCommand: (binding, envelope, command) => this.dispatchWorkflowCommand(binding, envelope, command),
                 dispatchLearningCommand: (binding, envelope, action, preferenceKey) => this.dispatchLearningCommand(binding, envelope, action, preferenceKey),
                 authorizePermissionReply: (binding, envelope) => this.authorizePermissionReply(binding, envelope),
@@ -728,7 +730,8 @@ export class AssistantDeliveryService extends Service {
         // A plain approval/request listener can be starved by an earlier remote
         // waterfall (notably a Web-enabled Host with a headless Lark conversation).
         ctx.inject(['approval', 'assistantPolicy'], approvalCtx => approvalCtx.effect(() => {
-            if (typeof approvalCtx.assistantPolicy.registerHumanApprovalAnswerer !== 'function') {
+            if (typeof approvalCtx.assistantPolicy.registerHumanApprovalAnswerer !== 'function'
+                || typeof approvalCtx.assistantPolicy.isAutoReviewEscalation !== 'function') {
                 throw new Error('assistant-delivery: upgrade assistant-policy with Delivery; human approval routing is unavailable');
             }
             return approvalCtx.assistantPolicy.registerHumanApprovalAnswerer((request, next) => this.requestToolApproval(approvalCtx, request, next));
@@ -1843,6 +1846,83 @@ export class AssistantDeliveryService extends Service {
         runtime.ctx.effect(() => () => access.dispose(), 'assistant-delivery.native-web-runtime');
         return access;
     };
+    /** Host-only proof of a single live native tool call in the exact claimed owner Inbox. */
+    inspectOwnerForegroundToolCall(input) {
+        if (!input || typeof input !== 'object'
+            || typeof input.authorityId !== 'string' || input.authorityId.length === 0
+            || typeof input.callId !== 'string' || input.callId.length === 0
+            || typeof input.toolName !== 'string' || input.toolName.length === 0
+            || typeof input.argumentsJson !== 'string'
+            || Buffer.byteLength(input.authorityId) > toolApprovalIdentityBytes
+            || Buffer.byteLength(input.callId) > toolApprovalIdentityBytes
+            || Buffer.byteLength(input.toolName) > toolApprovalIdentityBytes
+            || Buffer.byteLength(input.argumentsJson) > toolApprovalArgumentBytes)
+            return undefined;
+        const route = this.validateOwnerAgentForRoute(input.agent, input.authorityId);
+        if (route === undefined)
+            return undefined;
+        const turn = this.currentPreferenceTurn(input.agent);
+        if (turn === undefined || turn.principalId !== route.principalId
+            || turn.principalLineage.principalRecordId !== route.principalRecordId
+            || turn.principalLineage.principalVersion !== route.principalVersion
+            || turn.scope.workspace !== route.workspace || turn.scope.preset !== route.agentPreset
+            || turn.bindingVersion !== route.bindingVersion
+            || turn.sessionId !== String(input.agent.session.id))
+            return undefined;
+        const task = this.deliveryStore.inspectPendingForegroundToolTask({
+            inboxId: turn.sourceInboxId, sessionId: turn.sessionId, scope: turn.scope,
+            owner: turn.principalLineage,
+            binding: { id: turn.bindingId, version: turn.bindingVersion, generation: route.generation },
+        });
+        if (task === undefined)
+            return undefined;
+        const events = input.agent.session.snapshotEvents();
+        const openTurn = events.findLast(event => event.type === 'turn/start' || event.type === 'turn/end');
+        if (openTurn?.type !== 'turn/start' || openTurn.data.turn !== turn.turn)
+            return undefined;
+        const nativeCalls = events.filter((event) => event.type === 'tool/call' && event.seq > openTurn.seq
+            && event.data.turn === turn.turn && String(event.data.callId) === input.callId);
+        const unresolved = nativeCalls.filter(call => !events.some(event => event.type === 'tool/result'
+            && event.seq > call.seq && String(event.data.message.source.callId) === String(call.data.callId)));
+        if (unresolved.length !== 1)
+            return undefined;
+        const call = unresolved[0];
+        const currentStep = events.findLast(event => (event.type === 'step/start' || event.type === 'step/end')
+            && event.data.turn === turn.turn);
+        if (String(call.data.callId) !== input.callId || call.data.name !== input.toolName
+            || !Number.isSafeInteger(call.seq) || !Number.isSafeInteger(call.data.step)
+            || typeof call.data.arguments !== 'string'
+            || Buffer.byteLength(call.data.arguments) > toolApprovalArgumentBytes
+            || events.some(event => event !== call && ((event.type === 'tool/call'
+                && String(event.data.callId) === input.callId)
+                || (event.type === 'tool/ptc-dispatch-start' && String(event.data.subCallId) === input.callId)))
+            || currentStep?.type !== 'step/start' || currentStep.seq <= openTurn.seq
+            || currentStep.seq >= call.seq || currentStep.data.step !== call.data.step
+            || events.filter(event => event.type === 'step/start' && event.data.turn === turn.turn
+                && event.data.step === call.data.step).length !== 1)
+            return undefined;
+        let normalizedArguments;
+        try {
+            const parsed = JSON.parse(call.data.arguments);
+            if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed))
+                return undefined;
+            normalizedArguments = JSON.stringify(parsed);
+        }
+        catch {
+            return undefined;
+        }
+        const argumentsDigest = createHash('sha256').update(normalizedArguments).digest('hex');
+        if (argumentsDigest !== createHash('sha256').update(input.argumentsJson).digest('hex'))
+            return undefined;
+        const eventDigest = createHash('sha256').update(JSON.stringify(['tool/call', call.seq,
+            call.data.turn, call.data.step, input.callId, input.toolName, call.data.arguments])).digest('hex');
+        if (this.deliveryStore.inspectPendingForegroundToolTask({ inboxId: task.inboxId,
+            sessionId: task.sessionId, scope: task.scope, owner: task.owner, binding: task.binding }) === undefined)
+            return undefined;
+        return Object.freeze({ protocol: 'assistant-delivery/foreground-tool-call/v1', task,
+            turn: turn.turn, call: Object.freeze({ id: input.callId, toolName: input.toolName,
+                eventSeq: call.seq, eventDigest, argumentsDigest }) });
+    }
     currentPreferenceTurn(agent) {
         this.assertActive();
         const attestation = this.preferenceTurns.get(agent);
@@ -1973,6 +2053,7 @@ export class AssistantDeliveryService extends Service {
         }
         const token = Symbol('assistant-delivery.trusted-evaluation');
         this.evaluationSink = Object.freeze({ token, registration });
+        void this.drainNaturalObjectiveIntents();
         let active = true;
         return () => {
             if (!active)
@@ -2437,13 +2518,14 @@ export class AssistantDeliveryService extends Service {
             context: { initiator: 'external' },
         }).effect === 'allow';
     }
-    isOwnerFeedbackController(binding, envelope) {
+    isOwnerFeedbackController(binding, envelope, allowProcessedNatural = false) {
         if (!this.isInboundAuthorized(binding, envelope))
             return false;
         const principal = this.deliveryStore.getPrincipal(binding.principal);
         const inbox = this.deliveryStore.getInboxByProviderEvent(envelope.channel, envelope.account, envelope.eventId);
         if (principal?.status !== 'active' || principal.role !== 'owner'
-            || inbox?.status !== 'claimed'
+            || (inbox?.status !== 'claimed' && !(allowProcessedNatural && (inbox?.status === 'processed' || inbox?.status === 'dead_letter')
+                && inbox.envelope.kind === 'text' && this.deliveryStore.getNaturalObjectiveIntent(inbox.id)?.envelopeHash === inbox.envelopeHash))
             || inbox.bindingId !== binding.id
             || JSON.stringify(inbox.envelope) !== JSON.stringify(envelope)) {
             return false;
@@ -2828,17 +2910,112 @@ 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 dispatchNaturalObjectiveFeedback(binding, envelope) {
+        const selection = envelope.kind === 'text' && (envelope.attachments?.length ?? 0) === 0
+            ? parseNaturalObjectiveFeedback(envelope.text) : undefined;
+        if (selection === undefined || !this.isOwnerFeedbackController(binding, envelope))
+            return;
+        const replyTarget = envelope.metadata?.replyToProviderMessageId;
+        if (typeof replyTarget !== 'string')
+            return;
+        const inbox = this.deliveryStore.getInboxByProviderEvent(envelope.channel, envelope.account, envelope.eventId);
+        const target = this.deliveryStore.getOutboxByProviderMessage(envelope.channel, envelope.account, replyTarget);
+        const sourceEventId = target?.intent.replyToEventId;
+        const source = sourceEventId === undefined ? undefined
+            : this.deliveryStore.getInboxByProviderEvent(envelope.channel, envelope.account, sourceEventId);
+        const lineage = this.ownerLineageForBinding(binding);
+        if (inbox === undefined || target === undefined || source === undefined || lineage === undefined)
+            return;
+        if (!this.deliveryStore.isVerifiedForegroundObjectiveTarget(binding, source.id, target.id))
+            return;
+        const scope = { workspace: binding.workspace, preset: binding.agentPreset };
+        const execution = this.deliveryStore.inspectForegroundExecutionForOwner({ inboxId: source.id,
+            scope, owner: lineage, bindingId: binding.id, bindingVersion: binding.version,
+            bindingGeneration: binding.generation })
+            ?? this.deliveryStore.inspectForegroundAcceptedExecutionForOwner({ inboxId: source.id,
+                scope, owner: lineage, bindingId: binding.id });
+        if (execution?.status !== 'succeeded' || !execution.quiescent)
+            return;
+        try {
+            this.deliveryStore.prepareNaturalObjectiveIntent({ binding, feedbackInboxId: inbox.id,
+                sourceInboxId: source.id, sourceOutboxId: target.id, selection });
+        }
+        catch (error) {
+            if (error instanceof DeliveryStoreError)
+                return;
+            throw error;
+        }
+        void this.drainNaturalObjectiveIntents().catch(() => { });
+    }
+    drainNaturalObjectiveIntents() {
+        if (this.naturalObjectiveFlight !== undefined)
+            return this.naturalObjectiveFlight;
+        const flight = this.runNaturalObjectiveIntents()
+            .finally(() => { if (this.naturalObjectiveFlight === flight)
+            this.naturalObjectiveFlight = undefined; });
+        this.naturalObjectiveFlight = flight;
+        return flight;
+    }
+    async runNaturalObjectiveIntents() {
+        let afterAdmissionSequence = 0;
+        while (true) {
+            const page = this.deliveryStore.listPendingNaturalObjectiveIntents(100, afterAdmissionSequence);
+            if (page.length === 0)
+                return;
+            for (const intent of page) {
+                afterAdmissionSequence = intent.admissionSequence;
+                if (!this.active || this.evaluationSink === undefined)
+                    return;
+                if (this.evaluationSink.registration.ownerRevisionProtocol !== 'owner-objective-revision/v2'
+                    || typeof this.evaluationSink.registration.inspect !== 'function')
+                    return;
+                const inbox = this.deliveryStore.getInbox(intent.inboxId);
+                const binding = this.deliveryStore.getBinding(intent.bindingId);
+                if (inbox === undefined || binding === undefined)
+                    continue;
+                let frozen = intent;
+                if (frozen.status === 'awaiting-evaluation') {
+                    const inspected = await this.dispatchObjectiveFeedback(binding, inbox.envelope, { kind: 'objective-status' });
+                    if (inspected === 'invalid-target' || inspected === 'conflict') {
+                        this.deliveryStore.settleNaturalObjectiveIntent(intent.inboxId, 'conflict');
+                        continue;
+                    }
+                    if (inspected === 'unavailable' || inspected === 'unknown')
+                        continue;
+                    const current = typeof inspected === 'object' ? inspected : undefined;
+                    frozen = this.deliveryStore.freezeNaturalObjectiveIntent(intent.inboxId, current) ?? intent;
+                    if (frozen.status === 'awaiting-evaluation')
+                        continue;
+                }
+                if (frozen.status !== 'frozen' || frozen.command === undefined)
+                    continue;
+                const result = await this.dispatchObjectiveFeedback(binding, inbox.envelope, frozen.command);
+                if (typeof result === 'object') {
+                    this.deliveryStore.settleNaturalObjectiveIntent(intent.inboxId, 'projected', result);
+                }
+                else if (result === 'conflict' || result === 'invalid-target') {
+                    this.deliveryStore.settleNaturalObjectiveIntent(intent.inboxId, 'conflict');
+                }
+                else if (result === 'unavailable' || result === 'unknown')
+                    continue;
+            }
+            if (page.length < 100)
+                return;
+        }
+    }
     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';
-        if (!this.isOwnerFeedbackController(binding, envelope))
-            return 'invalid-target';
         const inbox = this.deliveryStore.getInboxByProviderEvent(envelope.channel, envelope.account, envelope.eventId);
+        const naturalIntent = inbox === undefined ? undefined : this.deliveryStore.getNaturalObjectiveIntent(inbox.id);
+        if (!this.isOwnerFeedbackController(binding, envelope, naturalIntent !== undefined))
+            return 'invalid-target';
         const target = this.deliveryStore.getOutboxByProviderMessage(envelope.channel, envelope.account, replyTarget);
-        if (inbox?.status !== 'claimed' || inbox.bindingId !== binding.id
+        if ((inbox?.status !== 'claimed' && !(naturalIntent !== undefined
+            && (inbox?.status === 'processed' || inbox?.status === 'dead_letter'))) || inbox.bindingId !== binding.id
             || target === undefined || target.providerMessageId !== replyTarget
             || target.intent.bindingId !== binding.id
             || JSON.stringify(target.intent.target.conversation) !== JSON.stringify(binding.conversation)
@@ -2846,9 +3023,22 @@ export class AssistantDeliveryService extends Service {
             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))
+        const typedMatches = hostCommand?.name === 'feedback'
+            && JSON.stringify(parseFeedbackCommand(hostCommand.rawInput)) === JSON.stringify(parsed);
+        const naturalMatches = naturalIntent !== undefined && inbox.envelope.kind === 'text'
+            && naturalIntent.envelopeHash === inbox.envelopeHash
+            && naturalIntent.sourceOutboxId === target.id
+            && parseNaturalObjectiveFeedback(inbox.envelope.text) === naturalIntent.selection
+            && (parsed.kind === 'objective-status' || (naturalIntent.status === 'frozen'
+                && JSON.stringify(naturalIntent.command) === JSON.stringify(parsed)));
+        if ((inbox.envelope.attachments?.length ?? 0) !== 0 || (!typedMatches && !naturalMatches))
             return 'invalid-target';
+        if (naturalIntent === undefined && parsed.kind !== 'objective-status'
+            && this.deliveryStore.hasEarlierPendingNaturalObjectiveIntent(target.id, inbox.admissionCursor.sequence)) {
+            await this.drainNaturalObjectiveIntents();
+            if (this.deliveryStore.hasEarlierPendingNaturalObjectiveIntent(target.id, inbox.admissionCursor.sequence))
+                return 'unknown';
+        }
         const metadata = target.intent.metadata;
         let goalOutcomeTarget;
         try {
@@ -2874,6 +3064,8 @@ export class AssistantDeliveryService extends Service {
             const sourceInbox = this.deliveryStore.getInboxByProviderEvent(envelope.channel, envelope.account, sourceEventId);
             if (sourceInbox === undefined)
                 return 'invalid-target';
+            if (!this.deliveryStore.isVerifiedForegroundObjectiveTarget(binding, sourceInbox.id, target.id))
+                return 'invalid-target';
             const lineage = this.ownerLineageForBinding(binding);
             const accepted = lineage === undefined ? null : this.deliveryStore.inspectForegroundAcceptedExecutionForOwner({
                 inboxId: sourceInbox.id,
@@ -2892,7 +3084,7 @@ export class AssistantDeliveryService extends Service {
                 && (execution.status !== 'succeeded' || !execution.quiescent)))
                 return 'invalid-target';
             const canonicalForeground = foreground !== null || accepted !== null;
-            const projectForegroundOwner = async (inspectOnly) => {
+            const projectForegroundOwner = (inspectOnly) => {
                 const sink = this.evaluationSink;
                 if (sink === undefined || lineage === undefined)
                     return undefined;
@@ -2921,10 +3113,10 @@ export class AssistantDeliveryService extends Service {
                     return undefined;
                 if (inspectOnly)
                     return sink.registration.inspect?.(capabilityReceipt);
-                const receipt = await Promise.resolve(sink.registration.append({
+                const receipt = 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
@@ -2934,12 +3126,15 @@ export class AssistantDeliveryService extends Service {
                 if (!canonicalForeground)
                     return this.deliveryStore.verifiedWorkflowObjectiveState(target.id, lineage) ?? 'recorded';
                 try {
-                    return await projectForegroundOwner(true) ?? 'unavailable';
+                    const inspected = projectForegroundOwner(true);
+                    return inspected ?? (naturalIntent !== undefined && this.evaluationSink !== undefined ? 'recorded' : 'unavailable');
                 }
                 catch {
                     return 'unknown';
                 }
             }
+            if (naturalIntent !== undefined && !canonicalForeground)
+                return 'invalid-target';
             if (canonicalForeground && this.evaluationSink === undefined)
                 return 'unavailable';
             try {
@@ -2947,7 +3142,7 @@ export class AssistantDeliveryService extends Service {
                 // 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;
+                const canonical = canonicalForeground ? projectForegroundOwner(false) : undefined;
                 if (canonicalForeground && canonical === undefined)
                     return 'unavailable';
                 const result = this.deliveryStore.commitVerifiedWorkflowTraceFeedback({
@@ -2958,7 +3153,7 @@ export class AssistantDeliveryService extends Service {
                     objectiveStatus,
                     ...(parsed.kind === 'objective-revision' ? { command: parsed } : {}),
                 });
-                await this.drainWorkflowTraces();
+                void this.drainWorkflowTraces().catch(() => { });
                 return canonical ?? result.ownerFeedbackState ?? 'recorded';
             }
             catch (error) {
@@ -2974,7 +3169,7 @@ export class AssistantDeliveryService extends Service {
                 if (typeof error === 'object' && error !== null && 'code' in error
                     && ['idempotency-conflict', 'version-conflict'].includes(String(error.code)))
                     return 'conflict';
-                return 'invalid-target';
+                return 'unknown';
             }
         }
         const automationId = metadata?.['dsh.learning.automationId'];
@@ -3264,7 +3459,7 @@ export class AssistantDeliveryService extends Service {
         const reviewer = approvalReviewerOf(events);
         const reviewRoute = reviewer === 'user'
             ? 'user'
-            : reviewer === 'auto-review' && isAutoReviewEscalation(request)
+            : reviewer === 'auto-review' && ctx.assistantPolicy.isAutoReviewEscalation(request)
                 ? 'auto-escalation'
                 : undefined;
         const sessionId = String(agent.session.id);
@@ -3407,7 +3602,7 @@ export class AssistantDeliveryService extends Service {
         }
         const reviewRoute = reviewer === 'user'
             ? 'user'
-            : reviewer === 'auto-review' && isAutoReviewEscalation(request)
+            : reviewer === 'auto-review' && ctx.assistantPolicy.isAutoReviewEscalation(request)
                 ? 'auto-escalation'
                 : undefined;
         if (reviewRoute === undefined)
@@ -3974,6 +4169,94 @@ export class AssistantDeliveryService extends Service {
             generation: resolved.snapshot.generation,
         });
     }
+    /** Host-only proof that the live caller Agent belongs to the current owner route. */
+    validateOwnerAgentForRoute(agent, authorityId) {
+        if (!this.active || typeof agent !== 'object' || agent === null || agent.session === undefined)
+            return undefined;
+        const agents = this.context.get('agents');
+        const sessions = this.context.get('sessions');
+        if (agents === undefined || sessions === undefined)
+            return undefined;
+        const sessionId = String(agent.session.id);
+        const liveCaller = () => String(agent.id) === sessionId
+            && agents.get(agent.id) === agent
+            && sessions.get(agent.id) === agent.session;
+        if (!liveCaller())
+            return undefined;
+        const matches = (attestation, route, receipt) => attestation.sessionId === sessionId
+            && attestation.bindingId === route.binding.id
+            && attestation.bindingVersion === route.binding.version
+            && attestation.bindingGeneration === route.binding.generation
+            && route.binding.sessionId === sessionId
+            && route.snapshot.bindingId === attestation.bindingId
+            && route.snapshot.bindingVersion === attestation.bindingVersion
+            && route.snapshot.generation === attestation.bindingGeneration
+            && attestation.principalId === receipt.principalId
+            && attestation.principalLineage.principalRecordId === receipt.principalRecordId
+            && attestation.principalLineage.principalVersion === receipt.principalVersion
+            && attestation.scope.workspace === receipt.workspace
+            && attestation.scope.preset === receipt.agentPreset
+            && agent.session.header.cwd === receipt.workspace
+            && agent.session.header.agentPreset === receipt.agentPreset
+            && route.authorityId === receipt.authorityId
+            && route.snapshot.authorityHash === receipt.authorityHash
+            && route.snapshot.bindingVersion === receipt.bindingVersion
+            && route.snapshot.generation === receipt.generation;
+        try {
+            const first = this.preferencePrincipalForAgent(agent);
+            if (first === undefined)
+                return undefined;
+            const route = this.resolveOwnerRoute(authorityId);
+            const receipt = this.validateOwnerRoute({
+                authorityId: route.authorityId,
+                principalId: first.principalId,
+                workspace: first.scope.workspace,
+                agentPreset: first.scope.preset,
+            });
+            if (!matches(first, route, receipt))
+                return undefined;
+            const current = this.preferencePrincipalForAgent(agent);
+            const currentRoute = this.resolveOwnerRoute(authorityId);
+            return current !== undefined && liveCaller() && matches(current, currentRoute, receipt)
+                ? receipt
+                : undefined;
+        }
+        catch (error) {
+            if (error instanceof AssistantDeliveryError && error.code === 'missing-binding')
+                return undefined;
+            throw error;
+        }
+    }
+    /** Host-only durable ordinary-turn metadata; never registered as a model tool. */
+    listOwnerForegroundTaskSources(input) {
+        this.assertActive();
+        this.validateOwnerRoute(input);
+        return this.deliveryStore.listOwnerForegroundTaskSources(input, this.ownerRoutes.get(input.authorityId));
+    }
+    /** Host-only exact terminal source metadata, including before reply Outbox exists. */
+    inspectOwnerForegroundTaskSource(input) {
+        this.assertActive();
+        this.validateOwnerRoute(input);
+        return this.deliveryStore.inspectOwnerForegroundTaskSource(input, this.ownerRoutes.get(input.authorityId));
+    }
+    /** Read one exact completed source under the current owner fence. */
+    readOwnerForegroundTaskSource(input) {
+        this.assertActive();
+        this.validateOwnerRoute(input);
+        return this.deliveryStore.readOwnerForegroundTaskSource(input, this.ownerRoutes.get(input.authorityId));
+    }
+    /** Hold Delivery's owner/source writer fence across synchronous downstream adoption. */
+    withOwnerForegroundTaskSourceFence(input, callback) {
+        this.assertActive();
+        this.validateOwnerRoute(input);
+        return this.deliveryStore.withOwnerForegroundTaskSourceFence(input, this.ownerRoutes.get(input.authorityId), callback);
+    }
+    /** Hold one owner/source writer fence for a bounded, ordered batch of sources. */
+    withOwnerForegroundTaskSourcesFence(input, callback) {
+        this.assertActive();
+        this.validateOwnerRoute(input);
+        return this.deliveryStore.withOwnerForegroundTaskSourcesFence(input, this.ownerRoutes.get(input.authorityId), callback);
+    }
     /** Host-only snapshot of the model selected for this owner's external conversation. */
     inspectOwnerModelSelection(input) {
         this.validateOwnerRoute(input);
@@ -4037,6 +4320,19 @@ export class AssistantDeliveryService extends Service {
             owner: { principalRecordId: owner.principalRecordId, principalVersion: owner.principalVersion } }) ?? accepted;
         if (execution === null)
             return undefined;
+        // /new retires the conversation binding. Read the version from the actual
+        // execution row, never the retired binding's incremented version or the
+        // new Session's generation. The Store also fences the current owner route.
+        const original = this.deliveryStore.inspectOwnerForegroundTaskSource({ ...routeInput,
+            inboxId: inbox.id, expectedOwner: { authorityHash: owner.authorityHash,
+                principalRecordId: owner.principalRecordId, principalVersion: owner.principalVersion } }, this.ownerRoutes.get(owner.authorityId));
+        if (original === undefined || original.binding.id !== binding.id
+            || original.binding.sessionId !== binding.sessionId)
+            return undefined;
+        const sourceOwner = Object.freeze({ ...owner, bindingVersion: original.binding.version,
+            generation: original.binding.generation });
+        if (!isSourceOwnerContinuation(owner, sourceOwner))
+            return undefined;
         const verifierComponent = (component) => accepted !== null && component.source.kind === 'evaluator' && component.source.id === 'assistant-verifier'
             && component.evaluator.id === 'assistant-verifier' && component.evaluator.version === '1'
             && component.evidence.some(ref => ref.kind === 'foreground-turn' && ref.ref === inbox.id)
@@ -4048,6 +4344,8 @@ export class AssistantDeliveryService extends Service {
             return undefined;
         let judgement = 'unresolved';
         let ownerRevision;
+        let feedback;
+        let feedbackOutboxId;
         const objective = canonical.objective;
         if (objective?.source.kind === 'user-feedback') {
             if (objective.source.id !== 'assistant-delivery/typed-owner-feedback')
@@ -4068,7 +4366,10 @@ export class AssistantDeliveryService extends Service {
                 || !['accepted', 'delivered', 'read'].includes(outbox.status))
                 return undefined;
             judgement = 'owner-feedback';
+            feedbackOutboxId = outbox.id;
             ownerRevision = Object.freeze({ version: revision.version, action: revision.action });
+            if (revision.operationId !== undefined)
+                feedback = this.deliveryStore.findNaturalObjectiveFeedbackByOperation(outbox.id, revision.operationId, { principalRecordId: owner.principalRecordId, principalVersion: owner.principalVersion });
         }
         else if (objective !== undefined) {
             if (!verifierComponent(objective))
@@ -4080,16 +4381,36 @@ export class AssistantDeliveryService extends Service {
         // may turn a completed ordinary conversation into a learning source.
         if (accepted === null && judgement !== 'owner-feedback')
             return undefined;
+        const content = feedbackOutboxId === undefined ? undefined : this.readOwnerForegroundTaskSource({
+            ...routeInput, inboxId: inbox.id, expectedSourceDigest: original.sourceDigest,
+            expectedOwner: { authorityHash: owner.authorityHash,
+                principalRecordId: owner.principalRecordId, principalVersion: owner.principalVersion },
+            maxReplyBytes: 16_384,
+        });
+        if (content !== undefined && content.reply.outboxId !== feedbackOutboxId)
+            return undefined;
+        const reply = content?.reply === undefined ? undefined : (() => {
+            // A partial prefix could cut a credential below the filter's minimum
+            // token length. Publish no raw prefix when the reader hit its hard cap.
+            const visible = content.reply.truncated
+                ? { text: '[TRUNCATED REPLY]', truncated: true, redacted: true }
+                : redactOwnerLearningReply(content.reply.text, 4096);
+            return Object.freeze({ text: visible.text, truncated: content.reply.truncated || visible.truncated,
+                redacted: visible.redacted, outboxId: content.reply.outboxId,
+                intentDigest: content.reply.intentDigest, fullTextDigest: content.reply.fullTextDigest });
+        })();
         // Fence cross-ledger reads before handing any task text to the consumer.
         if (!evaluation.isTrustedTaskLearningProjectionReceipt(canonical)
             || acceptanceCanonicalJson(owner) !== acceptanceCanonicalJson(this.validateOwnerRoute(routeInput)))
             return undefined;
         const objectiveText = inbox.envelope.text;
-        return Object.freeze({ protocol: 'assistant-delivery/owner-foreground-learning/v1', owner, canonical, judgement,
+        return Object.freeze({ protocol: 'assistant-delivery/owner-foreground-learning/v1', owner: sourceOwner, canonical, judgement,
             ...(ownerRevision === undefined ? {} : { ownerRevision }),
+            ...(feedback === undefined ? {} : { feedback }),
             source: Object.freeze({ sessionId: binding.sessionId, inboxId: inbox.id,
                 objective: objectiveText.slice(0, 4096), truncated: objectiveText.length > 4096, quiescent: execution.quiescent,
-                modelSelectionState: execution.modelSelectionState, ...(execution.modelSelection === undefined ? {} : { modelSelection: execution.modelSelection }) }) });
+                modelSelectionState: execution.modelSelectionState, ...(execution.modelSelection === undefined ? {} : { modelSelection: execution.modelSelection }),
+                ...(reply === undefined ? {} : { reply }) }) });
     }
     /**
      * Enqueue against a stable Host-owned route rather than a session binding.
@@ -4366,6 +4687,7 @@ export class AssistantDeliveryService extends Service {
         await this.outbound.tick();
         await this.drainDeliveryPresentations();
         await this.drainPreferenceProjections();
+        await this.drainNaturalObjectiveIntents();
         await this.drainWorkflowTraces();
     }
     async whenIdle() {
@@ -4376,6 +4698,7 @@ export class AssistantDeliveryService extends Service {
             this.modelSelectionFlight,
             this.presentationFlight,
             this.preferenceProjectionFlight,
+            this.naturalObjectiveFlight,
             this.workflowTraceFlight,
             this.inboundAdmissionRecoveryFlight,
         ]);
@@ -4628,6 +4951,7 @@ export class AssistantDeliveryService extends Service {
             this.modelSelectionFlight,
             this.presentationFlight,
             this.preferenceProjectionFlight,
+            this.naturalObjectiveFlight,
             this.workflowTraceFlight,
         ]);
     }