@kontourai/survey 3.0.0 → 5.0.0

package/dist/src/schema-mapping.js

@@ -20,7 +20,7 @@
  *      so that resolveInquiry can resolve across systems with weakest-link
  *      capping.
  */
-import { evaluateAutoAccept, getProducerProposal, projectProposalsToCandidateSet, } from "./producer-profile.js";
+import { assertValidAutoAcceptThreshold, evaluateAutoAccept, getProducerProposal, projectProposalsToCandidateSet, } from "./producer-profile.js";
 import { buildSurveyTrustBundle } from "./to-surface.js";
 // ---------------------------------------------------------------------------
 // Canonical pair key
@@ -35,6 +35,14 @@ function fieldPairKey(a, b) {
 function mappingSubjectId(a, b) {
     return fieldPairKey(a, b);
 }
+function mappingValue(proposal) {
+    return {
+        relation: proposal.relation,
+        sourceField: proposal.sourceField,
+        targetField: proposal.targetField,
+        conversion: proposal.conversion,
+    };
+}
 // ---------------------------------------------------------------------------
 // surveySchemaMapping
 // ---------------------------------------------------------------------------
@@ -56,9 +64,12 @@ function mappingSubjectId(a, b) {
  * storage) or for mappingReviewToSurface after human review.
  */
 export async function surveySchemaMapping(context, extractor, options = {}) {
+    if (options.autoAcceptMinConfidence !== undefined)
+        assertValidAutoAcceptThreshold(options.autoAcceptMinConfidence);
     const generatedAt = options.generatedAt ?? new Date().toISOString();
     const source = options.source ?? `schema-mapping:${extractor.name}`;
     const proposals = await Promise.resolve(extractor.extract(context));
+    const autoAcceptWarnings = [];
     // One RawSource per system schema
     const rawSources = context.systems.map((s) => ({
         id: `schema-mapping.source.${s.system}`,
@@ -93,11 +104,7 @@ export async function surveySchemaMapping(context, extractor, options = {}) {
                 id: extractionId,
                 sourceId: rawSource.id,
                 target: `${proposal.sourceField.entity}.${proposal.sourceField.field}:maps-to:${proposal.targetField.entity}.${proposal.targetField.field}`,
-                value: {
-                    relation: proposal.relation,
-                    targetField: proposal.targetField,
-                    conversion: proposal.conversion,
-                },
+                value: mappingValue(proposal),
                 confidence: proposal.confidence,
                 locator: proposal.sourceField.locator ?? `structured-field:${proposal.sourceField.entity}.${proposal.sourceField.field}`,
                 excerpt: proposal.evidence.map((e) => `[${e.system}] ${e.excerpt}`).join(" | "),
@@ -120,11 +127,7 @@ export async function surveySchemaMapping(context, extractor, options = {}) {
             return {
                 candidateId: `schema-mapping.candidate.${proposal.id}`,
                 extractionId,
-                value: {
-                    relation: proposal.relation,
-                    targetField: proposal.targetField,
-                    conversion: proposal.conversion,
-                },
+                value: mappingValue(proposal),
                 confidence: proposal.confidence,
                 equivalenceKey: proposal.relation,
                 metadata: {
@@ -179,6 +182,13 @@ export async function surveySchemaMapping(context, extractor, options = {}) {
                 rationale: selectedProposal?.rationale,
                 proposedAt: selectedProposal?.proposedAt,
             }, hasConflict, { minConfidence: options.autoAcceptMinConfidence }, generatedAt);
+            if (decision.warning) {
+                autoAcceptWarnings.push({
+                    code: decision.warning,
+                    proposalId: selectedProposal?.proposalId ?? selectedCandidate.id,
+                    confidence: decision.confidence,
+                });
+            }
             if (decision.accepted) {
                 const reviewId = `schema-mapping.review.${pairKey}`;
                 reviewOutcomes.push({
@@ -208,12 +218,8 @@ export async function surveySchemaMapping(context, extractor, options = {}) {
                 facet: "schema-mapping.profile",
                 claimType: "schema-mapping.field-link",
                 fieldOrBehavior: "maps-to",
-                value: {
-                    relation: first.relation,
-                    sourceField: first.sourceField,
-                    targetField: first.targetField,
-                    conversion: first.conversion,
-                },
+                // No value override: the claim carries the selected candidate's value,
+                // which is the whole mapping a reviewer (or auto-accept) decided on.
                 ...(claimStatus ? { status: claimStatus } : {}),
                 impactLevel: "medium",
                 collectedBy: extractor.name,
@@ -241,7 +247,12 @@ export async function surveySchemaMapping(context, extractor, options = {}) {
         reviewOutcomes,
         claims,
     };
-    return { surveyInput, proposals, candidateSets };
+    return {
+        surveyInput,
+        proposals,
+        candidateSets,
+        ...(autoAcceptWarnings.length > 0 ? { autoAcceptWarnings } : {}),
+    };
 }
 // ---------------------------------------------------------------------------
 // mappingReviewToSurface
@@ -315,7 +326,7 @@ export function mappingReviewToSurface(reviewedMappings, options = {}) {
             id: extractionId,
             sourceId: rawSourceId,
             target: `${sourceField.entity}.${sourceField.field}:maps-to:${targetField.entity}.${targetField.field}`,
-            value: { relation, targetField, conversion },
+            value: { relation, sourceField, targetField, conversion },
             confidence,
             locator: sourceField.locator ?? `structured-field:${sourceField.entity}.${sourceField.field}`,
             excerpt: evidence.map((e) => `[${e.system}] ${e.excerpt}`).join(" | "),
@@ -352,7 +363,6 @@ export function mappingReviewToSurface(reviewedMappings, options = {}) {
             facet: "schema-mapping.profile",
             claimType: "schema-mapping.field-link",
             fieldOrBehavior: "maps-to",
-            value: { relation, sourceField, targetField, conversion },
             status: rm.reviewOutcome.status,
             impactLevel: "medium",
             collectedBy: proposedBy,

package/dist/src/surface-reviewed-extraction.js

@@ -1,4 +1,8 @@
 export function toSurfaceReviewedExtractionImport(record) {
+    const unreported = record.spec.envelope.result.proposals.findIndex((proposal) => proposal.confidence === undefined);
+    if (unreported !== -1) {
+        throw new Error(`Surface's reviewed-extraction profile requires a proposer confidence on every proposal; proposal ${unreported} of ${record.metadata.name} reports none.`);
+    }
     return record;
 }
 export function toSurfaceReviewedExtractionItem(item) {

package/dist/src/to-surface.d.ts

@@ -2,6 +2,14 @@ import type { TrustBundle } from "@kontourai/surface";
 import { type CalibrationMetrics } from "./calibration.js";
 import type { SurveyInput } from "./types.js";
 export interface SurveyCalibrationOptions {
+    /**
+     * EXPERIMENTAL opt-in, required for any `conclusionConfidence.value` to be
+     * set (#279). The value is the affirmation rate of the claim's whole
+     * extractor/field GROUP — a base rate every affirmed claim in the group
+     * shares — not a per-claim probability. Without this flag the `calibration`
+     * option sets no value.
+     */
+    experimentalConclusionValue?: boolean;
     /**
      * Precomputed calibration to source the value from — typically derived over a
      * LONGER history than the current batch (a better-grounded curve, and it avoids
@@ -30,16 +38,32 @@ export interface BuildSurveyTrustBundleOptions {
      */
     projectionContextId?: string;
     /**
-     * Populate `conclusionConfidence.value` from empirical review calibration —
-     * "how often this extractor's proposals at this confidence were affirmed by a
-     * human reviewer" (the produce side of the confidence loop; see #114/#137).
-     * `true` derives calibration from this batch; an object supplies precomputed
-     * metrics and/or a `minSamples` floor. Absent → `value` stays unset and only
-     * the comfort-zone signal is carried (unchanged behavior).
+     * EXPERIMENTAL. Populate `conclusionConfidence.value` from empirical review
+     * calibration — the affirmation rate of the claim's extractor/field group
+     * (a group base rate, not a per-claim probability; see #114/#137/#279).
+     * A value is set ONLY with `{ experimentalConclusionValue: true }`; `true` or
+     * an object without that flag sets no value. The object may also supply
+     * precomputed `metrics` and/or a `minSamples` floor. Absent → `value` stays
+     * unset and only the comfort-zone signal is carried.
      *
      * ADVISORY (ADR 0003 §4): this only enriches the emitted conclusion confidence;
      * it never changes a claim's `status`.
      */
     calibration?: boolean | SurveyCalibrationOptions;
 }
+/**
+ * Thrown when a claim's trusted status or value does not agree with the review
+ * outcome it cites, or when the governing review cannot be chosen.
+ * - `status-mismatch`: a `verified`/`assumed` claim cites a review whose status differs.
+ * - `value-mismatch`: a `verified`/`assumed` claim carries a value other than the reviewed value.
+ * - `ambiguous-review-order`: several reviews apply to one candidate and the latest
+ *   cannot be determined from `reviewedAt` (missing, unparseable, or tied).
+ */
+export declare class ReviewAgreementError extends Error {
+    readonly name = "ReviewAgreementError";
+    readonly code: "status-mismatch" | "value-mismatch" | "ambiguous-review-order";
+    constructor(code: ReviewAgreementError["code"], message: string);
+}
 export declare function buildSurveyTrustBundle(input: SurveyInput, options?: BuildSurveyTrustBundleOptions): TrustBundle;
+/** Test-only: re-arm the once-per-process calibration opt-in warning. Not exported from the package index. */
+export declare function resetCalibrationOptInWarningForTests(): void;

package/dist/src/to-surface.js

@@ -2,15 +2,34 @@ import { createHash } from "node:crypto";
 import { buildReviewProofAnchor } from "./review-proof.js";
 import { assertReviewOutcomeDiscipline } from "./producer-discipline.js";
 import { deriveCalibration } from "./calibration.js";
+import { AUTO_ACCEPT_ACTOR } from "./producer-profile.js";
+import { canonicalJson } from "./review-workbench/canonical.js";
 /** Minimum labeled samples a calibration group needs before its empirical
  *  accuracy is emitted as a `conclusionConfidence.value`. */
 const DEFAULT_CALIBRATION_MIN_SAMPLES = 20;
+/**
+ * Thrown when a claim's trusted status or value does not agree with the review
+ * outcome it cites, or when the governing review cannot be chosen.
+ * - `status-mismatch`: a `verified`/`assumed` claim cites a review whose status differs.
+ * - `value-mismatch`: a `verified`/`assumed` claim carries a value other than the reviewed value.
+ * - `ambiguous-review-order`: several reviews apply to one candidate and the latest
+ *   cannot be determined from `reviewedAt` (missing, unparseable, or tied).
+ */
+export class ReviewAgreementError extends Error {
+    name = "ReviewAgreementError";
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+    }
+}
 export function buildSurveyTrustBundle(input, options = {}) {
     const projectionContextId = validateProjectionContextId(options.projectionContextId);
     const rawSources = indexById(input.rawSources, "raw source");
     const extractions = indexById(input.extractions, "extraction");
     const candidateSets = indexById(input.candidateSets, "candidate set");
     const reviewsByCandidateSet = groupBy(input.reviewOutcomes, (review) => review.candidateSetId);
+    // Only the explicit experimental opt-in produces a value (#279).
     const calibrationOptions = normalizeCalibrationOptions(options.calibration);
     const calibrationMetrics = calibrationOptions
         ? (calibrationOptions.metrics ?? deriveCalibration({
@@ -25,21 +44,26 @@ export function buildSurveyTrustBundle(input, options = {}) {
     const events = [];
     for (const projection of input.claims) {
         const candidateSet = requireMapValue(candidateSets, projection.candidateSetId, "candidate set");
+        if (projection.candidateId === undefined && candidateSet.selectedCandidateId === undefined && candidateSet.candidates.length > 1) {
+            projectUnselectedSetClaim({ input, projection, candidateSet, rawSources, extractions, reviewsByCandidateSet, projectionContextId, claims, evidence, events });
+            continue;
+        }
         const candidate = selectCandidate(candidateSet, projection.candidateId);
         const extraction = requireMapValue(extractions, candidate.extractionId, "extraction");
         const rawSource = requireMapValue(rawSources, extraction.sourceId, "raw source");
-        const review = selectReview(reviewsByCandidateSet.get(candidateSet.id) ?? [], candidate.id);
+        const review = selectReview(reviewsByCandidateSet.get(candidateSet.id) ?? [], candidate.id, projection.id);
         const projectionReview = review?.resolution === "could_not_confirm" ? undefined : review;
         const unreviewedStatus = statusFor({ candidateSet, candidate });
         const status = projection.status
             ?? (review?.resolution === "could_not_confirm"
                 ? (unreviewedStatus === "disputed" ? unreviewedStatus : review.status)
                 : statusFor({ candidateSet, candidate, review }));
-        assertProducerDiscipline({ status, review, candidateSet, extraction, rawSource, projection });
         const claimValue = projection.value ?? candidate.value;
+        assertProducerDiscipline({ status, review, candidateSet, candidate, extraction, rawSource, projection, claimValue });
         const createdAt = projection.createdAt ?? extraction.extractedAt;
         const updatedAt = projection.updatedAt ?? projectionReview?.reviewedAt ?? input.generatedAt;
         const evidenceId = projectionRecordId(projection.id, projectionContextId, "claim-evidence", "evidence.source");
+        const autoAccepted = projectionReview?.actor === AUTO_ACCEPT_ACTOR;
         const claim = {
             id: projection.id,
             subjectType: projection.subjectType,
@@ -57,8 +81,13 @@ export function buildSurveyTrustBundle(input, options = {}) {
             confidenceBasis: {
                 sourceQuality: "moderate",
                 extractionConfidence: candidate.confidence ?? extraction.confidence,
-                reviewerAuthority: status === "verified" || status === "assumed" ? "operator" : "none",
-                evidenceStrength: status === "verified" || status === "assumed" ? "moderate" : "weak",
+                // An auto-accept policy checked nothing but the proposer's own
+                // confidence, so its claims carry system authority and weak evidence;
+                // only a human review earns operator authority.
+                reviewerAuthority: status === "verified" || status === "assumed"
+                    ? (autoAccepted ? "system" : "operator")
+                    : "none",
+                evidenceStrength: (status === "verified" || status === "assumed") && !autoAccepted ? "moderate" : "weak",
                 impactLevel: projection.impactLevel,
                 ...projection.confidenceBasis,
             },
@@ -72,18 +101,21 @@ export function buildSurveyTrustBundle(input, options = {}) {
                     candidate,
                     review: projectionReview,
                     comfortZoneReview: review,
+                    valueEdit: (status === "verified" || status === "assumed") && review ? acceptedEdit(review) : undefined,
                 }),
             },
         };
-        // Promote the review's comfort-zone signal — and, when calibration is
-        // enabled, an empirically-calibrated conclusion probability — into the
+        // Promote the review's comfort-zone signal — and, under the experimental
+        // calibration opt-in, the group affirmation rate — into the
         // first-class conclusionConfidence field (Surface 2.9 / Hachure 0.14) so the
         // signal is portable and comparable, not buried in producer metadata.
         //
-        // comfortZone is CARRIED from the review. `value` is PRODUCED from empirical
-        // review calibration (#114/#137): the affirmation rate of this extractor's
-        // proposals at this confidence — a calibrated conclusion probability, distinct
-        // from the extraction-confidence ingredient in confidenceBasis.
+        // comfortZone is CARRIED from the review. `value` is PRODUCED, only under the
+        // experimental opt-in, from empirical review calibration (#114/#137/#279):
+        // the affirmation rate of this claim's extractor/field GROUP. It is a group
+        // base rate shared by every affirmed claim in the group, not a per-claim
+        // probability, and distinct from the extraction-confidence ingredient in
+        // confidenceBasis.
         //
         // A value is produced only for an AFFIRMED conclusion (status verified/assumed)
         // that clears the sample floor. conclusionConfidence.value is "probability the
@@ -192,6 +224,116 @@ export function buildSurveyTrustBundle(input, options = {}) {
         events,
     };
 }
+/**
+ * A claim over a candidate set that selects none of its candidates (a review
+ * rejected every conflicting value, or could not confirm any). No single value
+ * is presented: the claim value is the projection's own (null from the
+ * canonical path), every candidate is listed in `metadata.survey.candidates`
+ * and backed by its own evidence record, and the status can never be trusted.
+ * A review that names one candidate cannot apply to such a claim and is
+ * refused rather than dropped. With `reviewProofs`, no integrity anchor is
+ * attached: the anchor commits one reviewed candidate, and this claim has none
+ * (it is never `verified` or `assumed`).
+ */
+function projectUnselectedSetClaim(context) {
+    const { input, projection, candidateSet, projectionContextId } = context;
+    const setReviews = context.reviewsByCandidateSet.get(candidateSet.id) ?? [];
+    const candidateReviews = setReviews.filter((review) => review.candidateId);
+    if (candidateReviews.length) {
+        throw new Error(`Claim ${projection.id} names no candidate of set ${candidateSet.id}, but review ${candidateReviews.map((review) => review.id).join(", ")} is about candidate ${candidateReviews.map((review) => review.candidateId).join(", ")}: a candidate-level review needs a selectedCandidateId on the set or a candidateId on the claim.`);
+    }
+    const reviews = setReviews;
+    const review = latestReview(reviews, projection.id);
+    const setStatus = statusFor({ candidateSet, candidate: { id: "", extractionId: "", value: null } });
+    const status = projection.status
+        ?? (review?.resolution === "could_not_confirm"
+            ? (setStatus === "disputed" ? setStatus : review.status)
+            : review?.status ?? setStatus);
+    if (status === "verified" || status === "assumed") {
+        throw new ReviewAgreementError("status-mismatch", `Claim ${projection.id} selects no candidate of set ${candidateSet.id}, so it cannot be ${status}`);
+    }
+    assertReviewOutcomeDiscipline({ subject: `Claim ${projection.id}`, status, review, candidateSetStatus: candidateSet.status });
+    const sources = candidateSet.candidates.map((candidate) => {
+        const extraction = requireMapValue(context.extractions, candidate.extractionId, "extraction");
+        const rawSource = requireMapValue(context.rawSources, extraction.sourceId, "raw source");
+        return { candidate, extraction, rawSource };
+    });
+    const evidenceIds = sources.map(({ candidate, extraction, rawSource }) => {
+        const id = projectionRecordId(projection.id, projectionContextId, "claim-evidence", `evidence.source.${candidate.id}`);
+        const policyStandard = policyStandardFields(rawSource);
+        context.evidence.push({
+            id,
+            claimId: projection.id,
+            evidenceType: projection.evidenceType ?? (rawSource.resolution ? evidenceTypeForResolution(rawSource, rawSource.resolution) : evidenceTypeFor(rawSource)),
+            method: projection.evidenceMethod ?? "extraction",
+            sourceRef: rawSource.sourceRef,
+            sourceLocator: extraction.locator,
+            excerptOrSummary: evidenceExcerptOrSummary({ rawSource, extraction, projection, policyStandard }),
+            observedAt: rawSource.observedAt,
+            collectedBy: projection.collectedBy,
+            integrityRef: rawSource.checksum,
+            metadata: {
+                ...rawSource.metadata,
+                ...extraction.metadata,
+                ...candidate.metadata,
+                ...(policyStandard ? { policyStandard } : {}),
+                rawSourceKind: rawSource.kind,
+                locatorScheme: rawSource.locatorScheme,
+                candidateId: candidate.id,
+                ...(candidate.confidence ?? extraction.confidence) !== undefined ? { confidence: candidate.confidence ?? extraction.confidence } : {},
+            },
+        });
+        return id;
+    });
+    const producerSurvey = isRecord(projection.metadata?.survey) ? projection.metadata.survey : {};
+    context.claims.push({
+        id: projection.id,
+        subjectType: projection.subjectType,
+        subjectId: projection.subjectId,
+        facet: projection.facet,
+        claimType: projection.claimType,
+        fieldOrBehavior: projection.fieldOrBehavior,
+        value: "value" in projection ? projection.value : null,
+        status,
+        createdAt: projection.createdAt ?? sources.map(({ extraction }) => extraction.extractedAt).sort()[0],
+        updatedAt: projection.updatedAt ?? review?.reviewedAt ?? input.generatedAt,
+        impactLevel: projection.impactLevel,
+        derivedFrom: projection.derivedFrom,
+        derivationEdges: projection.derivationEdges,
+        confidenceBasis: {
+            sourceQuality: "moderate",
+            reviewerAuthority: "none",
+            evidenceStrength: "weak",
+            impactLevel: projection.impactLevel,
+            ...projection.confidenceBasis,
+        },
+        metadata: {
+            ...projection.metadata,
+            survey: {
+                ...producerSurvey,
+                candidateSetId: candidateSet.id,
+                candidateSetStatus: candidateSet.status,
+                // No candidate is selected; every value the set held, in set order.
+                candidates: candidateSet.candidates.map((candidate) => ({
+                    candidateId: candidate.id,
+                    value: candidate.value,
+                    ...(candidate.rejectionReason !== undefined ? { rejectionReason: candidate.rejectionReason } : {}),
+                })),
+                reviewOutcomeId: review?.id,
+            },
+        },
+    });
+    context.events.push({
+        id: projectionRecordId(projection.id, projectionContextId, "claim-event", `event.${status}`),
+        claimId: projection.id,
+        status,
+        actor: projection.actor ?? (review?.resolution === "could_not_confirm" ? undefined : review?.actor) ?? projection.collectedBy,
+        method: projection.eventMethod ?? eventMethodFor(status, candidateSet),
+        evidenceIds,
+        createdAt: review?.reviewedAt ?? input.generatedAt,
+        notes: review?.rationale ?? candidateSet.rationale,
+    });
+}
 function validateProjectionContextId(contextId) {
     if (contextId === undefined)
         return undefined;
@@ -235,7 +377,8 @@ function projectInterpretations(input) {
     }
 }
 function buildInterpretationProjection(input) {
-    const anchorSource = requirePolicyStandardAnchor(input.interpretation, input.rawSources);
+    assertInterpretationReadingShape(input.interpretation);
+    const anchorSource = requireInterpretationAnchor(input.interpretation, input.rawSources);
     const claim = resolveInterpretationClaim(input.interpretation, input.claims, input.input);
     if (!input.claimsById.has(claim.id)) {
         throw new Error(`Interpretation ${input.interpretation.id} resolved unknown claim ${claim.id}`);
@@ -260,6 +403,48 @@ function buildInterpretationProjection(input) {
         }),
     };
 }
+const INTERPRETATION_READING_KINDS = ["policy-standard", "gleaned", "answerImpact"];
+const INTERPRETATION_ANSWER_IMPACTS = ["supported", "narrowed", "accepted-risk"];
+/** Absent readingKind means the original policy-standard reading (pre-#259 records). */
+function interpretationReadingKind(interpretation) {
+    return interpretation.readingKind ?? "policy-standard";
+}
+/**
+ * Fail-closed shape validation for the reading dimension (#259). Records come
+ * from JSON as often as from typed callers, so unknown vocabulary throws
+ * instead of silently projecting under a label nothing derived.
+ */
+function assertInterpretationReadingShape(interpretation) {
+    if (interpretation.readingKind !== undefined && !INTERPRETATION_READING_KINDS.includes(interpretation.readingKind)) {
+        throw new Error(`Interpretation ${interpretation.id} has unknown readingKind ${String(interpretation.readingKind)}; expected one of ${INTERPRETATION_READING_KINDS.join(", ")}`);
+    }
+    const kind = interpretationReadingKind(interpretation);
+    if (kind === "answerImpact") {
+        if (interpretation.answerImpact === undefined) {
+            throw new Error(`Interpretation ${interpretation.id} readingKind answerImpact requires an answerImpact value`);
+        }
+        if (!INTERPRETATION_ANSWER_IMPACTS.includes(interpretation.answerImpact)) {
+            throw new Error(`Interpretation ${interpretation.id} has unknown answerImpact ${String(interpretation.answerImpact)}; expected one of ${INTERPRETATION_ANSWER_IMPACTS.join(", ")}`);
+        }
+        return;
+    }
+    if (interpretation.answerImpact !== undefined) {
+        throw new Error(`Interpretation ${interpretation.id} sets answerImpact but readingKind is ${kind}; answerImpact is only valid on answerImpact readings`);
+    }
+}
+/**
+ * Resolves an interpretation's anchor raw source. Every reading kind requires
+ * a KNOWN raw source (referential integrity per #16 R3); only the original
+ * policy-standard reading additionally requires the source kind to be
+ * `policy-standard`. The gleaned / answerImpact readings (#259) anchor to the
+ * result source the producer read, whatever its kind.
+ */
+function requireInterpretationAnchor(interpretation, rawSources) {
+    if (interpretationReadingKind(interpretation) === "policy-standard") {
+        return requirePolicyStandardAnchor(interpretation, rawSources);
+    }
+    return requireMapValue(rawSources, interpretation.anchorsToSourceId, "interpretation anchor raw source");
+}
 function requirePolicyStandardAnchor(interpretation, rawSources) {
     const anchorSource = requireMapValue(rawSources, interpretation.anchorsToSourceId, "interpretation anchor raw source");
     if (anchorSource.kind !== "policy-standard") {
@@ -268,14 +453,20 @@ function requirePolicyStandardAnchor(interpretation, rawSources) {
     return anchorSource;
 }
 function createInterpretationAnchorEvidence(input) {
+    const readingKind = interpretationReadingKind(input.interpretation);
     return {
         id: projectionRecordId(input.interpretation.id, input.projectionContextId, "interpretation-evidence", "evidence.anchor"),
         claimId: input.claim.id,
-        evidenceType: "policy_rule",
+        // The policy-standard reading keeps its exact prior projection; the new
+        // reading kinds (#259) derive the evidence type from the anchor source
+        // they actually read, via the same mapping extraction evidence uses.
+        evidenceType: readingKind === "policy-standard" ? "policy_rule" : evidenceTypeFor(input.anchorSource),
         method: "anchoring",
         sourceRef: input.anchorSource.sourceRef,
         sourceLocator: input.interpretation.ruleLocator,
-        excerptOrSummary: input.policyStandard?.inlineText ?? `Anchored policy-standard reading at ${input.interpretation.ruleLocator}.`,
+        excerptOrSummary: readingKind === "policy-standard"
+            ? input.policyStandard?.inlineText ?? `Anchored policy-standard reading at ${input.interpretation.ruleLocator}.`
+            : input.anchorSource.inlineText ?? `Anchored ${readingKind} reading at ${input.interpretation.ruleLocator}.`,
         observedAt: input.anchorSource.observedAt,
         collectedBy: input.interpretation.actor,
         integrityRef: input.anchorSource.checksum,
@@ -287,6 +478,10 @@ function createInterpretationAnchorEvidence(input) {
             locatorScheme: input.anchorSource.locatorScheme,
             anchorsToSourceId: input.anchorSource.id,
             ruleLocator: input.interpretation.ruleLocator,
+            // Only explicitly-set reading kinds project, so legacy batches stay
+            // byte-identical. Authored-judgment provenance markers, not machine facts.
+            ...(input.interpretation.readingKind ? { readingKind: input.interpretation.readingKind } : {}),
+            ...(input.interpretation.answerImpact ? { answerImpact: input.interpretation.answerImpact } : {}),
         },
     };
 }
@@ -319,6 +514,10 @@ function attachInterpretationClaimMetadata(input) {
                     reading: input.interpretation.reading,
                     actor: input.interpretation.actor,
                     recordedAt: input.interpretation.recordedAt,
+                    // Explicit reading dimension only (#259): legacy entries keep their
+                    // exact prior bytes; absent readingKind means policy-standard.
+                    ...(input.interpretation.readingKind ? { readingKind: input.interpretation.readingKind } : {}),
+                    ...(input.interpretation.answerImpact ? { answerImpact: input.interpretation.answerImpact } : {}),
                     ...(input.interpretation.metadata ? { metadata: input.interpretation.metadata } : {}),
                     edges: [
                         {
@@ -394,6 +593,11 @@ function buildSurveyMetadata(input) {
                 },
             }
             : {}),
+        // A trusted claim whose value is a reviewer's edit says so, and keeps the
+        // value the reviewer was shown.
+        ...(input.valueEdit
+            ? { valueEdit: { edited: true, originalValue: input.candidate.value, reviewOutcomeId: input.comfortZoneReview?.id } }
+            : {}),
         ...(input.comfortZoneReview?.withinComfortZone === false
             ? {
                 comfortZone: {
@@ -414,6 +618,8 @@ function statusFor(input) {
         return "disputed";
     if (input.candidateSet.status === "escalated")
         return "disputed";
+    if (input.candidateSet.status === "rejected")
+        return "rejected";
     return "proposed";
 }
 function assertProducerDiscipline(input) {
@@ -423,6 +629,17 @@ function assertProducerDiscipline(input) {
         review: input.review,
         candidateSetStatus: input.candidateSet.status,
     });
+    if ((input.status === "verified" || input.status === "assumed") && input.review) {
+        // A trusted claim may only restate its review: same status, and the value
+        // the reviewer saw (the candidate value, or the edit the review records).
+        if (input.review.status !== input.status) {
+            throw new ReviewAgreementError("status-mismatch", `Claim ${input.projection.id} status ${input.status} disagrees with review outcome ${input.review.id} status ${input.review.status}`);
+        }
+        const reviewedValue = reviewedValueFor(input.review, input.candidate);
+        if (canonicalJson(input.claimValue) !== canonicalJson(reviewedValue)) {
+            throw new ReviewAgreementError("value-mismatch", `Claim ${input.projection.id} is ${input.status} but its value differs from the value reviewed in ${input.review.id}`);
+        }
+    }
     if (input.rawSource.kind !== "manual-entry" && !input.extraction.locator) {
         throw new Error(`Claim ${input.projection.id} needs a source locator for ${input.rawSource.kind}`);
     }
@@ -435,15 +652,92 @@ function selectCandidate(candidateSet, candidateId) {
     }
     return candidate;
 }
-function selectReview(reviews, candidateId) {
-    return reviews.find((review) => review.candidateId === candidateId) ?? reviews.find((review) => !review.candidateId);
+/** An accepted edit the review records. `buildCanonicalReviewedTrustInput`
+ *  writes `metadata.editedValue` next to `metadata.workbenchDecision`; only an
+ *  edit on an `accept-proposed` decision replaces the reviewed value. Any other
+ *  `editedValue` (a bare one, or one on a reject or keep decision) is not an
+ *  accepted edit and is ignored. */
+function acceptedEdit(review) {
+    const metadata = review.metadata;
+    return metadata?.workbenchDecision === "accept-proposed" && Object.hasOwn(metadata, "editedValue")
+        ? { value: metadata.editedValue }
+        : undefined;
+}
+/** The value a review outcome attests: its accepted edit, else the candidate value that was reviewed. */
+function reviewedValueFor(review, candidate) {
+    const edit = acceptedEdit(review);
+    return edit ? edit.value : candidate.value;
+}
+/** The latest applicable review governs. Exact candidate bindings take
+ *  precedence over unbound (set-wide) reviews; within a tier, several reviews
+ *  are ordered by `reviewedAt`, and an order that cannot be established is
+ *  refused rather than guessed. */
+function selectReview(reviews, candidateId, claimId) {
+    const exact = reviews.filter((review) => review.candidateId === candidateId);
+    return latestReview(exact.length ? exact : reviews.filter((review) => !review.candidateId), claimId);
+}
+function latestReview(reviews, claimId) {
+    if (reviews.length <= 1)
+        return reviews[0];
+    const timed = reviews.map((review) => ({ review, at: review.reviewedAt ? Date.parse(review.reviewedAt) : Number.NaN }));
+    const untimed = timed.find((entry) => Number.isNaN(entry.at));
+    if (untimed) {
+        throw new ReviewAgreementError("ambiguous-review-order", `Claim ${claimId} has ${reviews.length} applicable review outcomes but ${untimed.review.id} has no parseable reviewedAt`);
+    }
+    const latestAt = Math.max(...timed.map((entry) => entry.at));
+    const latest = timed.filter((entry) => entry.at === latestAt).map((entry) => entry.review);
+    // Reviews at the same instant (however the timestamp is spelled) that record
+    // the same decision are one review recorded twice; conflicting ones are refused.
+    if (new Set(latest.map(reviewDecisionKey)).size > 1) {
+        throw new ReviewAgreementError("ambiguous-review-order", `Claim ${claimId} has conflicting review outcomes ${latest.map((review) => review.id).join(", ")} at the latest reviewedAt`);
+    }
+    return [...latest].sort((left, right) => (left.id < right.id ? -1 : left.id > right.id ? 1 : 0))[0];
+}
+function reviewDecisionKey(review) {
+    const edit = acceptedEdit(review);
+    return canonicalJson({
+        candidateId: review.candidateId ?? null,
+        status: review.status,
+        resolution: review.resolution ?? null,
+        edit: edit ? { value: edit.value } : null,
+        // These reach the claim (comfort zone, testimony provenance), so reviews
+        // that differ in them are different decisions, not one recorded twice.
+        withinComfortZone: review.withinComfortZone ?? null,
+        comfortZoneNote: review.comfortZoneNote ?? null,
+        authorizing: review.authorizing ?? null,
+    });
 }
 function normalizeCalibrationOptions(calibration) {
     if (calibration === undefined || calibration === false)
         return undefined;
-    if (calibration === true)
-        return {};
-    return calibration;
+    if (calibration === true || calibration.experimentalConclusionValue === undefined) {
+        // Callers written before #279 asked for a value this way; tell them it is
+        // now ignored instead of silently dropping it. An explicit `false` is a
+        // deliberate opt-out and stays quiet.
+        warnCalibrationOptInMissingOnce();
+        return undefined;
+    }
+    return calibration.experimentalConclusionValue === true ? calibration : undefined;
+}
+let warnedCalibrationOptInMissing = false;
+/**
+ * Warn once per process, matching the `defineProductVocabulary` deprecation
+ * notice: `buildSurveyTrustBundle` has no diagnostics channel in its return
+ * value (it returns a TrustBundle), and a per-call warning would flood batch
+ * projections.
+ */
+function warnCalibrationOptInMissingOnce() {
+    if (warnedCalibrationOptInMissing)
+        return;
+    warnedCalibrationOptInMissing = true;
+    console.warn("[@kontourai/survey] buildSurveyTrustBundle: the `calibration` option no longer sets " +
+        "conclusionConfidence.value without `calibration: { experimentalConclusionValue: true }` (#279). " +
+        "The value is an experimental extractor/field group base rate, not a per-claim probability. " +
+        "Pass the flag to keep it, or `experimentalConclusionValue: false` / omit `calibration` to silence this warning.");
+}
+/** Test-only: re-arm the once-per-process calibration opt-in warning. Not exported from the package index. */
+export function resetCalibrationOptInWarningForTests() {
+    warnedCalibrationOptInMissing = false;
 }
 /**
  * Looks up the empirical affirmation rate for an extractor/field, preferring the