@kontourai/survey 4.0.0 → 5.0.0

package/dist/src/review-workbench/review-workbench.d.ts

@@ -5,7 +5,7 @@ import { type ReviewCandidate, type ReviewDecision, type ReviewItem, type Review
 export { reviewAuditRowKeys, type ReviewAuditRowKey } from "./audit-rows.js";
 export { assertReviewQueueAgainstExtractionImport, assertReviewQueueBinding, bindReviewQueue, hashReviewQueueSnapshot, UnattestedExtractionQueueError, UnattestedReviewQueueError, validateReviewQueueAgainstExtractionImport, validateReviewQueueBinding, type BindReviewQueueOptions, type ReviewQueueBinding, type ReviewQueueBindingIssue, type ReviewQueueBindingIssueCode, type ReviewQueueExtractionIssue, type ReviewQueueExtractionIssueCode, type ValidateReviewQueueBindingOptions, } from "./queue-binding.js";
 export { buildExtractionInspectorModel, exportExtractionInspector, filterExtractionInspectorCandidates, mountExtractionInspector, type ExtractionAlignmentState, type ArtifactUnavailableCode, type BuiltExtractionInspectorCandidate, type BuiltExtractionInspectorModel, type ExtractionInspectorCandidate, type ExtractionInspectorEntry, type ExtractionInspectorExportOptions, type ExtractionInspectorFilters, type ExtractionInspectorInput, type ExtractionInspectorMountOptions, type ExtractionInspectorModel, type ExtractionInspectorSource, type ResolvedExtractionArtifact, } from "./extraction-inspector.js";
-export { buildReviewSessionEvents, buildReviewSessionEvent, buildReviewSessionResource, candidateForDecision, keepActionDecision, currentReviewItem, currentReviewWorkbenchState, defaultReviewSessionName, deriveQueueRowStatus, initialReviewQueueSessionState, initialReviewWorkbenchState, nextUnresolvedItemName, replayReviewSessionEvents, reviewSessionSummary, reviewWorkbenchSessionStorageKey, selectedCandidateRole, workbenchDecisionDefinitions, type ReviewQueueRowStatus, type ReviewQueueSessionState, type ReviewSessionSummary, type ReviewWorkbenchDecision, type ReviewWorkbenchState, } from "./review-queue-session.js";
+export { buildReviewSessionEvents, buildReviewSessionEvent, buildReviewSessionResource, candidateForDecision, decisionCandidateId, decisionSelectsNoCandidate, keepActionDecision, currentReviewItem, currentReviewWorkbenchState, defaultReviewSessionName, deriveQueueRowStatus, initialReviewQueueSessionState, initialReviewWorkbenchState, nextUnresolvedItemName, replayReviewSessionEvents, reviewSessionSummary, reviewWorkbenchSessionStorageKey, selectedCandidateRole, workbenchDecisionDefinitions, type ReviewQueueRowStatus, type ReviewQueueSessionState, type ReviewSessionSummary, type ReviewWorkbenchDecision, type ReviewWorkbenchState, } from "./review-queue-session.js";
 export { buildReviewCandidatePresentation, buildReviewItemPresentation, buildReviewResultPresentation, humanizeIdentifier, type ReviewCandidatePresentation, type ReviewCandidatePresentationContext, type ReviewItemPresentation, type ReviewItemPresentationContext, type ReviewPresentationAdapter, type ReviewPresentationLink, type ReviewResultPresentation, type ReviewTracePresentationContext, type ReviewTraceRef, type ReviewValuePresentationContext, } from "./review-presentation.js";
 export { buildSurfaceProjectionPreview, type PreviewAuthorityTrace, type PreviewCandidateHistory, type PreviewClaim, type PreviewIntegrityPosture, type PreviewReviewEvent, type PreviewSourceAuthority, type PreviewSourceEvidence, type SurfaceProjectionPreview, } from "./review-surface-preview.js";
 export { reviewSessionReplayWarningsForSnapshot, validateReviewSessionEventsForSnapshot, type ReviewSessionReplayIssue, type ReviewSessionReplayIssueCode, type ReviewSessionReplayWarning, } from "./review-session-replay.js";
@@ -110,24 +110,31 @@ export interface ReviewQueueWindow {
 export interface BrowserReviewWorkbenchConfig {
     readonly startState?: ReviewQueueSessionState | ReviewWorkbenchState;
 }
+/**
+ * The in-process outcome of one workbench decision, derived from the session.
+ * For a decision that selects no candidate ({@link decisionSelectsNoCandidate}:
+ * reject-all or could-not-confirm on a conflict), every `selected*` and
+ * `effective*` field is absent, `unselectedCandidates` holds every candidate,
+ * and `reviewDecision.spec.candidateId` is absent.
+ */
 export interface ReviewWorkbenchResult {
     readonly reviewItemName: string;
     readonly decision: ReviewWorkbenchDecision;
-    readonly selectedCandidate: ReviewCandidate;
-    readonly selectedCandidateId: string;
+    readonly selectedCandidate?: ReviewCandidate;
+    readonly selectedCandidateId?: string;
     readonly selectedCandidateRole?: ReviewCandidate["role"];
     /** The selected candidate's original value, unaffected by any reviewer edit. Used
      *  for candidate-identity matching (see `matchingSelectedCandidate`); consumers who
      *  want the reviewer's edited value should read `effectiveValue` instead. */
-    readonly selectedValue: unknown;
-    readonly selectedDisplayValue: string;
+    readonly selectedValue?: unknown;
+    readonly selectedDisplayValue?: string;
     /** Reviewer-edited override captured for an accept-proposed decision, if the
      *  reviewer changed the proposed value before applying it. Additive/optional. */
     readonly editedValue?: unknown;
     /** The value that should actually be applied: `editedValue` when present (and the
      *  decision selects the proposed candidate), otherwise `selectedValue`. */
-    readonly effectiveValue: unknown;
-    readonly effectiveDisplayValue: string;
+    readonly effectiveValue?: unknown;
+    readonly effectiveDisplayValue?: string;
     readonly unselectedCandidates: readonly ReviewCandidate[];
     readonly reviewDecision: ReviewDecision;
     readonly status: ReviewDecision["spec"]["status"];

package/dist/src/review-workbench/review-workbench.js

@@ -1,6 +1,6 @@
 import { canonicalJson } from "./canonical.js";
 import { assertReviewResolutionConsistency } from "../producer-discipline.js";
-import { candidateForDecision, keepActionDecision, buildReviewSessionEvent, buildReviewSessionEvents, buildReviewSessionResource, currentReviewWorkbenchState, defaultReviewSessionName, effectiveValueForDecision, initialReviewQueueSessionState, replayReviewSessionEvents, reviewWorkbenchSessionStorageKey, workbenchDecisionDefinitions, } from "./review-queue-session.js";
+import { candidateForDecision, decisionCandidateId, decisionSelectsNoCandidate, keepActionDecision, buildReviewSessionEvent, buildReviewSessionEvents, buildReviewSessionResource, currentReviewWorkbenchState, defaultReviewSessionName, effectiveValueForDecision, initialReviewQueueSessionState, replayReviewSessionEvents, reviewWorkbenchSessionStorageKey, workbenchDecisionDefinitions, } from "./review-queue-session.js";
 import { reviewSessionReplayWarningsForSnapshot, validateReviewSessionEventsForSnapshot, } from "./review-session-replay.js";
 import { buildSurfaceProjectionPreview, formatValue, } from "./review-surface-preview.js";
 import { buildReviewCandidatePresentation, buildReviewItemPresentation, } from "./review-presentation.js";
@@ -12,7 +12,7 @@ import { createAuditFactTrace, } from "./audit-rows.js";
 export { reviewAuditRowKeys } from "./audit-rows.js";
 export { assertReviewQueueAgainstExtractionImport, assertReviewQueueBinding, bindReviewQueue, hashReviewQueueSnapshot, UnattestedExtractionQueueError, UnattestedReviewQueueError, validateReviewQueueAgainstExtractionImport, validateReviewQueueBinding, } from "./queue-binding.js";
 export { buildExtractionInspectorModel, exportExtractionInspector, filterExtractionInspectorCandidates, mountExtractionInspector, } from "./extraction-inspector.js";
-export { buildReviewSessionEvents, buildReviewSessionEvent, buildReviewSessionResource, candidateForDecision, keepActionDecision, currentReviewItem, currentReviewWorkbenchState, defaultReviewSessionName, deriveQueueRowStatus, initialReviewQueueSessionState, initialReviewWorkbenchState, nextUnresolvedItemName, replayReviewSessionEvents, reviewSessionSummary, reviewWorkbenchSessionStorageKey, selectedCandidateRole, workbenchDecisionDefinitions, } from "./review-queue-session.js";
+export { buildReviewSessionEvents, buildReviewSessionEvent, buildReviewSessionResource, candidateForDecision, decisionCandidateId, decisionSelectsNoCandidate, keepActionDecision, currentReviewItem, currentReviewWorkbenchState, defaultReviewSessionName, deriveQueueRowStatus, initialReviewQueueSessionState, initialReviewWorkbenchState, nextUnresolvedItemName, replayReviewSessionEvents, reviewSessionSummary, reviewWorkbenchSessionStorageKey, selectedCandidateRole, workbenchDecisionDefinitions, } from "./review-queue-session.js";
 export { buildReviewCandidatePresentation, buildReviewItemPresentation, buildReviewResultPresentation, humanizeIdentifier, } from "./review-presentation.js";
 export { buildSurfaceProjectionPreview, } from "./review-surface-preview.js";
 export { reviewSessionReplayWarningsForSnapshot, validateReviewSessionEventsForSnapshot, } from "./review-session-replay.js";
@@ -27,11 +27,15 @@ export function buildReviewDecision(state) {
         throw new Error("Could not confirm requires a non-empty reason.");
     }
     const candidate = candidateForDecision(state.item, state.decision);
+    // A decision that selects no candidate (a value-neutral decision on a
+    // conflict) records no candidate id and no candidate's projection hints.
+    const selectsNone = decisionSelectsNoCandidate(state.item, state.decision);
     const projection = {
-        ...candidate.projection,
-        reviewOutcomeId: candidate.projection?.reviewOutcomeId
+        ...(selectsNone ? state.item.spec.projection : candidate.projection),
+        reviewOutcomeId: (selectsNone ? state.item.spec.projection : candidate.projection)?.reviewOutcomeId
             ?? `${state.item.metadata.name}:${state.decision}:review-outcome`,
     };
+    const candidateProjection = selectsNone ? undefined : candidate.projection;
     const authorizing = buildDecisionCardAuthorizing(state);
     const reviewDecision = {
         apiVersion: reviewResourceApiVersion,
@@ -43,7 +47,7 @@ export function buildReviewDecision(state) {
         },
         spec: {
             reviewItemName: state.item.metadata.name,
-            candidateId: candidate.id,
+            ...(selectsNone ? {} : { candidateId: candidate.id }),
             status: definition.status,
             ...(state.decision === "could-not-confirm"
                 ? {
@@ -64,7 +68,7 @@ export function buildReviewDecision(state) {
                 : {}),
         },
         status: {
-            ...(candidate.projection?.claimId ? { appliedToClaimIds: [candidate.projection.claimId] } : {}),
+            ...(candidateProjection?.claimId ? { appliedToClaimIds: [candidateProjection.claimId] } : {}),
         },
     };
     assertReviewResolutionConsistency(`ReviewDecision ${reviewDecision.metadata.name}`, {
@@ -126,7 +130,16 @@ function buildDecisionCardAuthorizing(state) {
  */
 function decisionCardRenderedPrompt(state, targetLabel) {
     const currentCandidate = state.item.spec.candidates.find((c) => c.role === "current");
-    const proposedCandidate = state.item.spec.candidates.find((c) => c.role === "proposed");
+    const proposedCandidates = state.item.spec.candidates.filter((c) => c.role === "proposed");
+    // A conflict card lists every proposed value and offers reject-all or could
+    // not confirm; the prompt states the same, naming no single value.
+    if (proposedCandidates.length > 1) {
+        const decisionLabel = state.decision === "reject-proposed"
+            ? "Reject all values"
+            : state.decision ? workbenchDecisionDefinitions[state.decision].label : "";
+        return `For ${targetLabel}, ${proposedCandidates.length} different values were proposed: ${proposedCandidates.map((c) => formatValue(c.value)).join(", ")}. Selected decision: ${decisionLabel}.`;
+    }
+    const proposedCandidate = proposedCandidates[0];
     const currentValue = formatValue(currentCandidate?.value ?? "");
     const proposedValue = formatValue(proposedCandidate?.value ?? "");
     const decisionLabel = state.decision ? workbenchDecisionDefinitions[state.decision].label : "";
@@ -206,7 +219,9 @@ function duplicateTargetIssues(items) {
     return issues;
 }
 function mapReviewApplyResultToActions(input) {
-    if (input.result.decision === "could-not-confirm") {
+    // Could-not-confirm applies nothing, and neither does a decision that selects
+    // no candidate (rejecting every value of a conflict): there is no value to apply.
+    if (input.result.decision === "could-not-confirm" || input.result.selectedCandidateId === undefined) {
         return [];
     }
     const context = buildReviewApplyActionContext(input.result, input.itemByName, input.issues);
@@ -256,6 +271,8 @@ function buildReviewApplyActionContext(result, itemByName, issues) {
     };
 }
 function matchingSelectedCandidate(item, result) {
+    if (result.selectedCandidateId === undefined)
+        return undefined;
     const candidate = findSoleCandidateById(item, result.selectedCandidateId);
     return candidate
         && candidate.role === result.selectedCandidateRole
@@ -280,6 +297,16 @@ export function buildReviewWorkbenchResultsFromSession(session) {
         if (!reviewDecision) {
             return [];
         }
+        if (decisionSelectsNoCandidate(item, decision)) {
+            return [{
+                    reviewItemName: item.metadata.name,
+                    decision,
+                    unselectedCandidates: [...item.spec.candidates],
+                    reviewDecision,
+                    status: reviewDecision.spec.status,
+                    rationale: reviewDecision.spec.rationale,
+                }];
+        }
         const selectedCandidate = candidateForDecision(item, decision);
         const editedValue = decision === "accept-proposed"
             ? session.editedValuesByItemName?.[item.metadata.name]
@@ -491,13 +518,13 @@ function fieldCardState(item, decision) {
  * {@link keepActionDecision}). Saying "Kept — flagged wrong" there would claim a
  * distinction the record does not hold, so the chip states only what happened.
  */
-function chipLabel(state, hasCurrentValue) {
+function chipLabel(state, hasCurrentValue, conflictingValues) {
     switch (state) {
         case "accepted": return "Accepted";
-        case "kept": return hasCurrentValue ? "Kept current" : "Left unset";
-        case "rejected": return hasCurrentValue ? "Kept — flagged wrong" : "Left unset";
+        case "kept": return hasCurrentValue ? "Kept current" : conflictingValues ? "All values rejected" : "Left unset";
+        case "rejected": return hasCurrentValue ? "Kept — flagged wrong" : conflictingValues ? "All values rejected" : "Left unset";
         case "could-not-confirm": return "Could not confirm";
-        default: return "Needs review";
+        default: return conflictingValues ? `Conflict: ${conflictingValues} values` : "Needs review";
     }
 }
 const DEFAULT_REVIEW_QUEUE_PAGE_SIZE = 50;
@@ -618,11 +645,16 @@ function renderFieldCard(item, session, presentationAdapter) {
     const state = fieldCardState(item, decision);
     const decided = decision !== undefined;
     const current = item.spec.candidates.find((candidate) => candidate.role === "current");
-    const proposed = item.spec.candidates.find((candidate) => candidate.role === "proposed");
+    const proposedCandidates = item.spec.candidates.filter((candidate) => candidate.role === "proposed");
+    // Several proposed values for one claim are a conflict. A control names a
+    // role, not a value, so none may make one of them the trusted value; the
+    // reviewer can still reject them all or end the round as could-not-confirm.
+    const conflict = proposedCandidates.length > 1;
+    const proposed = proposedCandidates.length === 1 ? proposedCandidates[0] : undefined;
     const presentation = buildReviewItemPresentation(item, presentationAdapter);
     const hasCurrentValue = current !== undefined && !isEmptyValue(current.value);
     const kind = hasCurrentValue ? "Update" : "New";
-    const keepLabel = hasCurrentValue ? "Keep current" : "Leave unset";
+    const keepLabel = hasCurrentValue ? "Keep current" : conflict ? "Reject all values" : "Leave unset";
     // Only render controls whose decision this item can actually record. Every
     // decision resolves to a candidate role, so a control routed at a role the
     // item does not carry cannot emit anything — it used to throw mid-click and
@@ -653,11 +685,13 @@ function renderFieldCard(item, session, presentationAdapter) {
         <div class="frow1">
           <span class="fname">${escapeHtml(presentation.targetLabel)}</span>
           <span class="fkind">${kind}</span>
-          <span class="chip ${state} push" data-testid="field-chip">${chipLabel(state, hasCurrentValue)}</span>
+          <span class="chip ${state} push" data-testid="field-chip">${chipLabel(state, hasCurrentValue, conflict ? proposedCandidates.length : undefined)}</span>
         </div>
         ${proposed
         ? renderDiffRow(item, current, proposed, presentation.targetLabel, decided, effectiveProposedText, currentPresentationText)
-        : "<p class=\"field-value\">No proposed value is available for this field.</p>"}
+        : proposedCandidates.length > 1
+            ? renderConflictingProposals(item, proposedCandidates, presentationAdapter, presentation.targetLabel)
+            : "<p class=\"field-value\">No proposed value is available for this field.</p>"}
         ${proposed ? renderProvenanceRow(item, proposed, presentationAdapter) : ""}
         <div class="decide">
           ${keepDecision === undefined ? "" : `<button class="btn keep" type="button" data-testid="keep-current" data-item-name="${escapeHtml(item.metadata.name)}">${keepLabel}</button>`}
@@ -667,6 +701,7 @@ function renderFieldCard(item, session, presentationAdapter) {
             Suggestion was wrong
           </label>
           <button class="btn unconfirmed" type="button" data-testid="could-not-confirm" data-item-name="${escapeHtml(item.metadata.name)}">Could not confirm</button>` : ""}
+          ${conflict ? `<button class="btn unconfirmed" type="button" data-testid="could-not-confirm" data-item-name="${escapeHtml(item.metadata.name)}">Could not confirm</button>` : ""}
         </div>
         <!--
           A control's precondition message belongs where the control is. The
@@ -677,7 +712,7 @@ function renderFieldCard(item, session, presentationAdapter) {
         -->
         <span class="derr" data-testid="decision-error" role="alert" hidden></span>
         <div class="decided">
-          <span class="chip ${state}" data-testid="decided-chip">${chipLabel(state, hasCurrentValue)}</span>
+          <span class="chip ${state}" data-testid="decided-chip">${chipLabel(state, hasCurrentValue, conflict ? proposedCandidates.length : undefined)}</span>
           <button class="undo" type="button" data-testid="undo-decision" data-item-name="${escapeHtml(item.metadata.name)}">Change</button>
         </div>
         ${renderAuditDetails(item, current, proposed, session, presentationAdapter)}
@@ -685,6 +720,24 @@ function renderFieldCard(item, session, presentationAdapter) {
     </section>
   `;
 }
+/**
+ * The card body for an item whose candidate set holds several proposed values.
+ * Lists every value with its excerpt; the workbench records a decision against
+ * a role, so it cannot pick one of them, and says what the reviewer can do.
+ */
+function renderConflictingProposals(item, candidates, presentationAdapter, targetLabel) {
+    const values = candidates.map((candidate) => {
+        const text = buildReviewCandidatePresentation(item, candidate, presentationAdapter, targetLabel).valueText;
+        const excerpt = candidate.locator?.excerpt;
+        return `<li data-testid="conflicting-value"><span class="vtext">${escapeHtml(text)}</span>${excerpt ? ` <q>${escapeHtml(excerpt)}</q>` : ""}</li>`;
+    }).join("");
+    return `
+    <div class="field-value" data-testid="conflicting-proposals">
+      <p>${candidates.length} different values were proposed for this field. This queue cannot choose one of them yet: reject them all, or mark the field Could not confirm with a reason.</p>
+      <ul>${values}</ul>
+    </div>
+  `;
+}
 /**
  * Renders the Current → Proposed diff row. The proposed side is editable
  * (via {@link renderProposedValueEditor}) until the field has a decision.
@@ -1165,7 +1218,7 @@ function createReviewWorkbenchController(root, startState, options) {
         const session = sessionForEvent;
         const item = itemName ? session.items.find((entry) => entry.metadata.name === itemName) : undefined;
         const decision = itemName ? session.decisionsByItemName[itemName] : undefined;
-        const candidate = item && decision ? candidateForDecision(item, decision) : undefined;
+        const candidateId = item && decision ? decisionCandidateId(item, decision) : undefined;
         const definition = decision ? workbenchDecisionDefinitions[decision] : undefined;
         const note = itemName ? session.notesByItemName[itemName] : undefined;
         // Carry the reviewer's inline edit in the event (accept-proposed only), so
@@ -1188,7 +1241,7 @@ function createReviewWorkbenchController(root, startState, options) {
             occurredAt: session.reviewedAt,
             reviewItemName: itemName,
             reviewDecisionName: item && decision ? `${item.metadata.name}-${decision}` : undefined,
-            candidateId: candidate?.id,
+            candidateId,
             status: definition?.status,
             ...(decision === "could-not-confirm"
                 ? {

package/dist/src/review-workbench/review-workbench.standalone.css

@@ -39,6 +39,8 @@
 .inspector-heading h2 { margin: 0; }
 .inspector-posture { display: flex; flex-direction: column; padding: .75rem; border-radius: var(--k-radius-sm); background: var(--k-positive-wash); }
 .inspector-posture.digest-mismatch, .inspector-posture.artifact-unavailable, .inspector-posture.excerpt-mismatch { background: var(--k-negative-wash); color: var(--k-negative); border: 2px solid currentColor; }
+.inspector-posture.extraction-failed { background: var(--k-negative-wash); color: var(--k-negative); border: 2px solid currentColor; }
+.inspector-posture.extraction-incomplete { background: var(--k-caution-wash); color: var(--k-caution); border: 2px solid currentColor; }
 .inspector-filters { display: flex; flex-wrap: wrap; gap: .6rem; margin: 1rem 0; }
 .inspector-filters label { display: grid; gap: .25rem; font-size: .75rem; color: var(--k-text-muted); }
 .inspector-filters select, .inspector-filters input { color: var(--k-text); background: var(--k-sunken); border: 1px solid var(--k-line); padding: .4rem; }

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.js

@@ -44,6 +44,10 @@ 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");
@@ -220,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;
@@ -504,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) {

package/dist/src/types.d.ts

@@ -28,7 +28,11 @@ export interface Extraction {
     extractedAt: string;
     metadata?: Record<string, unknown>;
 }
-export type CandidateSetStatus = "resolved" | "needs-review" | "conflict" | "escalated";
+/**
+ * `rejected`: a review rejected every candidate in the set and selected none
+ * (for example rejecting all conflicting values for one claim).
+ */
+export type CandidateSetStatus = "resolved" | "needs-review" | "conflict" | "escalated" | "rejected";
 export type EscalationDimension = "framing" | "completeness" | "conclusion" | "citation";
 export interface Candidate {
     id: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kontourai/survey",
-  "version": "4.0.0",
+  "version": "5.0.0",
   "description": "Producer-side source, extraction, candidate, and review contracts for projecting verified claims into Surface.",
   "license": "Apache-2.0",
   "type": "module",