@dsh-enhanced/assistant-evaluation 0.1.65 → 0.1.67

package/lib/service.js

@@ -1,9 +1,24 @@
 import { Context, Service, symbols } from '@deepseek-ai/cordis';
 import Schema from '@deepseek-ai/schemastery';
 import { acceptanceDigest, goalDefinitionSituation, validateTaskAcceptanceContract, validateTaskVerificationReceipt } from '@dsh-enhanced/task-acceptance-contract';
-import { EvaluationStore, canonicalEvaluationScope, evaluationLearningProjectionDigest, } from './store.js';
+import { EvaluationStore, EvaluationStoreError, canonicalEvaluationScope, evaluationLearningProjectionDigest, } from './store.js';
 import { registerEvaluationTools } from './tools.js';
+import { normalizeAttentionCohort, } from './attention-tuning.js';
+import { ATTENTION_OWNER_QUESTION_SOURCE_ID, attentionOwnerQuestionIdempotencyKey, attentionOwnerQuestionText, parseAttentionOwnerQuestionChoice, ATTENTION_OWNER_QUESTION_REPLY_PROTOCOL, } from './attention-owner-questions.js';
+import { validateWorkItemOwnerFeedbackProof } from './work-item-owner-proof.js';
+import { computeIntakeAttentionAgreement, INTAKE_ATTENTION_AGREEMENT_SCAN_LIMIT, isIntakeProvenanceSource } from './intake-attention-agreement.js';
 import { executionStatuses, objectiveStatuses, outcomeSourceKinds, TRUSTED_EVALUATION_PRODUCER_PROTOCOL, } from './types.js';
+const OWNER_NOTIFICATION_WITHDRAWAL_PROTOCOL = 'assistant-delivery/owner-notification-withdrawal/v1';
+function isOwnerQuestionDeliveryPort(value) {
+    const port = value;
+    return typeof port === 'object' && port !== null && typeof port.enqueueOwnerNotification === 'function'
+        && typeof port.validateOwnerRoute === 'function' && typeof port.resolveOwnerRoute === 'function'
+        && typeof port.inspectOwnerNotification === 'function' && typeof port.registerOwnerNotificationWithdrawal === 'function';
+}
+function isOwnerQuestionReplyPort(value) {
+    const port = value;
+    return typeof port === 'object' && port !== null && typeof port.registerOwnerNotificationReply === 'function';
+}
 export const ASSISTANT_EVALUATION_SKILL = `# Personal assistant self-evaluation
 
 Use this workflow only to assess whether an already-finished task met its objective. A self-assessment is diagnostic evidence, never ground truth and never permission to change production behavior.
@@ -34,6 +49,31 @@ const configSchema = Schema.object({
     projectionTimeoutMs: Schema.number().step(1).min(100).max(300_000).default(2_000),
     projectionRetryBaseMs: Schema.number().step(1).min(1).max(3_600_000).default(1_000),
     projectionRetryMaxMs: Schema.number().step(1).min(1).max(86_400_000).default(3_600_000),
+    notificationOutcomesEnabled: Schema.boolean().default(false),
+    notificationResponseWindowMs: Schema.number().step(1).min(60_000).max(2_592_000_000).default(86_400_000),
+    notificationObservationHorizonMs: Schema.number().step(1).min(60_000).max(31_536_000_000).default(2_592_000_000),
+    notificationSyncBatchSize: Schema.number().step(1).min(1).max(500).default(100),
+    notificationSyncIntervalMs: Schema.number().step(1).min(0).max(86_400_000).default(60_000),
+    attentionTuningAutoAdopt: Schema.boolean().default(false),
+    intakeAttentionAgreementEnabled: Schema.boolean().default(false),
+    attentionTuningCohorts: Schema.array(Schema.object({
+        lane: Schema.string().required(),
+        sourceId: Schema.string().required(),
+    })).default([{ lane: 'owner-notification', sourceId: 'assistant-proactive/v1' }]),
+    attentionTuningMinSample: Schema.number().step(1).min(5).max(10_000).default(20),
+    attentionTuningNegativeRatePpm: Schema.number().step(1).min(100_000).max(1_000_000).default(600_000),
+    attentionTuningMuteRatePpm: Schema.number().step(1).min(100_000).max(1_000_000).default(900_000),
+    attentionTuningRegressionMarginPpm: Schema.number().step(1).min(0).max(1_000_000).default(100_000),
+    attentionTuningObservationMs: Schema.number().step(1).min(60_000).max(31_536_000_000).default(604_800_000),
+    attentionTuningEvaluationWindowMs: Schema.number().step(1).min(60_000).max(31_536_000_000).default(604_800_000),
+    attentionLooseningEnabled: Schema.boolean().default(false),
+    attentionLooseningReplayWindowMs: Schema.number().step(1).min(3_600_000).max(31_536_000_000).default(2_592_000_000),
+    attentionOwnerQuestionDeliveryEnabled: Schema.boolean().default(false),
+    attentionOwnerQuestionOwner: Schema.union([Schema.object({
+            ownerRouteId: Schema.string().required(),
+            principalId: Schema.string().required(),
+        })]),
+    attentionOwnerQuestionNoticeTtlMs: Schema.number().step(1).min(60_000).max(2_592_000_000).default(86_400_000),
 });
 export class AssistantEvaluationError extends Error {
     code;
@@ -59,6 +99,10 @@ export function canonicalEvaluationHostScope(input) {
     });
     return Object.freeze(branded);
 }
+function isNotificationOutcomeFactSource(value) {
+    return typeof value === 'object' && value !== null
+        && typeof value.inspectNotificationOutcomeFacts === 'function';
+}
 function exactEvaluationHostScope(input) {
     if (typeof input !== 'object' || input === null || !Object.isFrozen(input)
         || input[evaluationHostScopeBrand] !== true) {
@@ -173,6 +217,11 @@ function isTrustedVerifierEvaluationProducer(value) {
         && typeof value.trustedVerificationProducerGeneration === 'function'
         && typeof value.registerTrustedVerifierEvaluationSink === 'function';
 }
+function isTrustedWorkItemEvaluationProducer(value) {
+    return typeof value === 'object' && value !== null
+        && typeof value.trustedWorkItemProducerGeneration === 'function'
+        && typeof value.registerTrustedWorkItemEvaluationSink === 'function';
+}
 function isTrustedEvaluationProjector(value) {
     return typeof value === 'object' && value !== null
         && typeof value.projectTrustedEvaluationTaskRevision === 'function';
@@ -194,11 +243,20 @@ export class AssistantEvaluationService extends Service {
     automationBinding;
     deliveryBinding;
     verifierBinding;
+    workItemsBinding;
     activeAutomationRegistrations = new WeakSet();
     activeDeliveryRegistrations = new WeakSet();
     activeVerifierRegistrations = new WeakSet();
+    activeWorkItemRegistrations = new WeakSet();
     activeProjections = new Map();
     projectionTimer;
+    notificationFacts;
+    lastNotificationSyncAt = Number.NEGATIVE_INFINITY;
+    ownerQuestionWithdrawal;
+    activeOwnerQuestionWithdrawals = new WeakSet();
+    ownerQuestionReply;
+    activeOwnerQuestionReplies = new WeakSet();
+    attentionCohorts;
     active = true;
     constructor(ctx, input, options = {}) {
         super(ctx, 'assistantEvaluation');
@@ -217,6 +275,30 @@ export class AssistantEvaluationService extends Service {
         if (this.config.projectionRetryBaseMs > this.config.projectionRetryMaxMs) {
             throw new Error('assistant-evaluation: projectionRetryBaseMs must not exceed projectionRetryMaxMs');
         }
+        if (this.config.intakeAttentionAgreementEnabled && !this.config.notificationOutcomesEnabled) {
+            throw new Error('assistant-evaluation: intakeAttentionAgreementEnabled requires notificationOutcomesEnabled');
+        }
+        if (this.config.attentionTuningAutoAdopt && !this.config.notificationOutcomesEnabled) {
+            throw new Error('assistant-evaluation: attentionTuningAutoAdopt requires notificationOutcomesEnabled');
+        }
+        if (this.config.attentionLooseningEnabled && !this.config.attentionTuningAutoAdopt) {
+            throw new Error('assistant-evaluation: attentionLooseningEnabled requires attentionTuningAutoAdopt');
+        }
+        if (this.config.attentionOwnerQuestionDeliveryEnabled && !this.config.attentionLooseningEnabled) {
+            throw new Error('assistant-evaluation: attentionOwnerQuestionDeliveryEnabled requires attentionLooseningEnabled');
+        }
+        if (this.config.attentionOwnerQuestionDeliveryEnabled && (typeof this.config.attentionOwnerQuestionOwner?.ownerRouteId !== 'string'
+            || this.config.attentionOwnerQuestionOwner.ownerRouteId.length === 0 || typeof this.config.attentionOwnerQuestionOwner.principalId !== 'string'
+            || this.config.attentionOwnerQuestionOwner.principalId.length === 0)) {
+            throw new Error('assistant-evaluation: attentionOwnerQuestionDeliveryEnabled requires attentionOwnerQuestionOwner');
+        }
+        if (this.config.attentionTuningMuteRatePpm < this.config.attentionTuningNegativeRatePpm) {
+            throw new Error('assistant-evaluation: attentionTuningMuteRatePpm must not be below attentionTuningNegativeRatePpm');
+        }
+        if (this.config.attentionTuningCohorts.length > 16) {
+            throw new Error('assistant-evaluation: at most 16 attention tuning cohorts');
+        }
+        this.attentionCohorts = Object.freeze(this.config.attentionTuningCohorts.map(cohort => normalizeAttentionCohort(cohort)));
         this.now = options.now ?? Date.now;
         this.store = new EvaluationStore({
             path: this.config.databasePath,
@@ -313,6 +395,21 @@ export class AssistantEvaluationService extends Service {
                 return;
             return this.bindDeliveryProducer(producer);
         });
+        const bindNotificationFacts = (source) => {
+            if (!isNotificationOutcomeFactSource(source))
+                return;
+            this.notificationFacts = source;
+            return () => { if (this.notificationFacts === source)
+                this.notificationFacts = undefined; };
+        };
+        bindNotificationFacts(currentDelivery);
+        ctx.inject(['assistantDelivery'], deliveryCtx => bindNotificationFacts(deliveryCtx.get('assistantDelivery')));
+        if (this.config.attentionOwnerQuestionDeliveryEnabled) {
+            this.bindOwnerQuestionWithdrawal(currentDelivery);
+            ctx.inject(['assistantDelivery'], deliveryCtx => this.bindOwnerQuestionWithdrawal(deliveryCtx.get('assistantDelivery')));
+            this.bindOwnerQuestionReply(currentDelivery);
+            ctx.inject(['assistantDelivery'], deliveryCtx => this.bindOwnerQuestionReply(deliveryCtx.get('assistantDelivery')));
+        }
         const currentVerifier = ctx.get('assistantVerifier');
         if (isTrustedVerifierEvaluationProducer(currentVerifier))
             this.bindVerifierProducer(currentVerifier);
@@ -322,8 +419,33 @@ export class AssistantEvaluationService extends Service {
                 return;
             return this.bindVerifierProducer(producer);
         });
+        const currentWorkItems = ctx.get('assistantWorkItems');
+        if (isTrustedWorkItemEvaluationProducer(currentWorkItems))
+            this.bindWorkItemsProducer(currentWorkItems);
+        ctx.inject(['assistantWorkItems'], workItemsCtx => {
+            const producer = workItemsCtx.get('assistantWorkItems');
+            if (!isTrustedWorkItemEvaluationProducer(producer))
+                return;
+            return this.bindWorkItemsProducer(producer);
+        });
         if (this.config.projectionIntervalMs > 0) {
             this.projectionTimer = setInterval(() => {
+                const now = this.now();
+                if (this.config.notificationOutcomesEnabled && now - this.lastNotificationSyncAt >= this.config.notificationSyncIntervalMs) {
+                    this.lastNotificationSyncAt = now;
+                    try {
+                        this.reconcileNotificationOutcomes();
+                    }
+                    catch { /* isolated from projection; retried on a later tick */ }
+                    try {
+                        this.reconcileAttentionTuning();
+                    }
+                    catch { /* retried on a later sync */ }
+                    try {
+                        this.reconcileAttentionOwnerQuestions();
+                    }
+                    catch { /* retried on a later sync */ }
+                }
                 void this.reconcileProjections().catch(() => { });
             }, this.config.projectionIntervalMs);
             this.projectionTimer.unref?.();
@@ -333,10 +455,14 @@ export class AssistantEvaluationService extends Service {
             if (this.projectionTimer !== undefined)
                 clearInterval(this.projectionTimer);
             this.projectionTimer = undefined;
+            this.notificationFacts = undefined;
+            this.ownerQuestionWithdrawal?.dispose();
+            this.ownerQuestionReply?.dispose();
             disposeCurrentProjector?.();
             this.automationBinding?.dispose();
             this.deliveryBinding?.dispose();
             this.verifierBinding?.dispose();
+            this.workItemsBinding?.dispose();
             toolsBinding?.dispose();
             skillBinding?.dispose();
             await Promise.allSettled(this.activeProjections.values());
@@ -412,8 +538,8 @@ export class AssistantEvaluationService extends Service {
         if (state === undefined) {
             throw new AssistantEvaluationError('not-found', 'exact Evaluation projection was not found');
         }
-        if (state.status === 'recorded') {
-            return Object.freeze({ evaluationId, status: 'recorded', attemptCount: state.attemptCount });
+        if (state.status !== 'pending') {
+            return Object.freeze({ evaluationId, status: state.status, attemptCount: state.attemptCount });
         }
         const active = this.activeProjections.get(evaluationId);
         if (active !== undefined)
@@ -434,7 +560,7 @@ export class AssistantEvaluationService extends Service {
         }
         return Object.freeze({
             evaluationId,
-            status: state.status === 'recorded' ? 'recorded' : 'deferred',
+            status: state.status === 'pending' ? 'deferred' : state.status,
             attemptCount: state.attemptCount,
         });
     }
@@ -513,6 +639,11 @@ export class AssistantEvaluationService extends Service {
         this.assertActive();
         return this.store.getForegroundLearningProjection(exactEvaluationHostScope(input.scope), hostIdentifier(input.inboxId, 'inboxId', 1_000));
     }
+    /** Host-only exact current owner result for one durable work item. */
+    getTrustedWorkItemLearningProjection(input) {
+        this.assertActive();
+        return this.store.getWorkItemLearningProjection(exactEvaluationHostScope(input.scope), hostIdentifier(input.itemId, 'itemId', 1_000));
+    }
     /** Host-only exact canonical whole-goal proof, addressed by assessment id. */
     getTrustedGoalOutcomeLearningProjection(input) {
         this.assertActive();
@@ -544,6 +675,7 @@ export class AssistantEvaluationService extends Service {
                     && projection.subjectKind !== 'foreground-turn'
                     && projection.subjectKind !== 'goal-step'
                     && projection.subjectKind !== 'goal-outcome'
+                    && projection.subjectKind !== 'work-item'
                     && projection.subjectKind !== 'outcome')
                 || !exactHostIdentifier(projection.subjectRef, 'projection.subjectRef', 1_000)
                 || !Number.isSafeInteger(projection.version) || projection.version < 1
@@ -700,6 +832,578 @@ export class AssistantEvaluationService extends Service {
         this.assertActive();
         return this.store.health();
     }
+    /**
+     * WP22 deterministic sync: ingest new Delivery audit rows after the durable
+     * cursor, then refresh a bounded batch of known notifications inside the
+     * observation horizon (least recently checked first) so late replies,
+     * corrections, withdrawals and expiry produce new revisions. No model call,
+     * no Evolution projection and no parameter change. Missing Delivery is a
+     * zero result, as is a disabled `notificationOutcomesEnabled`.
+     */
+    reconcileNotificationOutcomes() {
+        this.assertActive();
+        const source = this.notificationFacts;
+        if (!this.config.notificationOutcomesEnabled || source === undefined)
+            return Object.freeze({ ingested: 0, refreshed: 0, revised: 0, invalid: 0 });
+        const ledger = this.store.notifications;
+        const limit = this.config.notificationSyncBatchSize;
+        const window = this.config.notificationResponseWindowMs;
+        let ingested = 0;
+        let refreshed = 0;
+        let revised = 0;
+        let invalid = 0;
+        const apply = (fact) => {
+            try {
+                if (ledger.apply(fact, window).revised)
+                    revised += 1;
+                return true;
+            }
+            catch (error) {
+                // A malformed fact or a fact whose scope disagrees with its recorded
+                // head is counted and skipped so one bad row never stalls the cursor.
+                if (error instanceof EvaluationStoreError && (error.code === 'invalid-input' || error.code === 'version-conflict')) {
+                    invalid += 1;
+                    return false;
+                }
+                throw error;
+            }
+        };
+        const page = source.inspectNotificationOutcomeFacts({ afterSequence: ledger.syncCursor(), limit });
+        for (const fact of page.facts)
+            if (apply(fact))
+                ingested += 1;
+        if (page.nextAfterSequence !== null)
+            ledger.advanceSyncCursor(page.nextAfterSequence);
+        // The horizon is measured from notification time while expiry is measured
+        // from send time, so a horizon near the response window would stop
+        // re-checking a delivered notification before it could expire. Keep at
+        // least one extra window of slack for send latency.
+        const horizon = Math.max(this.config.notificationObservationHorizonMs, 2 * window);
+        const due = ledger.dueForRefresh(this.now() - horizon, limit);
+        if (due.length > 0) {
+            const facts = source.inspectNotificationOutcomeFacts({ outboxIds: due }).facts;
+            const applied = new Set();
+            for (const fact of facts) {
+                if (!apply(fact))
+                    continue;
+                refreshed += 1;
+                applied.add(fact.outboxId);
+            }
+            // Missing or rejected facts still rotate to the back of the re-check
+            // order so they cannot starve the rest of the horizon.
+            for (const id of due)
+                if (!applied.has(id))
+                    ledger.touch(id);
+        }
+        return Object.freeze({ ingested, refreshed, revised, invalid });
+    }
+    /** Current revision plus full revision history for one notification (Delivery Outbox id). */
+    inspectNotificationOutcome(input) {
+        this.assertActive();
+        return this.store.notifications.history(input.scope, hostIdentifier(input.notificationId, 'notificationId', 256));
+    }
+    /** Restart-safe feed of current notification heads after a per-scope notification watermark. */
+    notificationOutcomeFeed(input) {
+        this.assertActive();
+        return this.store.notifications.feed(input.scope, input.after, input.limit ?? 100);
+    }
+    /** Current-head counts by outcome and by attention verdict, over notification time. */
+    notificationOutcomeSummary(input) {
+        this.assertActive();
+        const to = input.toNotifiedAt ?? this.now() + 1;
+        const from = input.fromNotifiedAt ?? Math.max(0, to - this.config.defaultSummaryWindowMs);
+        if (!Number.isSafeInteger(from) || !Number.isSafeInteger(to) || from < 0 || to <= from
+            || to - from > this.config.maxSummaryWindowMs) {
+            throw new AssistantEvaluationError('invalid-input', 'notification outcome summary window is invalid');
+        }
+        return this.store.notifications.summary(input.scope, from, to);
+    }
+    /**
+     * WP22, read-only and default off: agreement between the WP20 intake
+     * judgment behind each auto-admitted work item and the owner outcome of its
+     * notifications, over notification time. Undefined when
+     * `intakeAttentionAgreementEnabled` is off. Observe-mode intake creates no
+     * item and is therefore not measurable here. Observational (`causal:
+     * false`); it writes, adopts and sends nothing.
+     */
+    inspectIntakeAttentionAgreement(input) {
+        this.assertActive();
+        if (!this.config.intakeAttentionAgreementEnabled)
+            return undefined;
+        const to = input.toNotifiedAt ?? this.now() + 1;
+        const from = input.fromNotifiedAt ?? Math.max(0, to - this.config.defaultSummaryWindowMs);
+        if (!Number.isSafeInteger(from) || !Number.isSafeInteger(to) || from < 0 || to <= from
+            || to - from > this.config.maxSummaryWindowMs) {
+            throw new AssistantEvaluationError('invalid-input', 'intake attention agreement window is invalid');
+        }
+        const { scope } = canonicalEvaluationScope(input.scope);
+        const heads = this.store.notifications.workItemHeads(scope, from, to, INTAKE_ATTENTION_AGREEMENT_SCAN_LIMIT);
+        const workItems = this.ctx.get('assistantWorkItems');
+        return computeIntakeAttentionAgreement({ scope, fromNotifiedAt: from, toNotifiedAt: to, records: heads.records,
+            truncated: heads.truncated, source: isIntakeProvenanceSource(workItems) ? workItems : undefined });
+    }
+    #attentionPolicy() {
+        return Object.freeze({
+            minSample: this.config.attentionTuningMinSample,
+            negativeRatePpm: this.config.attentionTuningNegativeRatePpm,
+            muteRatePpm: this.config.attentionTuningMuteRatePpm,
+            regressionMarginPpm: this.config.attentionTuningRegressionMarginPpm,
+        });
+    }
+    #looseningOptions() {
+        if (!this.config.attentionLooseningEnabled)
+            return undefined;
+        return Object.freeze({
+            replayWindowMs: this.config.attentionLooseningReplayWindowMs,
+            ...(this.config.attentionOwnerQuestionDeliveryEnabled
+                ? { ownerQuestionReplyLoop: Object.freeze({ noticeTtlMs: this.config.attentionOwnerQuestionNoticeTtlMs }) }
+                : {}),
+        });
+    }
+    #attentionCohort(input) {
+        let cohort;
+        try {
+            cohort = normalizeAttentionCohort(input);
+        }
+        catch {
+            throw new AssistantEvaluationError('invalid-input', 'attention cohort is invalid');
+        }
+        if (!this.attentionCohorts.some(item => item.lane === cohort.lane && item.sourceId === cohort.sourceId)) {
+            throw new AssistantEvaluationError('not-found', 'attention cohort is not configured');
+        }
+        return cohort;
+    }
+    /**
+     * WP22 slice 2 deterministic tuning tick: for every configured cohort and
+     * every scope that has notifications in it, monitor an observing version
+     * (exact-parent rollback on regression) or adopt one bounded tightening
+     * step. With `attentionLooseningEnabled`, a pending sealed loosening
+     * proposal is decided first and tightening uses training data only.
+     * Zero work when `attentionTuningAutoAdopt` is off.
+     */
+    reconcileAttentionTuning() {
+        this.assertActive();
+        if (!this.config.attentionTuningAutoAdopt)
+            return Object.freeze([]);
+        const policy = this.#attentionPolicy();
+        const loosening = this.#looseningOptions();
+        const options = {
+            observationMs: this.config.attentionTuningObservationMs, evaluationWindowMs: this.config.attentionTuningEvaluationWindowMs,
+            ...(loosening === undefined ? {} : { loosening }),
+        };
+        const results = [];
+        for (const cohort of this.attentionCohorts) {
+            for (const scope of this.store.attention.scopes(cohort)) {
+                let scopeKey;
+                try {
+                    scopeKey = canonicalEvaluationScope(scope).scopeKey;
+                }
+                catch {
+                    continue;
+                }
+                results.push({ scopeKey, cohort, result: this.store.attention.tick(scope, cohort, policy, options) });
+            }
+        }
+        return Object.freeze(results);
+    }
+    /**
+     * Verified active attention parameters for a consumer, or undefined when
+     * auto-adoption is off (consumers then apply no overlay at all).
+     */
+    currentAttentionTuning(input) {
+        this.assertActive();
+        if (!this.config.attentionTuningAutoAdopt)
+            return undefined;
+        return this.store.attention.current(input.scope, this.#attentionCohort(input.cohort));
+    }
+    /** Versions, durable observation state and recent events for one cohort. */
+    attentionTuningStatus(input) {
+        this.assertActive();
+        return this.store.attention.status(input.scope, this.#attentionCohort(input.cohort));
+    }
+    /**
+     * Host-internal explicit request. Without `attentionLooseningEnabled`,
+     * loosening is rejected as `loosening-requires-holdout` and recorded; with
+     * it, a single-parameter loosening is sealed as a proposal for the next
+     * tick's holdout replay and grant check.
+     */
+    requestAttentionTuning(input) {
+        this.assertActive();
+        return this.store.attention.request(input.scope, this.#attentionCohort(input.cohort), input.parameters, {
+            enabled: this.config.attentionTuningAutoAdopt,
+            observationMs: this.config.attentionTuningObservationMs,
+            evaluationWindowMs: this.config.attentionTuningEvaluationWindowMs,
+            ...(this.#looseningOptions() === undefined ? {} : { loosening: this.#looseningOptions() }),
+        });
+    }
+    /** Record an owner one-time loosening pre-authorization for one cohort. */
+    grantAttentionLoosening(input) {
+        this.assertActive();
+        const cohort = this.#attentionCohort(input.cohort);
+        if (!this.config.attentionLooseningEnabled)
+            return Object.freeze({ status: 'rejected', reason: 'loosening-disabled' });
+        return this.store.attention.grant(input.scope, cohort, input.grant);
+    }
+    /** Active grant with used/remaining quota, sealed proposals with decisions, and recorded owner questions. */
+    attentionLooseningStatus(input) {
+        this.assertActive();
+        const status = this.store.attention.looseningStatus(input.scope, this.#attentionCohort(input.cohort));
+        return Object.freeze({ enabled: this.config.attentionLooseningEnabled, ...status });
+    }
+    #ownerQuestionDelivery() {
+        const delivery = this.ctx.get('assistantDelivery');
+        return isOwnerQuestionDeliveryPort(delivery) ? delivery : undefined;
+    }
+    /**
+     * Register (once per Delivery instance) the send-time withdrawal check for
+     * owner-question notices. A Delivery without the check is treated as absent.
+     */
+    bindOwnerQuestionWithdrawal(source) {
+        if (!this.active || !isOwnerQuestionDeliveryPort(source))
+            return undefined;
+        if (this.ownerQuestionWithdrawal?.source === source)
+            return undefined;
+        const registration = Object.freeze({
+            protocol: OWNER_NOTIFICATION_WITHDRAWAL_PROTOCOL,
+            authority: 'assistantEvaluation',
+            sourceId: ATTENTION_OWNER_QUESTION_SOURCE_ID,
+            isWithdrawn: (idempotencyKey) => this.#ownerQuestionWithdrawn(idempotencyKey),
+        });
+        this.activeOwnerQuestionWithdrawals.add(registration);
+        let handle;
+        let unregister;
+        try {
+            const result = source.registerOwnerNotificationWithdrawal(registration);
+            handle = result?.handle;
+            unregister = result?.unregister;
+        }
+        catch (error) {
+            this.activeOwnerQuestionWithdrawals.delete(registration);
+            // Unbound: the tick defers owner questions as delivery-unavailable until a later bind succeeds.
+            this.ctx.logger.warn(`assistant-evaluation: owner-question withdrawal registration failed; owner questions deferred: ${String(error)}`);
+            return undefined;
+        }
+        if (typeof handle !== 'string' || handle.length === 0 || typeof unregister !== 'function') {
+            this.activeOwnerQuestionWithdrawals.delete(registration);
+            try {
+                if (typeof unregister === 'function')
+                    unregister();
+            }
+            catch { /* best effort */ }
+            this.ctx.logger.warn('assistant-evaluation: owner-question withdrawal registration returned no handle; owner questions deferred');
+            return undefined;
+        }
+        const release = unregister;
+        this.ownerQuestionWithdrawal?.dispose();
+        let live = true;
+        const binding = Object.freeze({ source, handle, dispose: () => {
+                if (!live)
+                    return;
+                live = false;
+                this.activeOwnerQuestionWithdrawals.delete(registration);
+                try {
+                    release();
+                }
+                catch { /* Delivery already gone */ }
+                if (this.ownerQuestionWithdrawal === binding)
+                    this.ownerQuestionWithdrawal = undefined;
+            } });
+        this.ownerQuestionWithdrawal = binding;
+        return binding.dispose;
+    }
+    /**
+     * Register (once per Delivery instance) the slice-5 reply consumer. A
+     * Delivery without the reply port is treated as absent: slice-4 notice
+     * delivery keeps working, only replies are not read. A registration error
+     * only disables replies; it never blocks notice delivery.
+     */
+    bindOwnerQuestionReply(source) {
+        if (!this.active || !isOwnerQuestionReplyPort(source))
+            return undefined;
+        if (this.ownerQuestionReply?.source === source)
+            return undefined;
+        const registration = Object.freeze({
+            protocol: ATTENTION_OWNER_QUESTION_REPLY_PROTOCOL,
+            authority: 'assistantEvaluation',
+            sourceId: ATTENTION_OWNER_QUESTION_SOURCE_ID,
+            idempotencyKeyPrefix: attentionOwnerQuestionIdempotencyKey(''),
+            consume: (input) => this.#consumeOwnerQuestionReply(input),
+        });
+        this.activeOwnerQuestionReplies.add(registration);
+        let unregister;
+        try {
+            unregister = source.registerOwnerNotificationReply(registration)?.unregister;
+        }
+        catch (error) {
+            this.activeOwnerQuestionReplies.delete(registration);
+            this.ctx.logger.warn(`assistant-evaluation: owner-question reply registration failed; replies are not read: ${String(error)}`);
+            return undefined;
+        }
+        if (typeof unregister !== 'function') {
+            this.activeOwnerQuestionReplies.delete(registration);
+            this.ctx.logger.warn('assistant-evaluation: owner-question reply registration returned no unregister; replies are not read');
+            return undefined;
+        }
+        const release = unregister;
+        this.ownerQuestionReply?.dispose();
+        let live = true;
+        const binding = Object.freeze({ source, registration, dispose: () => {
+                if (!live)
+                    return;
+                live = false;
+                this.activeOwnerQuestionReplies.delete(registration);
+                try {
+                    release();
+                }
+                catch { /* Delivery already gone */ }
+                if (this.ownerQuestionReply === binding)
+                    this.ownerQuestionReply = undefined;
+            } });
+        this.ownerQuestionReply = binding;
+        return binding.dispose;
+    }
+    /**
+     * Synchronous Delivery callback for one authenticated reply to an exact
+     * owner-question notice. Only exact whole-phrase choices are accepted; a
+     * recognized choice is consumed even when its question is no longer open,
+     * so a stale "authorize-once" never reaches the Agent. Storage errors are
+     * `transient` and leave Delivery's Inbox pending for a bounded retry.
+     */
+    #consumeOwnerQuestionReply(input) {
+        if (!this.active || !this.config.attentionOwnerQuestionDeliveryEnabled)
+            return 'ignored';
+        if (typeof input?.idempotencyKey !== 'string' || typeof input.text !== 'string')
+            return 'ignored';
+        const prefix = attentionOwnerQuestionIdempotencyKey('');
+        if (!input.idempotencyKey.startsWith(prefix))
+            return 'ignored';
+        const questionId = input.idempotencyKey.slice(prefix.length);
+        const choice = parseAttentionOwnerQuestionChoice(input.text);
+        if (choice === undefined || questionId.length === 0)
+            return 'ignored';
+        try {
+            for (const cohort of this.attentionCohorts) {
+                for (const scope of this.store.attention.scopes(cohort)) {
+                    const latest = this.store.attention.latestOwnerQuestion(scope, cohort);
+                    if (latest === undefined || latest === 'unverifiable' || latest.questionId !== questionId)
+                        continue;
+                    this.applyAttentionOwnerQuestionReply({ scope, cohort, questionId, choice });
+                    return 'applied';
+                }
+            }
+            // The notice was genuinely issued under this source and key, but the
+            // local ledger no longer holds that exact question: consume the
+            // recognized choice instead of sending it to the Agent.
+            return 'applied';
+        }
+        catch {
+            return 'transient';
+        }
+    }
+    /**
+     * Send-time answer for one owner-question notice. It stays sendable only
+     * while its question is still the cohort's latest, open, unanswered, inside
+     * the notice TTL, and not recorded closed/expired. Anything else, including
+     * a key this service did not issue, is withdrawn. A storage error throws so
+     * Delivery holds the notice (bounded by its expiry) rather than sending.
+     */
+    #ownerQuestionWithdrawn(idempotencyKey) {
+        if (!this.active || !this.config.attentionOwnerQuestionDeliveryEnabled)
+            return true;
+        const prefix = attentionOwnerQuestionIdempotencyKey('');
+        if (typeof idempotencyKey !== 'string' || !idempotencyKey.startsWith(prefix))
+            return true;
+        const questionId = idempotencyKey.slice(prefix.length);
+        for (const cohort of this.attentionCohorts) {
+            for (const scope of this.store.attention.scopes(cohort)) {
+                const latest = this.store.attention.latestOwnerQuestion(scope, cohort);
+                if (latest === undefined || latest === 'unverifiable' || latest.questionId !== questionId)
+                    continue;
+                const delivery = this.store.attentionQuestions.delivery(questionId);
+                return !latest.open || this.store.attentionQuestions.reply(questionId) !== undefined
+                    || (delivery !== undefined && delivery.status !== 'queued')
+                    || this.now() >= latest.question.createdAt + this.config.attentionOwnerQuestionNoticeTtlMs;
+            }
+        }
+        return true;
+    }
+    /**
+     * WP22 slice 4 tick step: for each configured cohort and scope, the latest
+     * recorded owner question is handed to Delivery at most once. An Outbox row
+     * already holding the question's idempotency key is adopted as `queued`
+     * before any other decision. Otherwise a question a newer grant (or a
+     * recorded reply) already closed is recorded `closed` and never sent; one
+     * older than the notice TTL is recorded `expired`. Notices are queued
+     * `withdrawable`, so a question closed after queueing is withdrawn by
+     * Delivery's send-time check instead of being sent. Delivery absence (or no
+     * live withdrawal binding of this service to that Delivery instance), a
+     * route that does not match the scope, or an enqueue failure leaves no row,
+     * so a later tick retries under the same idempotency key. Zero work when
+     * `attentionOwnerQuestionDeliveryEnabled` is off.
+     */
+    reconcileAttentionOwnerQuestions() {
+        this.assertActive();
+        if (!this.config.attentionOwnerQuestionDeliveryEnabled)
+            return Object.freeze([]);
+        const owner = this.config.attentionOwnerQuestionOwner;
+        const ttl = this.config.attentionOwnerQuestionNoticeTtlMs;
+        const results = [];
+        for (const cohort of this.attentionCohorts) {
+            for (const scope of this.store.attention.scopes(cohort)) {
+                let scopeKey;
+                try {
+                    scopeKey = canonicalEvaluationScope(scope).scopeKey;
+                }
+                catch {
+                    continue;
+                }
+                const push = (result) => { results.push({ scopeKey, cohort, result: Object.freeze(result) }); };
+                const latest = this.store.attention.latestOwnerQuestion(scope, cohort);
+                if (latest === undefined)
+                    continue;
+                // Fail closed: a question whose stored body does not verify is never sent.
+                if (latest === 'unverifiable') {
+                    push({ action: 'unverifiable' });
+                    continue;
+                }
+                const { questionId, question } = latest;
+                if (this.store.attentionQuestions.delivery(questionId) !== undefined)
+                    continue;
+                const delivery = this.#ownerQuestionDelivery();
+                // Without Delivery no Outbox lookup is possible, so no terminal row is written either.
+                if (delivery === undefined) {
+                    push({ action: 'deferred', questionId, reason: 'delivery-unavailable' });
+                    continue;
+                }
+                this.bindOwnerQuestionWithdrawal(delivery);
+                // A replaced Delivery instance needs the reply consumer bound as well;
+                // the tick is the existing retry point, so no extra loop is added.
+                this.bindOwnerQuestionReply(delivery);
+                // Only queue (or adopt) while this service's own withdrawal check is
+                // bound to this exact Delivery instance; otherwise a closed question
+                // could be sent unchecked.
+                const withdrawal = this.ownerQuestionWithdrawal;
+                if (withdrawal === undefined || withdrawal.source !== delivery) {
+                    push({ action: 'deferred', questionId, reason: 'delivery-unavailable' });
+                    continue;
+                }
+                const withdrawalHandle = withdrawal.handle;
+                const idempotencyKey = attentionOwnerQuestionIdempotencyKey(questionId);
+                // An Outbox row under this key (e.g. enqueued before a crash, or under an
+                // older TTL) is adopted as queued; the send-time withdrawal check then
+                // keeps a since-closed question from being sent.
+                let existing;
+                try {
+                    existing = delivery.inspectOwnerNotification({ sourceId: ATTENTION_OWNER_QUESTION_SOURCE_ID, idempotencyKey, withdrawalHandle });
+                }
+                catch {
+                    push({ action: 'deferred', questionId, reason: 'delivery-unavailable' });
+                    continue;
+                }
+                if (existing !== undefined) {
+                    if (typeof existing.outboxId !== 'string' || existing.outboxId.length === 0 || existing.outboxId.length > 256) {
+                        push({ action: 'deferred', questionId, reason: 'delivery-unavailable' });
+                        continue;
+                    }
+                    this.store.attentionQuestions.recordDelivery(scope, cohort, questionId, 'queued', existing.outboxId);
+                    push({ action: 'queued', questionId, outboxId: existing.outboxId });
+                    continue;
+                }
+                if (!latest.open || this.store.attentionQuestions.reply(questionId) !== undefined) {
+                    this.store.attentionQuestions.recordDelivery(scope, cohort, questionId, 'closed', null);
+                    push({ action: 'closed', questionId });
+                    continue;
+                }
+                const expiresAt = question.createdAt + ttl;
+                if (this.now() >= expiresAt) {
+                    this.store.attentionQuestions.recordDelivery(scope, cohort, questionId, 'expired', null);
+                    push({ action: 'expired', questionId });
+                    continue;
+                }
+                let principal;
+                let sessionId;
+                try {
+                    const receipt = delivery.validateOwnerRoute({ authorityId: owner.ownerRouteId, principalId: owner.principalId,
+                        workspace: scope.workspace, agentPreset: scope.preset });
+                    sessionId = delivery.resolveOwnerRoute(owner.ownerRouteId).binding.sessionId;
+                    principal = { principalRecordId: receipt.principalRecordId, principalVersion: receipt.principalVersion };
+                }
+                catch {
+                    push({ action: 'deferred', questionId, reason: 'route-mismatch' });
+                    continue;
+                }
+                let outboxId;
+                try {
+                    outboxId = delivery.enqueueOwnerNotification({
+                        sourceId: ATTENTION_OWNER_QUESTION_SOURCE_ID,
+                        ownerRouteId: owner.ownerRouteId,
+                        scope: { principalId: owner.principalId, ...principal, workspace: scope.workspace, preset: scope.preset },
+                        sessionId,
+                        idempotencyKey,
+                        text: attentionOwnerQuestionText(question, scope, { repliesRead: true }),
+                        expiresAt,
+                        attention: { purpose: 'result' },
+                        withdrawable: true,
+                        withdrawalHandle,
+                    }).id;
+                }
+                catch {
+                    push({ action: 'deferred', questionId, reason: 'enqueue-failed' });
+                    continue;
+                }
+                if (typeof outboxId !== 'string' || outboxId.length === 0 || outboxId.length > 256) {
+                    push({ action: 'deferred', questionId, reason: 'enqueue-failed' });
+                    continue;
+                }
+                this.store.attentionQuestions.recordDelivery(scope, cohort, questionId, 'queued', outboxId);
+                push({ action: 'queued', questionId, outboxId });
+            }
+        }
+        return Object.freeze(results);
+    }
+    /**
+     * Host-internal record-only owner reply to the cohort's latest question.
+     * It never records a grant or changes a tuning version, and it is not the
+     * slice-5 apply path; an owner who authorizes uses
+     * `applyAttentionOwnerQuestionReply` (the only path the Delivery reply
+     * consumer calls) or records a host grant through `grantAttentionLoosening`.
+     */
+    recordAttentionOwnerQuestionReply(input) {
+        this.assertActive();
+        const cohort = this.#attentionCohort(input.cohort);
+        if (!this.config.attentionOwnerQuestionDeliveryEnabled)
+            return Object.freeze({ status: 'rejected', reason: 'delivery-disabled' });
+        const latest = this.store.attention.latestOwnerQuestion(input.scope, cohort);
+        if (latest === undefined || latest === 'unverifiable' || latest.questionId !== input.questionId) {
+            return Object.freeze({ status: 'rejected', reason: 'unknown-question' });
+        }
+        // A question whose notice expired (recorded, or past the TTL) no longer takes a reply.
+        const expired = this.store.attentionQuestions.delivery(latest.questionId)?.status === 'expired'
+            || this.now() >= latest.question.createdAt + this.config.attentionOwnerQuestionNoticeTtlMs;
+        return this.store.attentionQuestions.recordReply(input.scope, cohort, latest.questionId, input.choice, latest.open, expired);
+    }
+    /**
+     * Slice 5 evidence-backed apply path for one exact owner reply; the
+     * Delivery consumer and Host callers use this instead of the record-only
+     * seam. `authorize-once` records the reply and creates one bounded one-time
+     * grant for exactly the questioned proposal (parent/candidate bounds, the
+     * proposal's step size, one adoption); the next tuning tick still re-runs
+     * the independent holdout replay before adopting. `decline` closes the
+     * proposal. A proposal that already had an immutable decision returns
+     * `proposal-terminal` and nothing adopts.
+     */
+    applyAttentionOwnerQuestionReply(input) {
+        this.assertActive();
+        const cohort = this.#attentionCohort(input.cohort);
+        if (!this.config.attentionOwnerQuestionDeliveryEnabled)
+            return Object.freeze({ status: 'rejected', reason: 'delivery-disabled' });
+        return this.store.attention.applyOwnerQuestionReply(input.scope, cohort, input.questionId, input.choice, { noticeTtlMs: this.config.attentionOwnerQuestionNoticeTtlMs });
+    }
+    /** Per-question delivery decisions and recorded replies for one cohort. */
+    attentionOwnerQuestionStatus(input) {
+        this.assertActive();
+        return this.store.attentionQuestions.status(input.scope, this.#attentionCohort(input.cohort), this.config.attentionOwnerQuestionDeliveryEnabled);
+    }
     limits() {
         this.assertActive();
         return Object.freeze({
@@ -717,6 +1421,23 @@ export class AssistantEvaluationService extends Service {
         return this.active && typeof registration === 'object' && registration !== null
             && this.activeAutomationRegistrations.has(registration);
     }
+    /**
+     * Delivery's slot-anchored proof that an owner-notification withdrawal
+     * registration under the `assistantEvaluation` authority is this live
+     * service's own; a foreign object claiming that authority never passes.
+     */
+    ownsOwnerNotificationWithdrawal(registration) {
+        return this.active && typeof registration === 'object' && registration !== null
+            && this.activeOwnerQuestionWithdrawals.has(registration);
+    }
+    /**
+     * Delivery's slot-anchored proof that the slice-5 reply consumer under the
+     * `assistantEvaluation` authority is this live service's own registration.
+     */
+    ownsOwnerNotificationReply(registration) {
+        return this.active && typeof registration === 'object' && registration !== null
+            && this.activeOwnerQuestionReplies.has(registration);
+    }
     /** Delivery uses the same ownership boundary as Automations. */
     ownsTrustedDeliveryEvaluationRegistration(registration) {
         return this.active && typeof registration === 'object' && registration !== null
@@ -726,6 +1447,11 @@ export class AssistantEvaluationService extends Service {
         return this.active && typeof registration === 'object' && registration !== null
             && this.activeVerifierRegistrations.has(registration);
     }
+    /** Work-items exports settled outcome revisions through the same ownership boundary. */
+    ownsTrustedWorkItemEvaluationRegistration(registration) {
+        return this.active && typeof registration === 'object' && registration !== null
+            && this.activeWorkItemRegistrations.has(registration);
+    }
     review(agent, input = {}) {
         this.assertActive();
         const scope = this.agentScope(agent, 'evaluation_review');
@@ -871,7 +1597,22 @@ export class AssistantEvaluationService extends Service {
         if (current?.generation === generation)
             return current.dispose;
         const capabilities = new WeakMap();
+        const workItemProofs = new WeakMap();
         let registered = true;
+        // A WorkItems resolver is foreign code and can synchronously withdraw
+        // this Delivery capability. Check generation first, then our own fields
+        // after that last producer callback, directly before local mutation.
+        const assertWorkItemDeliveryLocal = () => {
+            this.assertActive();
+            if (!registered || this.deliveryBinding?.producer !== producer || this.deliveryBinding.generation !== generation
+                || !this.activeDeliveryRegistrations.has(registration)) {
+                throw new AssistantEvaluationError('forbidden', 'stale delivery Evaluation producer capability');
+            }
+        };
+        const assertWorkItemDeliveryCurrent = () => {
+            this.assertCurrentProducer(producer, generation, registered, 'delivery');
+            assertWorkItemDeliveryLocal();
+        };
         const registration = Object.freeze({
             protocol: TRUSTED_EVALUATION_PRODUCER_PROTOCOL,
             producer: 'assistant-delivery',
@@ -881,16 +1622,26 @@ export class AssistantEvaluationService extends Service {
             issueCapability: (claims) => {
                 this.assertCurrentProducer(producer, generation, registered, 'delivery');
                 const normalized = this.deliveryClaims(claims);
+                let workItemProofDigest;
                 if (normalized.subjectKind === 'goal-outcome') {
                     const { proof, verifierOutcome } = this.resolveGoalOutcomeOwnerProof(normalized);
                     if (this.store.adoptTrustedGoalOutcomeOwnerBaseline(normalized, proof, verifierOutcome)) {
                         this.notifyTrustedTaskChange();
                     }
                 }
+                else if (normalized.subjectKind === 'work-item') {
+                    if (typeof producer.withOwnerWorkItemFeedbackWriterFence !== 'function') {
+                        throw new AssistantEvaluationError('forbidden', 'Delivery work-item feedback writer fence is unavailable');
+                    }
+                    workItemProofDigest = this.resolveWorkItemOwnerProof(normalized).proofDigest;
+                    assertWorkItemDeliveryCurrent();
+                }
                 else
                     this.store.adoptLegacyOwnerFeedback(normalized);
                 const capability = Object.freeze(Object.create(null));
                 capabilities.set(capability, normalized);
+                if (workItemProofDigest !== undefined)
+                    workItemProofs.set(capability, workItemProofDigest);
                 return capability;
             },
             inspect: (capabilityReceipt) => {
@@ -902,6 +1653,12 @@ export class AssistantEvaluationService extends Service {
                     throw new AssistantEvaluationError('forbidden', 'missing owner lineage');
                 if (claims.subjectKind === 'goal-outcome')
                     this.resolveGoalOutcomeOwnerProof(claims);
+                if (claims.subjectKind === 'work-item'
+                    && this.resolveWorkItemOwnerProof(claims).proofDigest !== workItemProofs.get(capabilityReceipt)) {
+                    throw new AssistantEvaluationError('forbidden', 'work-item proof changed since owner capability issue');
+                }
+                if (claims.subjectKind === 'work-item')
+                    assertWorkItemDeliveryCurrent();
                 return this.store.ownerObjectiveState(claims.scope, claims.subjectKind ?? 'automation-run', claims.subjectRef ?? claims.runId, claims.ownerCommand.principalRecordId, claims.ownerCommand.principalVersion);
             },
             append: (input) => {
@@ -924,6 +1681,59 @@ export class AssistantEvaluationService extends Service {
                 }
                 if (claims.subjectKind === 'goal-outcome')
                     this.resolveGoalOutcomeOwnerProof(claims);
+                if (claims.subjectKind === 'work-item') {
+                    const proof = this.resolveWorkItemOwnerProof(claims);
+                    assertWorkItemDeliveryCurrent();
+                    if (proof.proofDigest !== workItemProofs.get(input.capabilityReceipt))
+                        throw new AssistantEvaluationError('forbidden', 'work-item proof changed since owner capability issue');
+                    // Production termination is its own trusted fact. It is persisted
+                    // with objective unknown before the separately authenticated owner vote.
+                    this.store.append({
+                        scope: claims.scope, situation: claims.situation,
+                        executionStatus: proof.production.executionStatus, objectiveStatus: 'unknown', deliveryStatus: 'unknown',
+                        source: { kind: 'system', id: 'assistant-work-items-owner-proof' }, trust: 'trusted',
+                        evidence: [
+                            { kind: 'work-item-owner-result', ref: proof.itemId },
+                            { kind: 'work-item-report', ref: `${proof.itemId}#${String(proof.reportRevision)}`, digest: proof.reportDigest },
+                            { kind: 'work-item-production-proof', ref: proof.production.runId, digest: proof.proofDigest },
+                        ], metrics: {}, occurredAt: proof.production.completedAt,
+                        idempotencyKey: `work-item-owner-proof:${acceptanceDigest([proof.itemId, proof.proofDigest])}`,
+                        evaluator: { id: 'assistant-work-items-owner-proof', version: '1' },
+                    });
+                    // The native producer can run callbacks. Re-prove it after durable
+                    // baseline creation and directly before the owner mutation.
+                    const finalProof = this.resolveWorkItemOwnerProof(claims);
+                    assertWorkItemDeliveryCurrent();
+                    if (acceptanceDigest(finalProof) !== acceptanceDigest(proof))
+                        throw new AssistantEvaluationError('forbidden', 'work-item proof changed before owner append');
+                    if (typeof producer.withOwnerWorkItemFeedbackWriterFence !== 'function') {
+                        throw new AssistantEvaluationError('forbidden', 'Delivery work-item feedback writer fence is unavailable');
+                    }
+                    const outcome = producer.withOwnerWorkItemFeedbackWriterFence(registration, claims, finalProof.proofDigest, () => {
+                        // This callback runs while Delivery owns its source writer lock.
+                        // No producer calls or notifications may re-enter after its final
+                        // owner/source/Policy check and before this local owner mutation.
+                        assertWorkItemDeliveryLocal();
+                        return this.store.append({
+                            scope: claims.scope, situation: claims.situation,
+                            executionStatus: proof.production.executionStatus, objectiveStatus: claims.objectiveStatus,
+                            deliveryStatus: 'delivered', source: { kind: 'user-feedback', id: 'assistant-delivery/typed-owner-feedback' }, trust: 'trusted',
+                            evidence: [
+                                { kind: 'work-item-owner-result', ref: proof.itemId },
+                                { kind: 'work-item-report', ref: `${proof.itemId}#${String(proof.reportRevision)}`, digest: proof.reportDigest },
+                                { kind: 'delivery-outbox', ref: claims.outboxId },
+                                { kind: 'work-item-production-proof', ref: proof.production.runId, digest: proof.proofDigest },
+                            ], metrics: {}, occurredAt: claims.occurredAt, idempotencyKey: claims.idempotencyKey,
+                            evaluator: { id: 'assistant-delivery-owner-feedback', version: '2' },
+                        }, claims.ownerCommand);
+                    });
+                    // Delivery has now committed its recorded source acknowledgement.
+                    // A lost cross-database acknowledgement remains a durable unknown;
+                    // it must recover the same operation instead of replaying a new vote.
+                    assertWorkItemDeliveryLocal();
+                    this.notifyTrustedTaskChange();
+                    return outcome;
+                }
                 return this.appendTrusted({
                     scope: claims.scope,
                     situation: claims.situation,
@@ -1086,6 +1896,114 @@ export class AssistantEvaluationService extends Service {
         previous?.dispose();
         return dispose;
     }
+    /**
+     * Bind the settled work-item producer.
+     *
+     * The envelope's objective and delivery status are always `unknown` and its
+     * execution status is derived here from the evidence state, never read from
+     * the producer. A work item can therefore contribute durable evidence without
+     * ever upgrading its own objective claim through Evaluation.
+     */
+    bindWorkItemsProducer(producer) {
+        const generation = hostIdentifier(producer.trustedWorkItemProducerGeneration(), 'trusted work-item generation', 200);
+        const current = this.workItemsBinding;
+        if (current?.generation === generation)
+            return current.dispose;
+        let registered = true;
+        let disposeRegistration;
+        let binding;
+        const assertCurrent = () => {
+            this.assertActive();
+            if (!registered || this.workItemsBinding?.producer !== producer
+                || this.workItemsBinding.generation !== generation
+                || producer.trustedWorkItemProducerGeneration() !== generation) {
+                throw new AssistantEvaluationError('forbidden', 'stale work-item Evaluation producer capability');
+            }
+        };
+        const registration = Object.freeze({
+            protocol: 'assistant-work-items/evaluation/v1',
+            generation,
+            owner: this,
+            append: async (claims) => {
+                assertCurrent();
+                if (typeof claims !== 'object' || claims === null || Array.isArray(claims)) {
+                    throw new AssistantEvaluationError('forbidden', 'work-item Evaluation claims are invalid');
+                }
+                const itemId = hostIdentifier(claims.itemId, 'work item id', 200);
+                const revision = claims.outcomeRevision;
+                const settledBy = claims.settledBy;
+                const evidenceState = claims.evidenceState;
+                const occurredAt = claims.occurredAt;
+                if (!Number.isSafeInteger(revision) || revision < 1
+                    || !['report-ready', 'report-blocked', 'report-failed', 'withdrawn', 'retry-exhausted', 'observed-evidence', 'window-expired', 'closed-by-thread'].includes(settledBy)
+                    || !['observed', 'unverified', 'not-applicable'].includes(evidenceState)) {
+                    throw new AssistantEvaluationError('forbidden', 'work-item Evaluation settlement is invalid');
+                }
+                // The registration type already limits these to the literal `'unknown'`;
+                // re-proving them at runtime keeps a forged capability from widening it.
+                if (claims.objectiveStatus !== 'unknown' || claims.deliveryStatus !== 'unknown') {
+                    throw new AssistantEvaluationError('forbidden', 'work-item Evaluation claims cannot assert an objective');
+                }
+                const idempotencyKey = `work-items/${itemId}/${String(revision)}/${evidenceState}`;
+                if (claims.idempotencyKey !== idempotencyKey) {
+                    throw new AssistantEvaluationError('forbidden', 'work-item Evaluation identity is not deterministic');
+                }
+                const digest = hostIdentifier(claims.digest, 'work-item outcome digest', 200);
+                const situation = hostIdentifier(claims.situation, 'work-item situation', this.config.maxSituationBytes);
+                if (!Number.isSafeInteger(occurredAt) || occurredAt < 0 || occurredAt > this.now()) {
+                    throw new AssistantEvaluationError('forbidden', 'work-item Evaluation occurrence is invalid');
+                }
+                const scope = canonicalEvaluationScope(claims.scope).scope;
+                this.appendTrusted({
+                    scope,
+                    situation,
+                    executionStatus: evidenceState === 'observed' ? 'succeeded' : 'unknown',
+                    objectiveStatus: 'unknown',
+                    deliveryStatus: 'unknown',
+                    source: { kind: 'system', id: 'assistant-work-items' },
+                    trust: 'trusted',
+                    evidence: [
+                        { kind: 'work-item', ref: itemId },
+                        { kind: 'work-item-outcome', ref: `${itemId}#${String(revision)}`, digest },
+                    ],
+                    metrics: claims.metrics,
+                    occurredAt,
+                    idempotencyKey,
+                    evaluator: {
+                        id: 'assistant-work-items',
+                        version: evidenceState === 'observed' ? 'settlement-v1' : 'unverified-v1',
+                    },
+                });
+            },
+        });
+        this.activeWorkItemRegistrations.add(registration);
+        const dispose = () => {
+            if (!registered)
+                return;
+            registered = false;
+            this.activeWorkItemRegistrations.delete(registration);
+            if (this.workItemsBinding === binding)
+                this.workItemsBinding = undefined;
+            disposeRegistration?.();
+        };
+        binding = Object.freeze({ producer, generation, dispose });
+        const previous = this.workItemsBinding;
+        this.workItemsBinding = binding;
+        try {
+            disposeRegistration = producer.registerTrustedWorkItemEvaluationSink(registration);
+            if (typeof disposeRegistration !== 'function')
+                throw new AssistantEvaluationError('forbidden', 'work-items returned no registration disposer');
+        }
+        catch (error) {
+            registered = false;
+            this.activeWorkItemRegistrations.delete(registration);
+            if (this.workItemsBinding === binding)
+                this.workItemsBinding = previous;
+            throw error;
+        }
+        previous?.dispose();
+        return dispose;
+    }
     producerGeneration(producer) {
         return hostIdentifier(producer.trustedEvaluationProducerGeneration(), 'trusted Evaluation producer generation', 200);
     }
@@ -1146,7 +2064,7 @@ export class AssistantEvaluationService extends Service {
         const subjectKind = input.subjectKind ?? 'automation-run';
         const subjectRef = input.subjectRef ?? input.runId;
         if ((input.subjectKind !== undefined && input.subjectKind !== 'automation-run'
-            && input.subjectKind !== 'foreground-turn' && input.subjectKind !== 'goal-outcome')
+            && input.subjectKind !== 'foreground-turn' && input.subjectKind !== 'goal-outcome' && input.subjectKind !== 'work-item')
             || (input.subjectRef !== undefined && input.subjectRef.trim() === '')) {
             throw new AssistantEvaluationError('forbidden', 'delivery Evaluation subject is invalid');
         }
@@ -1164,7 +2082,16 @@ export class AssistantEvaluationService extends Service {
             || typeof input.goalOutcomeCapability !== 'object' || input.goalOutcomeCapability === null)) {
             throw new AssistantEvaluationError('forbidden', 'goal outcome owner capability is invalid');
         }
+        if (subjectKind === 'work-item' && (input.subjectRef === undefined || command === undefined
+            || typeof input.workItemOutcomeCapability !== 'object' || input.workItemOutcomeCapability === null)) {
+            throw new AssistantEvaluationError('forbidden', 'work-item owner capability is invalid');
+        }
+        if ((subjectKind !== 'work-item' && Object.hasOwn(input, 'workItemOutcomeCapability'))
+            || (subjectKind !== 'goal-outcome' && Object.hasOwn(input, 'goalOutcomeCapability'))) {
+            throw new AssistantEvaluationError('forbidden', 'owner capability does not match subject');
+        }
         return Object.freeze({
+            ...(subjectKind === 'work-item' ? { workItemOutcomeCapability: input.workItemOutcomeCapability } : {}),
             ...(subjectKind === 'goal-outcome'
                 ? { goalOutcomeCapability: input.goalOutcomeCapability } : {}),
             ...(input.initialIdempotencyKey === undefined ? {} : { initialIdempotencyKey: hostIdentifier(input.initialIdempotencyKey, 'initial feedback key', 200) }),
@@ -1186,6 +2113,39 @@ export class AssistantEvaluationService extends Service {
             idempotencyKey: hostIdentifier(input.idempotencyKey, 'idempotencyKey', 200),
         });
     }
+    resolveWorkItemOwnerProof(claims) {
+        this.assertActive();
+        const producer = this.ctx.get('assistantWorkItems', false);
+        const binding = this.workItemsBinding;
+        if (claims.subjectKind !== 'work-item' || !isTrustedWorkItemEvaluationProducer(producer)
+            || !binding || serviceIdentity(producer) !== serviceIdentity(binding.producer)
+            || producer.trustedWorkItemProducerGeneration() !== binding.generation
+            || typeof producer.resolveOwnerWorkItemFeedbackTarget !== 'function') {
+            throw new AssistantEvaluationError('forbidden', 'current WorkItems owner capability resolver is unavailable');
+        }
+        let proof;
+        try {
+            const value = producer.resolveOwnerWorkItemFeedbackTarget(claims.workItemOutcomeCapability);
+            proof = validateWorkItemOwnerFeedbackProof(value, this.now());
+        }
+        catch {
+            throw new AssistantEvaluationError('forbidden', 'WorkItems owner capability is stale or invalid');
+        }
+        const currentGeneration = producer.trustedWorkItemProducerGeneration();
+        const current = this.ctx.get('assistantWorkItems', false);
+        this.assertActive();
+        if (currentGeneration !== binding.generation || !current || typeof current !== 'object' || this.workItemsBinding !== binding
+            || serviceIdentity(current) !== serviceIdentity(producer)
+            || claims.subjectRef !== proof.itemId || claims.runId !== proof.production.runId
+            || claims.scope.workspace !== proof.scope.workspace || claims.scope.preset !== proof.scope.preset
+            || claims.situation !== `work-item:${proof.itemKind}` || claims.principalId !== proof.owner.principalId
+            || !claims.ownerCommand || claims.ownerCommand.principalRecordId !== proof.owner.principalRecordId
+            || claims.ownerCommand.principalVersion !== proof.owner.principalVersion
+            || claims.occurredAt < proof.report.recordedAt || claims.occurredAt > this.now()) {
+            throw new AssistantEvaluationError('forbidden', 'WorkItems proof does not match current Delivery claims');
+        }
+        return proof;
+    }
     resolveGoalOutcomeOwnerProof(claims) {
         const goals = this.ctx.get('assistantGoals', false);
         if (!isTrustedGoalsOutcomeOwnerResolver(goals)) {