@dsh-enhanced/assistant-evaluation 0.1.24 → 0.1.31

package/lib/service.js

@@ -1,8 +1,9 @@
-import { Context, Service } from '@deepseek-ai/cordis';
+import { Context, Service, symbols } from '@deepseek-ai/cordis';
 import Schema from '@deepseek-ai/schemastery';
-import { EvaluationStore, canonicalEvaluationScope } from './store.js';
+import { acceptanceDigest, validateTaskAcceptanceContract, validateTaskVerificationReceipt } from '@dsh-enhanced/task-acceptance-contract';
+import { EvaluationStore, canonicalEvaluationScope, evaluationLearningProjectionDigest, } from './store.js';
 import { registerEvaluationTools } from './tools.js';
-import { TRUSTED_EVALUATION_PRODUCER_PROTOCOL } from './types.js';
+import { executionStatuses, objectiveStatuses, outcomeSourceKinds, TRUSTED_EVALUATION_PRODUCER_PROTOCOL, } from './types.js';
 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.
@@ -88,6 +89,71 @@ function hostIdentifier(value, label, maxBytes) {
 function hostOutcomeId(value) {
     return hostIdentifier(value, 'outcomeId', 200);
 }
+function recordValue(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function serviceIdentity(value) {
+    try {
+        const original = Reflect.get(value, symbols.original);
+        return (typeof original === 'object' && original !== null) || typeof original === 'function'
+            ? original
+            : value;
+    }
+    catch {
+        return value;
+    }
+}
+function exactHostIdentifier(value, label, maxBytes) {
+    if (typeof value !== 'string')
+        return false;
+    try {
+        return hostIdentifier(value, label, maxBytes) === value;
+    }
+    catch {
+        return false;
+    }
+}
+function validTrustedEvidence(value, maximum) {
+    if (!Array.isArray(value) || value.length > maximum)
+        return false;
+    return value.every((item, index) => {
+        const entry = recordValue(item);
+        return entry !== undefined
+            && exactHostIdentifier(entry.kind, `evidence[${index}].kind`, 64)
+            && exactHostIdentifier(entry.ref, `evidence[${index}].ref`, 512)
+            && (entry.digest === undefined
+                || exactHostIdentifier(entry.digest, `evidence[${index}].digest`, 128));
+    });
+}
+function validTrustedTaskComponent(value, statuses, maximumEvidence) {
+    const component = recordValue(value);
+    const source = recordValue(component?.source);
+    const evaluator = recordValue(component?.evaluator);
+    return component !== undefined
+        && exactHostIdentifier(component.outcomeId, 'component.outcomeId', 200)
+        && typeof component.status === 'string' && statuses.includes(component.status)
+        && source !== undefined
+        && typeof source.kind === 'string' && outcomeSourceKinds.includes(source.kind)
+        && exactHostIdentifier(source.id, 'component.source.id', 200)
+        && validTrustedEvidence(component.evidence, maximumEvidence)
+        && Number.isSafeInteger(component.occurredAt) && component.occurredAt >= 0
+        && evaluator !== undefined
+        && exactHostIdentifier(evaluator.id, 'component.evaluator.id', 200)
+        && exactHostIdentifier(evaluator.version, 'component.evaluator.version', 100);
+}
+function isTrustedGoalsOutcomeOwnerResolver(value) {
+    return typeof value === 'object' && value !== null
+        && typeof value
+            .resolveOwnerGoalOutcomeFeedbackTarget === 'function';
+}
+function isTrustedVerifierTaskInspector(value) {
+    return typeof value === 'object' && value !== null
+        && typeof value
+            .trustedVerificationProducerGeneration === 'function'
+        && typeof value.inspectAcceptedTask === 'function';
+}
 function isTrustedAutomationEvaluationProducer(value) {
     return typeof value === 'object' && value !== null
         && typeof value
@@ -102,6 +168,11 @@ function isTrustedDeliveryEvaluationProducer(value) {
         && typeof value
             .registerTrustedDeliveryEvaluationSink === 'function';
 }
+function isTrustedVerifierEvaluationProducer(value) {
+    return typeof value === 'object' && value !== null
+        && typeof value.trustedVerificationProducerGeneration === 'function'
+        && typeof value.registerTrustedVerifierEvaluationSink === 'function';
+}
 function isTrustedEvaluationProjector(value) {
     return typeof value === 'object' && value !== null
         && typeof value.projectTrustedEvaluationTaskRevision === 'function';
@@ -122,8 +193,10 @@ export class AssistantEvaluationService extends Service {
     projector;
     automationBinding;
     deliveryBinding;
+    verifierBinding;
     activeAutomationRegistrations = new WeakSet();
     activeDeliveryRegistrations = new WeakSet();
+    activeVerifierRegistrations = new WeakSet();
     activeProjections = new Map();
     projectionTimer;
     active = true;
@@ -212,6 +285,15 @@ export class AssistantEvaluationService extends Service {
                 return;
             return this.bindDeliveryProducer(producer);
         });
+        const currentVerifier = ctx.get('assistantVerifier');
+        if (isTrustedVerifierEvaluationProducer(currentVerifier))
+            this.bindVerifierProducer(currentVerifier);
+        ctx.inject(['assistantVerifier'], verifierCtx => {
+            const producer = verifierCtx.get('assistantVerifier');
+            if (!isTrustedVerifierEvaluationProducer(producer))
+                return;
+            return this.bindVerifierProducer(producer);
+        });
         if (this.config.projectionIntervalMs > 0) {
             this.projectionTimer = setInterval(() => {
                 void this.reconcileProjections().catch(() => { });
@@ -226,6 +308,7 @@ export class AssistantEvaluationService extends Service {
             disposeCurrentProjector?.();
             this.automationBinding?.dispose();
             this.deliveryBinding?.dispose();
+            this.verifierBinding?.dispose();
             disposeCurrentTools?.();
             disposeCurrentSkill?.();
             await Promise.allSettled(this.activeProjections.values());
@@ -333,6 +416,15 @@ export class AssistantEvaluationService extends Service {
             await Promise.allSettled(this.activeProjections.values());
         }
     }
+    /**
+     * Mint the opaque scope token required by trusted Host APIs. Consumers of an
+     * optionally injected Evaluation service can call this instance method and
+     * keep their package dependency type-only.
+     */
+    canonicalHostScope(input) {
+        this.assertActive();
+        return canonicalEvaluationHostScope(input);
+    }
     /**
      * Exact Host-only lookup used to project quality evidence into another local
      * ledger. Untrusted and missing rows are deliberately indistinguishable.
@@ -364,6 +456,73 @@ export class AssistantEvaluationService extends Service {
         const scope = exactEvaluationHostScope(input.scope);
         return this.store.getTaskLearningProjection(scope, hostOutcomeId(input.outcomeId));
     }
+    /** Host-only exact canonical run proof; conflicted tasks have no ready proof. */
+    getTrustedAutomationRunLearningProjection(input) {
+        this.assertActive();
+        return this.store.getAutomationRunLearningProjection(exactEvaluationHostScope(input.scope), input.runId);
+    }
+    /** Host-only exact canonical whole-goal proof, addressed by assessment id. */
+    getTrustedGoalOutcomeLearningProjection(input) {
+        this.assertActive();
+        return this.store.getGoalOutcomeLearningProjection(exactEvaluationHostScope(input.scope), hostIdentifier(input.assessmentId, 'assessmentId', 1_000));
+    }
+    /**
+     * Validate that a structurally untrusted value is the exact current trusted
+     * Evaluation projection. This is the runtime seam for optional consumers:
+     * malformed, forged, stale, cross-scope and post-disposal values return false.
+     */
+    isTrustedTaskLearningProjectionReceipt(input) {
+        try {
+            this.assertActive();
+            const receipt = recordValue(input);
+            const scope = recordValue(receipt?.scope);
+            const projection = recordValue(receipt?.projection);
+            if (receipt === undefined || scope === undefined || projection === undefined
+                || !exactHostIdentifier(receipt.triggerOutcomeId, 'triggerOutcomeId', 200)
+                || !exactHostIdentifier(scope.workspace, 'scope.workspace', 4_096)
+                || !exactHostIdentifier(scope.preset, 'scope.preset', 200)
+                || typeof receipt.scopeKey !== 'string'
+                || !Number.isSafeInteger(receipt.scopeWatermark) || receipt.scopeWatermark < 1
+                || !exactHostIdentifier(receipt.situation, 'situation', this.config.maxSituationBytes)
+                || (receipt.execution !== undefined
+                    && !validTrustedTaskComponent(receipt.execution, executionStatuses, this.config.maxEvidenceRefs))
+                || (receipt.objective !== undefined
+                    && !validTrustedTaskComponent(receipt.objective, objectiveStatuses, this.config.maxEvidenceRefs))
+                || (projection.subjectKind !== 'automation-run'
+                    && projection.subjectKind !== 'foreground-turn'
+                    && projection.subjectKind !== 'goal-step'
+                    && projection.subjectKind !== 'goal-outcome'
+                    && projection.subjectKind !== 'outcome')
+                || !exactHostIdentifier(projection.subjectRef, 'projection.subjectRef', 1_000)
+                || !Number.isSafeInteger(projection.version) || projection.version < 1
+                || projection.version > 1_000_000_000
+                || typeof projection.digest !== 'string' || !/^[a-f\d]{64}$/u.test(projection.digest)
+                || (projection.disposition !== 'upsert' && projection.disposition !== 'retract')
+                || (projection.evidenceOutcomeId !== undefined
+                    && !exactHostIdentifier(projection.evidenceOutcomeId, 'projection.evidenceOutcomeId', 200))) {
+                return false;
+            }
+            const canonical = canonicalEvaluationScope(scope);
+            if (canonical.scope.workspace !== scope.workspace || canonical.scope.preset !== scope.preset
+                || canonical.scopeKey !== receipt.scopeKey
+                || evaluationLearningProjectionDigest(input) !== projection.digest)
+                return false;
+            const current = this.store.getTaskLearningProjection(canonical.scope, receipt.triggerOutcomeId);
+            return current !== undefined
+                && current.scopeKey === receipt.scopeKey
+                && current.scopeWatermark === receipt.scopeWatermark
+                && current.situation === receipt.situation
+                && current.projection.subjectKind === projection.subjectKind
+                && current.projection.subjectRef === projection.subjectRef
+                && current.projection.version === projection.version
+                && current.projection.digest === projection.digest
+                && current.projection.disposition === projection.disposition
+                && current.projection.evidenceOutcomeId === projection.evidenceOutcomeId;
+        }
+        catch {
+            return false;
+        }
+    }
     /**
      * Synchronous cross-ledger writer fence.  Evaluation's writer lock is always
      * acquired before the callback may acquire Evolution's writer lock.
@@ -379,6 +538,36 @@ export class AssistantEvaluationService extends Service {
             evidence: input.evidence,
         }, callback);
     }
+    /**
+     * Canonical task writer fence for Host consumers whose commit depends on
+     * Evaluation state itself, rather than on delivery of that state to Evolution.
+     */
+    withTrustedCanonicalLearningWriterFence(input, callback) {
+        this.assertActive();
+        if (typeof callback !== 'function') {
+            throw new AssistantEvaluationError('invalid-input', 'writer fence callback is required');
+        }
+        const scope = exactEvaluationHostScope(input.scope);
+        return this.store.withLearningWriterFence(scope, {
+            scopeWatermark: input.scopeWatermark,
+            evidence: input.evidence,
+        }, callback, { requireProjectionDelivery: false });
+    }
+    /**
+     * Exact canonical task fence for reconciliation. It accepts a current
+     * retraction so a downstream ledger can invalidate stale state atomically.
+     */
+    withTrustedCanonicalTaskWriterFence(input, callback) {
+        this.assertActive();
+        if (typeof callback !== 'function') {
+            throw new AssistantEvaluationError('invalid-input', 'writer fence callback is required');
+        }
+        const scope = exactEvaluationHostScope(input.scope);
+        return this.store.withCanonicalTaskWriterFence(scope, {
+            scopeWatermark: input.scopeWatermark,
+            evidence: input.evidence,
+        }, callback);
+    }
     /** Host-only seam for a memory-assisted/model evaluator; always stored as self-reported. */
     appendSelfAssessment(input) {
         this.assertActive();
@@ -473,6 +662,10 @@ export class AssistantEvaluationService extends Service {
         return this.active && typeof registration === 'object' && registration !== null
             && this.activeDeliveryRegistrations.has(registration);
     }
+    ownsTrustedVerifierEvaluationRegistration(registration) {
+        return this.active && typeof registration === 'object' && registration !== null
+            && this.activeVerifierRegistrations.has(registration);
+    }
     review(agent, input = {}) {
         this.assertActive();
         const scope = this.agentScope(agent, 'evaluation_review');
@@ -622,15 +815,35 @@ export class AssistantEvaluationService extends Service {
         const registration = Object.freeze({
             protocol: TRUSTED_EVALUATION_PRODUCER_PROTOCOL,
             producer: 'assistant-delivery',
+            ownerRevisionProtocol: 'owner-objective-revision/v2',
             generation,
             owner: this,
             issueCapability: (claims) => {
                 this.assertCurrentProducer(producer, generation, registered, 'delivery');
                 const normalized = this.deliveryClaims(claims);
+                if (normalized.subjectKind === 'goal-outcome') {
+                    const { proof, verifierOutcome } = this.resolveGoalOutcomeOwnerProof(normalized);
+                    if (this.store.adoptTrustedGoalOutcomeOwnerBaseline(normalized, proof, verifierOutcome)) {
+                        this.notifyTrustedTaskChange();
+                    }
+                }
+                else
+                    this.store.adoptLegacyOwnerFeedback(normalized);
                 const capability = Object.freeze(Object.create(null));
                 capabilities.set(capability, normalized);
                 return capability;
             },
+            inspect: (capabilityReceipt) => {
+                this.assertCurrentProducer(producer, generation, registered, 'delivery');
+                if (typeof capabilityReceipt !== 'object' || capabilityReceipt === null)
+                    throw new AssistantEvaluationError('forbidden', 'invalid owner capability');
+                const claims = capabilities.get(capabilityReceipt);
+                if (claims?.ownerCommand === undefined)
+                    throw new AssistantEvaluationError('forbidden', 'missing owner lineage');
+                if (claims.subjectKind === 'goal-outcome')
+                    this.resolveGoalOutcomeOwnerProof(claims);
+                return this.store.ownerObjectiveState(claims.scope, claims.subjectKind ?? 'automation-run', claims.subjectRef ?? claims.runId, claims.ownerCommand.principalRecordId, claims.ownerCommand.principalVersion);
+            },
             append: (input) => {
                 this.assertCurrentProducer(producer, generation, registered, 'delivery');
                 if (typeof input !== 'object' || input === null || Array.isArray(input)
@@ -649,6 +862,8 @@ export class AssistantEvaluationService extends Service {
                     || hostIdentifier(input.idempotencyKey, 'idempotencyKey', 200) !== claims.idempotencyKey) {
                     throw new AssistantEvaluationError('forbidden', 'delivery Evaluation capability identity changed');
                 }
+                if (claims.subjectKind === 'goal-outcome')
+                    this.resolveGoalOutcomeOwnerProof(claims);
                 return this.appendTrusted({
                     scope: claims.scope,
                     situation: claims.situation,
@@ -658,14 +873,14 @@ export class AssistantEvaluationService extends Service {
                     source: { kind: 'user-feedback', id: 'assistant-delivery/typed-owner-feedback' },
                     trust: 'trusted',
                     evidence: [
-                        { kind: 'automation-run', ref: claims.runId },
+                        { kind: claims.subjectKind ?? 'automation-run', ref: claims.subjectRef ?? claims.runId },
                         { kind: 'delivery-outbox', ref: claims.outboxId },
                     ],
                     metrics: {},
                     occurredAt: claims.occurredAt,
                     idempotencyKey: claims.idempotencyKey,
                     evaluator: { id: 'assistant-delivery-owner-feedback', version: '2' },
-                });
+                }, claims.ownerCommand);
             },
         });
         this.activeDeliveryRegistrations.add(registration);
@@ -700,6 +915,115 @@ export class AssistantEvaluationService extends Service {
             previous.dispose();
         return dispose;
     }
+    bindVerifierProducer(producer) {
+        const generation = hostIdentifier(producer.trustedVerificationProducerGeneration(), 'trusted verifier generation', 200);
+        const current = this.verifierBinding;
+        if (current?.generation === generation)
+            return current.dispose;
+        let registered = true;
+        let disposeRegistration;
+        let binding;
+        const assertCurrent = () => {
+            this.assertActive();
+            if (!registered || this.verifierBinding?.producer !== producer
+                || this.verifierBinding.generation !== generation
+                || producer.trustedVerificationProducerGeneration() !== generation) {
+                throw new AssistantEvaluationError('forbidden', 'stale verifier Evaluation producer capability');
+            }
+        };
+        const registration = Object.freeze({
+            protocol: 'assistant-verifier/evaluation/v1',
+            generation,
+            owner: this,
+            append: async (input) => {
+                assertCurrent();
+                if (typeof input !== 'object' || input === null || Array.isArray(input)
+                    || Object.keys(input).sort().join(',') !== 'contract,execution,receipt') {
+                    throw new AssistantEvaluationError('forbidden', 'verifier Evaluation input is invalid');
+                }
+                let contract;
+                let receipt;
+                try {
+                    contract = validateTaskAcceptanceContract(input.contract);
+                    receipt = validateTaskVerificationReceipt(contract, input.receipt);
+                }
+                catch {
+                    throw new AssistantEvaluationError('forbidden', 'verifier Evaluation contract or receipt is invalid');
+                }
+                const execution = input.execution;
+                const completedAt = execution?.completedAt;
+                if (execution === null || typeof execution !== 'object' || Array.isArray(execution)
+                    || !['succeeded', 'failed', 'timed-out', 'cancelled', 'unknown'].includes(execution.status)
+                    || typeof execution.quiescent !== 'boolean'
+                    || (!execution.quiescent && receipt.objectiveStatus !== 'unknown') || !Number.isSafeInteger(completedAt)
+                    || completedAt < contract.issuedAt || receipt.startedAt < completedAt
+                    || receipt.validUntil <= this.now() || receipt.completedAt < receipt.startedAt
+                    || receipt.completedAt > this.now()
+                    || execution.executionRef !== contract.task.ref) {
+                    throw new AssistantEvaluationError('forbidden', 'verifier Evaluation execution is invalid');
+                }
+                const taskRef = hostIdentifier(contract.task.ref, 'verification task ref', 1_000);
+                const scope = canonicalEvaluationScope(contract.scope).scope;
+                let situation;
+                if (contract.task.kind === 'foreground-turn')
+                    situation = `foreground:${taskRef}`;
+                else if (contract.task.kind === 'goal-step' || contract.task.kind === 'goal-outcome') {
+                    const goal = contract.task.goal;
+                    situation = `goal:${hostIdentifier(goal.id, 'goal id', 1_000)}:definition:${goal.definitionVersion}`;
+                }
+                else {
+                    const projection = this.store.getAutomationRunLearningProjection(scope, taskRef);
+                    if (projection === undefined || projection.execution === undefined) {
+                        throw new AssistantEvaluationError('forbidden', 'automation terminal Evaluation projection is not available');
+                    }
+                    situation = projection.situation;
+                }
+                this.appendTrusted({
+                    scope, situation,
+                    executionStatus: execution.status,
+                    objectiveStatus: receipt.objectiveStatus,
+                    deliveryStatus: 'not-required',
+                    source: { kind: 'evaluator', id: 'assistant-verifier' }, trust: 'trusted',
+                    evidence: [
+                        { kind: contract.task.kind, ref: taskRef },
+                        { kind: 'acceptance-contract', ref: contract.id, digest: contract.digest },
+                        { kind: 'verification-receipt', ref: receipt.id, digest: receipt.digest },
+                        { kind: 'execution', ref: execution.executionRef },
+                    ],
+                    metrics: {}, occurredAt: receipt.completedAt,
+                    idempotencyKey: `assistant-verifier:${receipt.id}`,
+                    evaluator: { id: 'assistant-verifier', version: '1' },
+                });
+            },
+        });
+        this.activeVerifierRegistrations.add(registration);
+        const dispose = () => {
+            if (!registered)
+                return;
+            registered = false;
+            this.activeVerifierRegistrations.delete(registration);
+            if (this.verifierBinding === binding)
+                this.verifierBinding = undefined;
+            disposeRegistration?.();
+        };
+        binding = Object.freeze({ producer, generation, dispose });
+        const previous = this.verifierBinding;
+        this.verifierBinding = binding;
+        try {
+            disposeRegistration = producer.registerTrustedVerifierEvaluationSink(registration);
+            if (typeof disposeRegistration !== 'function')
+                throw new AssistantEvaluationError('forbidden', 'verifier returned no registration disposer');
+        }
+        catch (error) {
+            registered = false;
+            this.activeVerifierRegistrations.delete(registration);
+            if (this.verifierBinding === binding)
+                this.verifierBinding = previous;
+            throw error;
+        }
+        previous?.dispose();
+        return dispose;
+    }
     producerGeneration(producer) {
         return hostIdentifier(producer.trustedEvaluationProducerGeneration(), 'trusted Evaluation producer generation', 200);
     }
@@ -752,13 +1076,44 @@ export class AssistantEvaluationService extends Service {
     deliveryClaims(input) {
         if (typeof input !== 'object' || input === null || Array.isArray(input)
             || (input.objectiveStatus !== 'achieved' && input.objectiveStatus !== 'partial'
-                && input.objectiveStatus !== 'not-achieved')
+                && input.objectiveStatus !== 'not-achieved'
+                && !(input.objectiveStatus === 'unknown' && input.ownerCommand?.action === 'withdraw'))
             || !Number.isSafeInteger(input.occurredAt) || input.occurredAt < 0) {
             throw new AssistantEvaluationError('forbidden', 'delivery Evaluation claims are invalid');
         }
+        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.subjectRef !== undefined && input.subjectRef.trim() === '')) {
+            throw new AssistantEvaluationError('forbidden', 'delivery Evaluation subject is invalid');
+        }
+        const command = input.ownerCommand;
+        if (command !== undefined && ((command.action === 'withdraw') !== (input.objectiveStatus === 'unknown')
+            || (command.action === 'initial' && (command.expectedVersion !== undefined || command.previousStatus !== undefined))
+            || !['initial', 'correct', 'withdraw'].includes(command.action)
+            || !Number.isSafeInteger(command.principalVersion) || command.principalVersion < 1
+            || (command.action !== 'initial' && (!Number.isSafeInteger(command.expectedVersion)
+                || command.expectedVersion < 1 || !['achieved', 'partial', 'not-achieved', 'unknown'].includes(command.previousStatus))))) {
+            throw new AssistantEvaluationError('forbidden', 'owner revision precondition is invalid');
+        }
+        if (subjectKind === 'goal-outcome' && (input.subjectRef === undefined
+            || subjectRef !== input.runId || command === undefined
+            || typeof input.goalOutcomeCapability !== 'object' || input.goalOutcomeCapability === null)) {
+            throw new AssistantEvaluationError('forbidden', 'goal outcome owner capability is invalid');
+        }
         return Object.freeze({
+            ...(subjectKind === 'goal-outcome'
+                ? { goalOutcomeCapability: input.goalOutcomeCapability } : {}),
+            ...(input.initialIdempotencyKey === undefined ? {} : { initialIdempotencyKey: hostIdentifier(input.initialIdempotencyKey, 'initial feedback key', 200) }),
+            ...(command === undefined ? {} : { ownerCommand: Object.freeze({ ...command,
+                    operationId: hostIdentifier(command.operationId, 'owner operation', 200),
+                    principalRecordId: hostIdentifier(command.principalRecordId, 'owner lineage', 1000),
+                }) }),
             scope: Object.freeze({ ...canonicalEvaluationScope(input.scope).scope }),
             situation: hostIdentifier(input.situation, 'situation', this.config.maxSituationBytes),
+            ...(input.subjectKind === undefined ? {} : { subjectKind }),
+            ...(input.subjectRef === undefined ? {} : { subjectRef: hostIdentifier(subjectRef, 'subjectRef', 1_000) }),
             runId: hostIdentifier(input.runId, 'runId', 1_000),
             outboxId: hostIdentifier(input.outboxId, 'outboxId', 1_000),
             chatId: hostIdentifier(input.chatId, 'chatId', 1_000),
@@ -769,11 +1124,203 @@ export class AssistantEvaluationService extends Service {
             idempotencyKey: hostIdentifier(input.idempotencyKey, 'idempotencyKey', 200),
         });
     }
-    appendTrusted(input) {
-        const outcome = this.store.append(input);
-        void this.reconcileProjections({ limit: 1 }).catch(() => { });
+    resolveGoalOutcomeOwnerProof(claims) {
+        const goals = this.ctx.get('assistantGoals', false);
+        if (!isTrustedGoalsOutcomeOwnerResolver(goals)) {
+            throw new AssistantEvaluationError('forbidden', 'current Goals owner capability resolver is unavailable');
+        }
+        let value;
+        try {
+            value = goals.resolveOwnerGoalOutcomeFeedbackTarget(claims.goalOutcomeCapability);
+        }
+        catch {
+            throw new AssistantEvaluationError('forbidden', 'Goals owner capability is stale or invalid');
+        }
+        const proof = recordValue(value);
+        const locator = recordValue(proof?.locator);
+        const goal = recordValue(proof?.goal);
+        const profile = recordValue(proof?.profile);
+        const contract = recordValue(proof?.contract);
+        const receipt = recordValue(proof?.receipt);
+        const digestPattern = /^[a-f\d]{64}$/u;
+        const exactKeys = (input, keys) => {
+            if (input === undefined || (Object.getPrototypeOf(input) !== Object.prototype
+                && Object.getPrototypeOf(input) !== null) || Object.getOwnPropertySymbols(input).length !== 0
+                || Object.getOwnPropertyNames(input).sort().join(',') !== [...keys].sort().join(','))
+                return false;
+            return Object.values(Object.getOwnPropertyDescriptors(input))
+                .every(descriptor => descriptor.enumerable && 'value' in descriptor);
+        };
+        if (!exactKeys(proof, ['protocol', 'locator', 'goal', 'runId', 'profile', 'contract', 'receipt', 'proofDigest'])
+            || !exactKeys(locator, ['protocol', 'ownerRouteId', 'principalId', 'principalRecordId', 'principalVersion', 'workspace', 'preset', 'bindingId', 'bindingVersion', 'bindingGeneration', 'sessionId', 'goalId', 'assessmentId'])
+            || !exactKeys(goal, ['definitionVersion', 'definitionDigest', 'nativeGoalId', 'phase'])
+            || !exactKeys(profile, ['id', 'version', 'digest'])
+            || !exactKeys(contract, ['id', 'digest'])
+            || !exactKeys(receipt, ['id', 'digest', 'objectiveStatus', 'completedAt', 'validUntil'])
+            || proof.protocol !== 'assistant-goals/owner-goal-outcome-feedback/v1'
+            || locator.protocol !== 'assistant-goals/owner-goal-outcome-locator/v1'
+            || !Number.isSafeInteger(locator.principalVersion) || locator.principalVersion < 1
+            || !Number.isSafeInteger(locator.bindingVersion) || locator.bindingVersion < 1
+            || !Number.isSafeInteger(locator.bindingGeneration) || locator.bindingGeneration < 1
+            || !Number.isSafeInteger(goal.definitionVersion) || goal.definitionVersion < 1
+            || (goal.phase !== 'complete' && goal.phase !== 'blocked')
+            || !Number.isSafeInteger(profile.version) || profile.version < 1
+            || !Number.isSafeInteger(receipt.completedAt) || receipt.completedAt < 0
+            || !Number.isSafeInteger(receipt.validUntil)
+            || receipt.validUntil <= receipt.completedAt
+            || (receipt.objectiveStatus !== 'achieved' && receipt.objectiveStatus !== 'not-achieved')
+            || ![goal.definitionDigest, profile.digest, contract.digest, receipt.digest, proof.proofDigest]
+                .every(item => typeof item === 'string' && digestPattern.test(item))
+            || ![locator.ownerRouteId, locator.principalId, locator.principalRecordId, locator.workspace,
+                locator.preset, locator.bindingId, locator.sessionId, locator.goalId, locator.assessmentId,
+                goal.nativeGoalId, proof.runId, profile.id, contract.id, receipt.id]
+                .every(item => exactHostIdentifier(item, 'Goals owner proof identity', 4_096))
+            || acceptanceDigest({
+                protocol: proof.protocol, locator, goal, runId: proof.runId, profile, contract, receipt,
+            }) !== proof.proofDigest) {
+            throw new AssistantEvaluationError('forbidden', 'Goals owner proof is invalid');
+        }
+        const valid = value;
+        const expectedSituation = `goal:${valid.locator.goalId}:definition:${valid.goal.definitionVersion}`;
+        if (claims.subjectKind !== 'goal-outcome' || claims.subjectRef !== valid.locator.assessmentId
+            || claims.runId !== valid.locator.assessmentId || claims.scope.workspace !== valid.locator.workspace
+            || claims.scope.preset !== valid.locator.preset || claims.situation !== expectedSituation
+            || claims.principalId !== valid.locator.principalId || claims.bindingId !== valid.locator.bindingId
+            || claims.ownerCommand === undefined
+            || claims.ownerCommand.principalRecordId !== valid.locator.principalRecordId
+            || claims.ownerCommand.principalVersion !== valid.locator.principalVersion) {
+            throw new AssistantEvaluationError('forbidden', 'Goals owner proof does not match delivery claims');
+        }
+        const verifier = this.ctx.get('assistantVerifier', false);
+        if (!isTrustedVerifierTaskInspector(verifier)) {
+            throw new AssistantEvaluationError('forbidden', 'current Verifier goal outcome proof is unavailable');
+        }
+        const expectedVerifierBinding = this.verifierBinding;
+        let inspectedVerifierGeneration;
+        try {
+            inspectedVerifierGeneration = hostIdentifier(verifier.trustedVerificationProducerGeneration(), 'trusted verifier generation', 200);
+        }
+        catch {
+            throw new AssistantEvaluationError('forbidden', 'current Verifier goal outcome proof is unavailable');
+        }
+        if (expectedVerifierBinding === undefined
+            || serviceIdentity(verifier) !== serviceIdentity(expectedVerifierBinding.producer)
+            || inspectedVerifierGeneration !== expectedVerifierBinding.generation) {
+            throw new AssistantEvaluationError('forbidden', 'current Verifier goal outcome proof is unavailable');
+        }
+        let accepted;
+        try {
+            accepted = verifier.inspectAcceptedTask(valid.contract.id);
+        }
+        catch {
+            throw new AssistantEvaluationError('forbidden', 'current Verifier goal outcome proof is unavailable');
+        }
+        let acceptedContract;
+        let acceptedReceipt;
+        try {
+            acceptedContract = validateTaskAcceptanceContract(accepted?.contract);
+            acceptedReceipt = validateTaskVerificationReceipt(acceptedContract, accepted?.receipt);
+        }
+        catch {
+            throw new AssistantEvaluationError('forbidden', 'current Verifier goal outcome proof is invalid');
+        }
+        const execution = recordValue(accepted?.execution);
+        if (accepted?.state !== 'done' || acceptedContract.task.kind !== 'goal-outcome'
+            || !exactKeys(execution, ['status', 'quiescent', 'completedAt', 'executionRef'])
+            || !['succeeded', 'failed', 'timed-out', 'cancelled', 'unknown'].includes(execution.status)
+            || execution.quiescent !== true || !Number.isSafeInteger(execution.completedAt)
+            || execution.completedAt < acceptedContract.issuedAt
+            || acceptedReceipt.startedAt < execution.completedAt
+            || acceptedReceipt.completedAt < acceptedReceipt.startedAt
+            || acceptedReceipt.completedAt > this.now()
+            || execution.executionRef !== acceptedContract.task.ref
+            || acceptedContract.id !== valid.contract.id || acceptedContract.digest !== valid.contract.digest
+            || acceptedContract.task.ref !== valid.locator.assessmentId
+            || acceptedContract.task.goal.assessmentId !== valid.locator.assessmentId
+            || acceptedContract.task.goal.id !== valid.locator.goalId
+            || acceptedContract.task.goal.definitionVersion !== valid.goal.definitionVersion
+            || acceptedContract.task.goal.definitionDigest !== valid.goal.definitionDigest
+            || acceptedContract.task.goal.sessionId !== valid.locator.sessionId
+            || acceptedContract.task.goal.nativeGoalId !== valid.goal.nativeGoalId
+            || acceptedContract.scope.workspace !== valid.locator.workspace
+            || acceptedContract.scope.preset !== valid.locator.preset
+            || acceptedContract.owner.principalRecordId !== valid.locator.principalRecordId
+            || acceptedContract.owner.principalVersion !== valid.locator.principalVersion
+            || acceptedContract.profile.id !== valid.profile.id
+            || acceptedContract.profile.version !== valid.profile.version
+            || acceptedContract.profile.digest !== valid.profile.digest
+            || acceptedReceipt.id !== valid.receipt.id || acceptedReceipt.digest !== valid.receipt.digest
+            || acceptedReceipt.objectiveStatus !== valid.receipt.objectiveStatus
+            || acceptedReceipt.completedAt !== valid.receipt.completedAt
+            || acceptedReceipt.validUntil !== valid.receipt.validUntil) {
+            throw new AssistantEvaluationError('forbidden', 'Goals owner proof does not match the current Verifier receipt');
+        }
+        const currentGoals = this.ctx.get('assistantGoals', false);
+        try {
+            if (!isTrustedGoalsOutcomeOwnerResolver(currentGoals)
+                || acceptanceDigest(currentGoals.resolveOwnerGoalOutcomeFeedbackTarget(claims.goalOutcomeCapability)) !== acceptanceDigest(valid)) {
+                throw new Error('Goals generation changed');
+            }
+        }
+        catch {
+            throw new AssistantEvaluationError('forbidden', 'Goals owner capability is stale or invalid');
+        }
+        const currentVerifier = this.ctx.get('assistantVerifier', false);
+        try {
+            if (!isTrustedVerifierTaskInspector(currentVerifier)
+                || serviceIdentity(currentVerifier) !== serviceIdentity(expectedVerifierBinding.producer)
+                || hostIdentifier(currentVerifier.trustedVerificationProducerGeneration(), 'trusted verifier generation', 200) !== inspectedVerifierGeneration
+                || this.verifierBinding !== expectedVerifierBinding
+                || expectedVerifierBinding.generation !== inspectedVerifierGeneration) {
+                throw new Error('Verifier generation changed');
+            }
+        }
+        catch {
+            throw new AssistantEvaluationError('forbidden', 'current Verifier goal outcome proof is unavailable');
+        }
+        return Object.freeze({
+            proof: valid,
+            verifierOutcome: Object.freeze({
+                scope: Object.freeze({ ...acceptedContract.scope }),
+                situation: expectedSituation,
+                executionStatus: execution.status,
+                objectiveStatus: acceptedReceipt.objectiveStatus,
+                deliveryStatus: 'not-required',
+                source: Object.freeze({ kind: 'evaluator', id: 'assistant-verifier' }),
+                trust: 'trusted',
+                evidence: Object.freeze([
+                    Object.freeze({ kind: 'goal-outcome', ref: acceptedContract.task.ref }),
+                    Object.freeze({ kind: 'acceptance-contract', ref: acceptedContract.id, digest: acceptedContract.digest }),
+                    Object.freeze({ kind: 'verification-receipt', ref: acceptedReceipt.id, digest: acceptedReceipt.digest }),
+                    Object.freeze({ kind: 'execution', ref: execution.executionRef }),
+                ]),
+                metrics: Object.freeze({}),
+                occurredAt: acceptedReceipt.completedAt,
+                idempotencyKey: `assistant-verifier:${acceptedReceipt.id}`,
+                evaluator: Object.freeze({ id: 'assistant-verifier', version: '1' }),
+            }),
+        });
+    }
+    taskChangeListeners = new Set();
+    /** Host lifecycle subscription; consumers must re-read canonical proof and recover on startup. */
+    onTrustedTaskChange(listener) {
+        this.taskChangeListeners.add(listener);
+        return () => { this.taskChangeListeners.delete(listener); };
+    }
+    appendTrusted(input, command) {
+        const outcome = this.store.append(input, command);
+        this.notifyTrustedTaskChange();
         return outcome;
     }
+    notifyTrustedTaskChange() {
+        for (const listener of this.taskChangeListeners) {
+            try {
+                listener();
+            }
+            catch { /* Consumer startup / dispatch revalidation retries durable evidence. */ }
+        }
+        void this.reconcileProjections({ limit: 1 }).catch(() => { });
+    }
     async projectOne(entry) {
         const projector = this.projector;
         if (projector === undefined)