@dsh-enhanced/assistant-evaluation 0.1.24 → 0.1.30

package/lib/store.js

@@ -255,14 +255,18 @@ export function evaluationLearningProjectionDigest(input) {
     ]);
 }
 function taskSubject(scopeKey, outcomeId, references) {
-    const automationRunRefs = new Set(references
-        .filter(reference => reference.kind === 'automation-run')
-        .map(reference => reference.ref));
-    if (automationRunRefs.size === 1) {
-        const ref = [...automationRunRefs][0];
+    const typed = references.flatMap(reference => (reference.kind === 'automation-run' || reference.kind === 'foreground-turn' || reference.kind === 'goal-step' || reference.kind === 'goal-outcome'
+        ? [{ kind: reference.kind, ref: reference.ref }]
+        : []));
+    const identities = new Map(typed.map(reference => [`${reference.kind}\u0000${reference.ref}`, reference]));
+    // A row that names more than one task subject is intentionally quarantined
+    // to its own audit outcome.  It must never bridge an Automation and a
+    // foreground turn (or two runs) into one learning subject.
+    if (identities.size === 1) {
+        const { kind, ref } = [...identities.values()][0];
         return Object.freeze({
-            key: JSON.stringify([scopeKey, 'automation-run', ref]),
-            kind: 'automation-run',
+            key: JSON.stringify([scopeKey, kind, ref]),
+            kind,
             ref,
         });
     }
@@ -303,9 +307,24 @@ function isAuthenticatedOwnerFeedback(row) {
         && row.source_id === 'assistant-delivery/typed-owner-feedback'
         && row.evaluator_id === 'assistant-delivery-owner-feedback'
         && row.evaluator_version === '2'
-        && containsEvidence(row, 'automation-run')
+        && (containsEvidence(row, 'automation-run') || containsEvidence(row, 'foreground-turn')
+            || containsEvidence(row, 'goal-outcome'))
         && containsEvidence(row, 'delivery-outbox');
 }
+function isTrustedVerifierReceipt(row) {
+    return row.trust === 'trusted'
+        && row.source_kind === 'evaluator'
+        && row.source_id === 'assistant-verifier'
+        && row.evaluator_id === 'assistant-verifier'
+        && row.evaluator_version === '1'
+        && containsEvidence(row, 'acceptance-contract')
+        && containsEvidence(row, 'verification-receipt');
+}
+function isAuthoritativeForegroundTerminal(row) {
+    return isTrustedVerifierReceipt(row)
+        && row.source_kind === 'evaluator'
+        && containsEvidence(row, 'foreground-turn');
+}
 export class EvaluationStore {
     #database;
     #now;
@@ -356,15 +375,240 @@ export class EvaluationStore {
     `).get(outcomeId, scopeKey);
         return row === undefined ? undefined : stored(row);
     }
-    append(input) {
+    /** Adopt a pre-revision owner row only through the exact Host delivery capability. */
+    adoptLegacyOwnerFeedback(claims) {
+        if (claims.ownerCommand === undefined || claims.initialIdempotencyKey === undefined)
+            return;
+        // Pre-revision rows only represented Automation runs. Foreground turns were
+        // introduced with the typed subject claims and cannot be guessed from them.
+        if ((claims.subjectKind ?? 'automation-run') !== 'automation-run')
+            return;
+        const scopeKey = canonicalEvaluationScope(claims.scope).scopeKey;
+        this.#database.exec('BEGIN IMMEDIATE');
+        try {
+            const row = this.#database.prepare(`SELECT * FROM evaluation_outcomes WHERE idempotency_key = ? AND scope_key = ?`)
+                .get(claims.initialIdempotencyKey, scopeKey);
+            if (row !== undefined && isAuthenticatedOwnerFeedback(row)) {
+                const evidence = JSON.parse(row.evidence_json);
+                if (!evidence.some(ref => ref.kind === 'automation-run' && ref.ref === claims.runId)
+                    || !evidence.some(ref => ref.kind === 'delivery-outbox' && ref.ref === claims.outboxId)) {
+                    throw new EvaluationStoreError('invalid-input', 'legacy feedback does not match exact delivered result');
+                }
+                this.#database.prepare(`INSERT INTO evaluation_owner_revisions
+          (outcome_id, subject_key, lineage, version, previous_outcome_id, action, command_json)
+          VALUES (?, ?, ?, 1, NULL, 'initial', ?) ON CONFLICT DO NOTHING`)
+                    .run(row.id, row.task_subject_key, JSON.stringify([claims.ownerCommand.principalRecordId, claims.ownerCommand.principalVersion]), JSON.stringify({
+                    ...claims.ownerCommand, action: 'legacy-adoption', outboxId: claims.outboxId,
+                    runId: claims.runId, bindingId: claims.bindingId, principalId: claims.principalId,
+                }));
+            }
+            this.#database.exec('COMMIT');
+        }
+        catch (error) {
+            this.#database.exec('ROLLBACK');
+            throw error;
+        }
+    }
+    /**
+     * Adopt the exact current Verifier whole-goal judgement as revision one for
+     * an authenticated owner lineage. The immutable Verifier outcome remains the
+     * authority row; the Goals proof is checked by the service and is not stored.
+     */
+    adoptTrustedGoalOutcomeOwnerBaseline(claims, proof, verifierOutcome) {
+        if (claims.subjectKind !== 'goal-outcome' || claims.ownerCommand === undefined) {
+            throw new EvaluationStoreError('invalid-input', 'goal outcome owner baseline claims are invalid');
+        }
+        const { scopeKey } = canonicalEvaluationScope(claims.scope);
+        const subjectRef = boundedText(claims.subjectRef, 'goal outcome assessmentId', 1_000);
+        const subject = taskSubject(scopeKey, '', [{ kind: 'goal-outcome', ref: subjectRef }]);
+        const lineage = JSON.stringify([
+            claims.ownerCommand.principalRecordId,
+            claims.ownerCommand.principalVersion,
+        ]);
+        const normalized = this.#normalize(verifierOutcome);
+        const payloadHash = digest(normalized);
+        const recordedAt = timestamp(this.#now(), 'recordedAt');
+        const outcomeId = `outcome-${randomUUID()}`;
+        const verifierSubject = taskSubject(normalized.scopeKey, outcomeId, normalized.evidence);
+        const exactEvidence = (entries, kind, ref, digestValue) => entries.some(item => (item.kind === kind && item.ref === ref
+            && (digestValue === undefined || item.digest === digestValue)));
+        if (normalized.scopeKey !== scopeKey || normalized.situation !== claims.situation
+            || normalized.objectiveStatus !== proof.receipt.objectiveStatus
+            || normalized.deliveryStatus !== 'not-required' || normalized.trust !== 'trusted'
+            || normalized.source.kind !== 'evaluator' || normalized.source.id !== 'assistant-verifier'
+            || normalized.evaluator.id !== 'assistant-verifier' || normalized.evaluator.version !== '1'
+            || normalized.occurredAt !== proof.receipt.completedAt
+            || normalized.idempotencyKey !== `assistant-verifier:${proof.receipt.id}`
+            || verifierSubject.kind !== 'goal-outcome' || verifierSubject.ref !== subjectRef
+            || normalized.evidence.length !== 4
+            || !exactEvidence(normalized.evidence, 'goal-outcome', subjectRef)
+            || !exactEvidence(normalized.evidence, 'acceptance-contract', proof.contract.id, proof.contract.digest)
+            || !exactEvidence(normalized.evidence, 'verification-receipt', proof.receipt.id, proof.receipt.digest)
+            || normalized.evidence.filter(item => item.kind === 'execution' && item.ref === subjectRef).length !== 1) {
+            throw new EvaluationStoreError('invalid-input', 'trusted goal outcome baseline input is invalid');
+        }
+        let changed = false;
+        this.#database.exec('BEGIN IMMEDIATE');
+        try {
+            let row = this.#database.prepare(`
+        SELECT outcome.* FROM evaluation_outcomes outcome
+        WHERE outcome.task_subject_key = ? AND outcome.task_subject_kind = 'goal-outcome'
+          AND outcome.task_subject_ref = ? AND outcome.trust = 'trusted'
+          AND outcome.source_kind = 'evaluator' AND outcome.source_id = 'assistant-verifier'
+          AND outcome.evaluator_id = 'assistant-verifier' AND outcome.evaluator_version = '1'
+        ORDER BY outcome.recorded_at DESC, outcome.id DESC LIMIT 1
+      `).get(subject.key, subjectRef);
+            if (row === undefined) {
+                const metric = normalized.metrics;
+                this.#database.prepare(`
+          INSERT INTO evaluation_outcomes(
+            id, idempotency_key, payload_hash, scope_key, workspace, preset, situation,
+            execution_status, objective_status, delivery_status, source_kind, source_id,
+            trust, evidence_json, metrics_json, cost_usd_micros, latency_ms, input_tokens,
+            output_tokens, tool_calls, occurred_at, recorded_at, evaluator_id, evaluator_version,
+            task_subject_key, task_subject_kind, task_subject_ref)
+          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+          ON CONFLICT(idempotency_key) DO NOTHING
+        `).run(outcomeId, normalized.idempotencyKey, payloadHash, normalized.scopeKey, normalized.scope.workspace, normalized.scope.preset, normalized.situation, normalized.executionStatus, normalized.objectiveStatus, normalized.deliveryStatus, normalized.source.kind, normalized.source.id, normalized.trust, JSON.stringify(normalized.evidence), JSON.stringify(normalized.metrics), metric.costUsdMicros ?? null, metric.latencyMs ?? null, metric.inputTokens ?? null, metric.outputTokens ?? null, metric.toolCalls ?? null, normalized.occurredAt, recordedAt, normalized.evaluator.id, normalized.evaluator.version, verifierSubject.key, verifierSubject.kind, verifierSubject.ref);
+                const winner = this.#database.prepare('SELECT * FROM evaluation_outcomes WHERE idempotency_key = ?')
+                    .get(normalized.idempotencyKey);
+                if (winner.payload_hash !== payloadHash || winner.task_subject_key !== verifierSubject.key
+                    || winner.task_subject_kind !== verifierSubject.kind || winner.task_subject_ref !== verifierSubject.ref) {
+                    throw new EvaluationStoreError('idempotency-conflict', 'trusted verifier outcome identity was reused');
+                }
+                this.#database.prepare(`
+          INSERT INTO evaluation_task_projections(
+            subject_key, scope_key, subject_kind, subject_ref, updated_at)
+          VALUES (?, ?, ?, ?, ?) ON CONFLICT(subject_key) DO NOTHING
+        `).run(verifierSubject.key, winner.scope_key, verifierSubject.kind, verifierSubject.ref, winner.recorded_at);
+                const refreshed = this.#refreshTaskProjection(verifierSubject.key);
+                if (refreshed.learningVersionChanged) {
+                    this.#database.prepare(`
+            INSERT INTO evaluation_projection_outbox(
+              evaluation_id, status, attempt_count, next_attempt_at,
+              last_failure_at, last_failure_code, created_at, updated_at)
+            VALUES (?, 'pending', 0, ?, NULL, NULL, ?, ?)
+            ON CONFLICT(evaluation_id) DO NOTHING
+          `).run(winner.id, winner.recorded_at, winner.recorded_at, winner.recorded_at);
+                    this.#advanceScopeWatermark(winner.scope_key, winner.recorded_at);
+                }
+                row = winner;
+                changed = true;
+            }
+            const storedEvidence = JSON.parse(row.evidence_json);
+            if (!isTrustedVerifierReceipt(row)
+                || row.idempotency_key !== normalized.idempotencyKey || row.payload_hash !== payloadHash
+                || (row.objective_status !== 'achieved' && row.objective_status !== 'not-achieved')
+                || row.objective_status !== proof.receipt.objectiveStatus
+                || row.situation !== claims.situation
+                || !exactEvidence(storedEvidence, 'goal-outcome', subjectRef)
+                || !exactEvidence(storedEvidence, 'acceptance-contract', proof.contract.id, proof.contract.digest)
+                || !exactEvidence(storedEvidence, 'verification-receipt', proof.receipt.id, proof.receipt.digest)) {
+                throw new EvaluationStoreError('invalid-input', 'trusted goal outcome baseline does not match the current verifier receipt');
+            }
+            const existing = this.#database.prepare(`
+        SELECT outcome_id FROM evaluation_owner_revisions
+        WHERE subject_key = ? AND lineage = ? ORDER BY version DESC LIMIT 1
+      `).get(subject.key, lineage);
+            if (existing !== undefined) {
+                this.#database.exec('COMMIT');
+                return changed;
+            }
+            const foreignLineage = this.#database.prepare(`
+        SELECT lineage FROM evaluation_owner_revisions WHERE subject_key = ? LIMIT 1
+      `).get(subject.key);
+            if (foreignLineage !== undefined) {
+                throw new EvaluationStoreError('invalid-input', 'goal outcome baseline belongs to another owner lineage');
+            }
+            this.#database.prepare(`INSERT INTO evaluation_owner_revisions
+        (outcome_id, subject_key, lineage, version, previous_outcome_id, action, command_json)
+        VALUES (?, ?, ?, 1, NULL, 'initial', ?)`)
+                .run(row.id, subject.key, lineage, JSON.stringify({
+                action: 'goal-outcome-baseline-adoption',
+                assessmentId: subjectRef,
+            }));
+            changed = true;
+            this.#database.exec('COMMIT');
+            return changed;
+        }
+        catch (error) {
+            this.#database.exec('ROLLBACK');
+            throw error;
+        }
+    }
+    ownerObjectiveState(scope, subjectKindOrRef, subjectRefOrPrincipal, principalRecordIdOrVersion, principalVersion) {
+        // Arity, not the opaque legacy run id, selects the generic overload.
+        const generic = principalVersion !== undefined;
+        const subjectKind = generic ? subjectKindOrRef : 'automation-run';
+        const subjectRef = generic ? subjectRefOrPrincipal : subjectKindOrRef;
+        const principalRecordId = generic ? principalRecordIdOrVersion : subjectRefOrPrincipal;
+        const version = generic ? principalVersion : principalRecordIdOrVersion;
+        const subject = taskSubject(canonicalEvaluationScope(scope).scopeKey, '', [{ kind: subjectKind, ref: subjectRef }]);
+        const row = this.#database.prepare(`
+      SELECT revision.version, outcome.objective_status
+      FROM evaluation_owner_revisions revision JOIN evaluation_outcomes outcome ON outcome.id = revision.outcome_id
+      WHERE revision.subject_key = ? AND revision.lineage = ? ORDER BY revision.version DESC LIMIT 1
+    `).get(subject.key, JSON.stringify([principalRecordId, version]));
+        return row === undefined ? undefined : { version: row.version, objectiveStatus: row.objective_status };
+    }
+    ownerCommandResult(outcome) {
+        const row = this.#database.prepare(`SELECT version FROM evaluation_owner_revisions WHERE outcome_id = ?`)
+            .get(outcome.id);
+        return row === undefined ? outcome : { ...outcome, ownerFeedbackState: { version: row.version, objectiveStatus: outcome.objectiveStatus } };
+    }
+    append(input, ownerCommand) {
         const normalized = this.#normalize(input);
         const payloadHash = digest(normalized);
         const id = `outcome-${randomUUID()}`;
         const subject = taskSubject(normalized.scopeKey, id, normalized.evidence);
         const recordedAt = timestamp(this.#now(), 'recordedAt');
         const metric = normalized.metrics;
+        let committed = false;
         this.#database.exec('BEGIN IMMEDIATE');
         try {
+            let previous;
+            const commandHash = digest({ input: normalized, ownerCommand: ownerCommand ?? null });
+            if (ownerCommand !== undefined) {
+                const replay = this.#database.prepare(`SELECT * FROM evaluation_owner_commands WHERE operation_id = ?`)
+                    .get(ownerCommand.operationId);
+                if (replay !== undefined) {
+                    if (replay.payload_hash !== commandHash)
+                        throw new EvaluationStoreError('idempotency-conflict', 'owner command identity reused');
+                    if (replay.failure_code !== null)
+                        throw new EvaluationStoreError(replay.failure_code === 'idempotency-conflict' ? 'idempotency-conflict' : 'version-conflict', 'owner judgement changed; inspect current feedback and retry');
+                    const result = this.getOutcome(input.scope, replay.outcome_id);
+                    this.#database.exec('COMMIT');
+                    return this.ownerCommandResult(result);
+                }
+                previous = this.#database.prepare(`
+          SELECT revision.outcome_id, revision.version, outcome.objective_status
+          FROM evaluation_owner_revisions revision JOIN evaluation_outcomes outcome ON outcome.id = revision.outcome_id
+          WHERE revision.subject_key = ? AND revision.lineage = ? ORDER BY revision.version DESC LIMIT 1
+        `).get(subject.key, JSON.stringify([ownerCommand.principalRecordId, ownerCommand.principalVersion]));
+                if (ownerCommand.action !== 'initial' && (previous === undefined
+                    || previous.version !== ownerCommand.expectedVersion || previous.objective_status !== ownerCommand.previousStatus)) {
+                    this.#database.prepare(`INSERT INTO evaluation_owner_commands VALUES (?, ?, NULL, 'version-conflict')`)
+                        .run(ownerCommand.operationId, commandHash);
+                    this.#database.exec('COMMIT');
+                    committed = true;
+                    throw new EvaluationStoreError('version-conflict', 'owner judgement changed; inspect current feedback and retry');
+                }
+                if (previous !== undefined && (ownerCommand.action === 'initial'
+                    || previous.objective_status === normalized.objectiveStatus)) {
+                    if (previous.objective_status !== normalized.objectiveStatus) {
+                        this.#database.prepare(`INSERT INTO evaluation_owner_commands VALUES (?, ?, NULL, 'idempotency-conflict')`)
+                            .run(ownerCommand.operationId, commandHash);
+                        this.#database.exec('COMMIT');
+                        committed = true;
+                        throw new EvaluationStoreError('idempotency-conflict', 'initial judgement already exists; use an explicit correction');
+                    }
+                    this.#database.prepare(`INSERT INTO evaluation_owner_commands VALUES (?, ?, ?, NULL)`)
+                        .run(ownerCommand.operationId, commandHash, previous.outcome_id);
+                    const result = this.getOutcome(input.scope, previous.outcome_id);
+                    this.#database.exec('COMMIT');
+                    return this.ownerCommandResult(result);
+                }
+            }
             this.#database.prepare(`
         INSERT INTO evaluation_outcomes(
           id, idempotency_key, payload_hash, scope_key, workspace, preset, situation,
@@ -393,6 +637,12 @@ export class EvaluationStore {
         VALUES (?, ?, ?, ?, ?)
         ON CONFLICT(subject_key) DO NOTHING
       `).run(winnerSubject.key, winner.scope_key, winnerSubject.kind, winnerSubject.ref, winner.recorded_at);
+            if (ownerCommand !== undefined) {
+                this.#database.prepare(`INSERT INTO evaluation_owner_revisions VALUES (?, ?, ?, ?, ?, ?, ?)`)
+                    .run(winner.id, winnerSubject.key, JSON.stringify([ownerCommand.principalRecordId, ownerCommand.principalVersion]), (previous?.version ?? 0) + 1, previous?.outcome_id ?? null, ownerCommand.action, JSON.stringify(ownerCommand));
+                this.#database.prepare(`INSERT INTO evaluation_owner_commands VALUES (?, ?, ?, NULL)`)
+                    .run(ownerCommand.operationId, commandHash, winner.id);
+            }
             const refreshed = this.#refreshTaskProjection(winnerSubject.key);
             if (winner.trust === 'trusted' && refreshed.learningVersionChanged) {
                 this.#database.prepare(`
@@ -405,10 +655,11 @@ export class EvaluationStore {
                 this.#advanceScopeWatermark(winner.scope_key, winner.recorded_at);
             }
             this.#database.exec('COMMIT');
-            return stored(winner);
+            return ownerCommand === undefined ? stored(winner) : this.ownerCommandResult(stored(winner));
         }
         catch (error) {
-            this.#database.exec('ROLLBACK');
+            if (!committed)
+                this.#database.exec('ROLLBACK');
             throw error;
         }
     }
@@ -573,6 +824,36 @@ export class EvaluationStore {
     `).get(outcomeId, scopeKey);
         return row === undefined ? undefined : projected(row);
     }
+    /** Exact run lookup without an audit query limit or a second success definition. */
+    getAutomationRunLearningProjection(scopeInput, runIdInput) {
+        const { scopeKey } = canonicalEvaluationScope(scopeInput);
+        const runId = boundedText(runIdInput, 'runId', 200);
+        const row = this.#database.prepare(`
+      SELECT task.* FROM evaluation_task_projection_view task
+      WHERE task.scope_key = ? AND task.task_subject_kind = 'automation-run'
+        AND task.task_subject_ref = ?
+    `).get(scopeKey, runId);
+        if (row === undefined)
+            return undefined;
+        const task = projected(row);
+        if (task.projection.status !== 'ready')
+            return undefined;
+        return this.getTaskLearningProjection(scopeInput, task.projection.primaryOutcomeId);
+    }
+    /** Exact whole-goal lookup by the verifier assessment identity. */
+    getGoalOutcomeLearningProjection(scopeInput, assessmentIdInput) {
+        const { scopeKey } = canonicalEvaluationScope(scopeInput);
+        const assessmentId = boundedText(assessmentIdInput, 'assessmentId', 1_000);
+        const row = this.#database.prepare(`
+      SELECT task.* FROM evaluation_task_projection_view task
+      WHERE task.scope_key = ? AND task.task_subject_kind = 'goal-outcome'
+        AND task.task_subject_ref = ?
+    `).get(scopeKey, assessmentId);
+        if (row === undefined)
+            return undefined;
+        const task = projected(row);
+        return this.getTaskLearningProjection(scopeInput, task.projection.primaryOutcomeId);
+    }
     /**
      * Resolve an append-only outbox trigger to the latest canonical state of its
      * task. The trigger may be arbitrarily old; version/digest always describe
@@ -638,9 +919,21 @@ export class EvaluationStore {
      * order is Evaluation first, downstream second; a Promise-returning callback
      * is rejected so the lock can never escape this stack frame.
      */
-    withLearningWriterFence(scopeInput, fenceInput, callback) {
+    withLearningWriterFence(scopeInput, fenceInput, callback, options = {}) {
+        const { scopeKey } = canonicalEvaluationScope(scopeInput);
+        const fence = this.#normalizeLearningWriterFence(fenceInput, false);
+        return this.#withLearningWriterFence(scopeKey, fence, callback, options);
+    }
+    /**
+     * Fence exact current canonical revisions, including retractions, without
+     * waiting for optional Evolution projection delivery.
+     */
+    withCanonicalTaskWriterFence(scopeInput, fenceInput, callback) {
         const { scopeKey } = canonicalEvaluationScope(scopeInput);
-        const fence = this.#normalizeLearningWriterFence(fenceInput);
+        const fence = this.#normalizeLearningWriterFence(fenceInput, true);
+        return this.#withLearningWriterFence(scopeKey, fence, callback, { requireProjectionDelivery: false });
+    }
+    #withLearningWriterFence(scopeKey, fence, callback, options) {
         this.#database.exec('BEGIN IMMEDIATE');
         try {
             const watermark = this.#database.prepare(`
@@ -650,7 +943,7 @@ export class EvaluationStore {
                 this.#database.exec('COMMIT');
                 return Object.freeze({ matched: false, reason: 'watermark-changed' });
             }
-            const pending = this.#database.prepare(`
+            const pending = options.requireProjectionDelivery === false ? undefined : this.#database.prepare(`
         SELECT 1 AS present
         FROM evaluation_projection_outbox outbox
         JOIN evaluation_outcomes outcome ON outcome.id = outbox.evaluation_id
@@ -671,7 +964,7 @@ export class EvaluationStore {
             for (const evidence of fence.evidence) {
                 const current = statement.get(scopeKey, evidence.subjectKind, evidence.subjectRef);
                 if (current === undefined || current.version !== evidence.version
-                    || current.digest !== evidence.digest || current.disposition !== 'upsert') {
+                    || current.digest !== evidence.digest || current.disposition !== evidence.disposition) {
                     this.#database.exec('COMMIT');
                     return Object.freeze({ matched: false, reason: 'evidence-changed' });
                 }
@@ -982,9 +1275,13 @@ export class EvaluationStore {
         }
         else {
             const terminals = rows.filter(row => isAuthoritativeAutomationTerminal(row));
-            execution = latest(terminals);
-            const owners = rows.filter(row => isAuthenticatedOwnerFeedback(row)
-                && row.objective_status !== 'unknown');
+            execution = projection.subject_kind === 'automation-run'
+                ? latest(terminals)
+                : latest(rows.filter(row => isAuthoritativeForegroundTerminal(row)));
+            const superseded = new Set(this.#database.prepare(`
+        SELECT previous_outcome_id FROM evaluation_owner_revisions WHERE subject_key = ? AND previous_outcome_id IS NOT NULL
+      `).all(subjectKey).map(row => row.previous_outcome_id));
+            const owners = rows.filter(row => isAuthenticatedOwnerFeedback(row) && !superseded.has(row.id));
             const ownerStatuses = new Set(owners.map(row => row.objective_status));
             if (ownerStatuses.size > 1)
                 objectiveConflicted = true;
@@ -993,12 +1290,14 @@ export class EvaluationStore {
             else {
                 const trustedObjectives = rows.filter(row => row.trust === 'trusted'
                     && row.source_kind !== 'user-feedback'
-                    && row.objective_status !== 'unknown');
+                    // The newest verifier receipt is authoritative even when it is
+                    // unknown: it retracts a stale achieved proof after expiry/recheck.
+                    && (row.objective_status !== 'unknown' || isTrustedVerifierReceipt(row)));
                 const ranked = trustedObjectives.map(row => ({
                     row,
                     // Independent trusted evaluators supersede the terminal producer's
                     // initial objective, while an owner judgement has already won above.
-                    rank: isAuthoritativeAutomationTerminal(row) ? 1 : 2,
+                    rank: isAuthoritativeAutomationTerminal(row) ? 1 : isTrustedVerifierReceipt(row) ? 3 : 2,
                 })).sort((left, right) => left.rank - right.rank || newer(left.row, right.row));
                 objective = ranked.at(-1)?.row;
             }
@@ -1009,7 +1308,7 @@ export class EvaluationStore {
             delivery = ownerDelivery ?? trustedDelivery ?? execution;
             const rankedPrimary = rows.map(row => ({
                 row,
-                rank: isAuthoritativeAutomationTerminal(row)
+                rank: isAuthoritativeAutomationTerminal(row) || isAuthoritativeForegroundTerminal(row)
                     ? 4
                     : isAuthenticatedOwnerFeedback(row)
                         ? 3
@@ -1082,7 +1381,7 @@ export class EvaluationStore {
         }
         return row.watermark;
     }
-    #normalizeLearningWriterFence(input) {
+    #normalizeLearningWriterFence(input, allowRetract) {
         if (typeof input !== 'object' || input === null || Array.isArray(input)
             || !Number.isSafeInteger(input.scopeWatermark) || input.scopeWatermark < 1
             || !Array.isArray(input.evidence) || input.evidence.length < 1
@@ -1092,8 +1391,8 @@ export class EvaluationStore {
         const seen = new Set();
         const entries = input.evidence.map((raw, index) => {
             if (typeof raw !== 'object' || raw === null || Array.isArray(raw)
-                || raw.disposition !== 'upsert'
-                || (raw.subjectKind !== 'automation-run' && raw.subjectKind !== 'outcome')
+                || (raw.disposition !== 'upsert' && (!allowRetract || raw.disposition !== 'retract'))
+                || (raw.subjectKind !== 'automation-run' && raw.subjectKind !== 'foreground-turn' && raw.subjectKind !== 'goal-step' && raw.subjectKind !== 'goal-outcome' && raw.subjectKind !== 'outcome')
                 || !Number.isSafeInteger(raw.version) || raw.version < 1
                 || raw.version > 1_000_000_000
                 || typeof raw.digest !== 'string' || !/^[a-f\d]{64}$/u.test(raw.digest)) {
@@ -1110,7 +1409,7 @@ export class EvaluationStore {
                 subjectRef,
                 version: raw.version,
                 digest: raw.digest,
-                disposition: 'upsert',
+                disposition: raw.disposition,
             });
         });
         return Object.freeze({