@kontourai/survey 6.1.0 → 7.0.0

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

@@ -57,6 +57,14 @@ export interface ReviewItemPresentation {
      * disproven: every decision surface shows them. Empty for other items.
      */
     readonly excludedProposals: readonly ExcludedProposalPresentation[];
+    /**
+     * Stored `excludedProposals` entries that {@link excludedProposals} cannot
+     * show: malformed entries, or every entry of an item whose envelope binding
+     * is not intact. Hiding a rival is the unsafe direction, so every surface
+     * that shows excluded proposals shows this notice too. Absent when every
+     * stored entry is shown.
+     */
+    readonly excludedProposalsUnreadable?: ExcludedProposalsUnreadable;
     /**
      * For an envelope-imported item, whether its import checked excerpts
      * against the prepared artifact. Absent for other items, and for an item
@@ -71,6 +79,16 @@ export interface ExcludedProposalPresentation {
     readonly locator: string;
     readonly excerpt: string;
 }
+export interface ExcludedProposalsUnreadable {
+    /**
+     * `malformed-entries`: some stored entries are not well-formed.
+     * `binding-broken`: the item's extraction binding is not intact, so none of
+     * its stored entries can be vouched for.
+     */
+    readonly reason: "malformed-entries" | "binding-broken";
+    /** How many stored entries are not shown; absent when the stored field is not a list. */
+    readonly count?: number;
+}
 export interface ReviewResultPresentation {
     readonly result: ReviewWorkbenchResult;
     readonly item?: ReviewItem;
@@ -131,6 +149,11 @@ export declare function buildInterpretationReadingPresentation(source: Interpret
  * text (the MCP item, the recorded decision prompt). Undefined when none.
  */
 export declare function excludedProposalsSentence(excluded: readonly ExcludedProposalPresentation[]): string | undefined;
+/**
+ * One sentence saying that stored excluded proposals cannot be shown, for
+ * every surface that shows excluded proposals. Undefined when none are hidden.
+ */
+export declare function excludedProposalsUnreadableSentence(unreadable: ExcludedProposalsUnreadable | undefined): string | undefined;
 export interface CandidateVerificationRecordPresentation {
     readonly recordId: string;
     readonly verifierId: string;

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

@@ -69,20 +69,39 @@ function extractionEnvelopeBinding(item) {
     });
     return bound ? binding : undefined;
 }
-/** The well-formed `excludedProposals` entries of a bound envelope item; malformed entries are ignored, never rendered. */
+/**
+ * The well-formed `excludedProposals` entries of a bound envelope item, and
+ * what the item stores but cannot show: malformed entries, or every entry
+ * when the binding is not intact. Nothing stored is dropped silently.
+ */
 function excludedProposalsOf(item, binding, adapter) {
-    if (!binding || !Array.isArray(binding.excludedProposals))
-        return [];
-    return binding.excludedProposals.flatMap((entry) => {
+    const metadata = item.metadata?.producer?.[EXTRACTION_ENVELOPE_PRODUCER];
+    if (!metadata || typeof metadata !== "object" || Array.isArray(metadata)) {
+        // Candidates that still carry the envelope binding came from an import,
+        // whose item metadata is gone or replaced: what it stored is unknown.
+        const candidatesBound = item.spec.candidates.some((candidate) => candidate.producer?.[EXTRACTION_ENVELOPE_PRODUCER] !== undefined);
+        return candidatesBound ? { excludedProposals: [], excludedProposalsUnreadable: { reason: "binding-broken" } } : { excludedProposals: [] };
+    }
+    const stored = metadata.excludedProposals;
+    if (stored === undefined)
+        return { excludedProposals: [] };
+    const count = Array.isArray(stored) ? stored.length : undefined;
+    if (!binding)
+        return count === 0 ? { excludedProposals: [] } : { excludedProposals: [], excludedProposalsUnreadable: { reason: "binding-broken", ...(count !== undefined ? { count } : {}) } };
+    if (!Array.isArray(stored))
+        return { excludedProposals: [], excludedProposalsUnreadable: { reason: "malformed-entries" } };
+    const proposed = item.spec.candidates.find((candidate) => candidate.role === "proposed");
+    const excludedProposals = stored.flatMap((entry) => {
         if (!entry || typeof entry !== "object" || Array.isArray(entry))
             return [];
         const e = entry;
         if (!Number.isSafeInteger(e.proposalIndex) || typeof e.locator !== "string" || typeof e.excerpt !== "string" || !("value" in e))
             return [];
-        const proposed = item.spec.candidates.find((candidate) => candidate.role === "proposed");
         const valueText = (proposed ? adapter.summarizeValue?.(e.value, { item, candidate: proposed, value: e.value }) : undefined) ?? formatValue(e.value);
         return [{ proposalIndex: e.proposalIndex, value: e.value, valueText, locator: e.locator, excerpt: e.excerpt }];
     });
+    const unreadable = stored.length - excludedProposals.length;
+    return { excludedProposals, ...(unreadable > 0 ? { excludedProposalsUnreadable: { reason: "malformed-entries", count: unreadable } } : {}) };
 }
 /**
  * One sentence naming every excluded proposal, for surfaces that speak in
@@ -94,6 +113,20 @@ export function excludedProposalsSentence(excluded) {
     const named = excluded.map((entry) => `${entry.valueText} (proposal ${entry.proposalIndex}, ${entry.locator})`).join(", ");
     return `${excluded.length === 1 ? "Another proposed value was" : `${excluded.length} other proposed values were`} excluded at import because the source text at the cited span is not the excerpt: ${named}. Unverifiable is not disproven.`;
 }
+/**
+ * One sentence saying that stored excluded proposals cannot be shown, for
+ * every surface that shows excluded proposals. Undefined when none are hidden.
+ */
+export function excludedProposalsUnreadableSentence(unreadable) {
+    if (!unreadable)
+        return undefined;
+    const { count } = unreadable;
+    const entries = count === undefined ? "Stored excluded proposals are" : `${count} stored excluded ${count === 1 ? "entry is" : "entries are"}`;
+    const why = unreadable.reason === "binding-broken"
+        ? "not shown because this item's extraction binding is broken"
+        : "unreadable and not shown";
+    return `${entries} ${why}. Another value may have been proposed for this field.`;
+}
 const VERIFICATION_RESULT_TEXT = {
     supported: "supported",
     contradicted: "contradicted",
@@ -167,7 +200,7 @@ export function buildReviewItemPresentation(item, adapter = {}) {
 function extractionPresentation(item, adapter) {
     const binding = extractionEnvelopeBinding(item);
     return {
-        excludedProposals: excludedProposalsOf(item, binding, adapter),
+        ...excludedProposalsOf(item, binding, adapter),
         ...(binding ? { excerptVerification: binding.excerptVerification === "verified" ? "verified" : "unverified" } : {}),
     };
 }
@@ -224,12 +257,20 @@ export function buildReviewResultPresentation(result, item, adapter = {}) {
         selectedValueText: selectedCandidate && item
             ? buildReviewCandidatePresentation(item, selectedCandidate, adapter, targetLabel).valueText
             : result.selectedDisplayValue,
-        applyMeaning: result.selectedCandidateRole === "proposed"
-            ? "Saved decision applies proposed value"
-            : "Saved decision keeps current value",
+        applyMeaning: result.decision === "select-proposed"
+            ? "Saved decision applies the chosen value; the other proposed values were seen and not chosen"
+            : result.selectedCandidateRole === "proposed"
+                ? "Saved decision applies proposed value"
+                : "Saved decision keeps current value",
         reviewItemLink: item && itemContext ? adapter.linkForReviewItem?.(item, itemContext) : undefined,
         traceRefs: item
-            ? traceRefsForResult(item, result, selectedCandidate, adapter)
+            ? [
+                ...traceRefsForResult(item, result, selectedCandidate, adapter),
+                // A choice between conflicting values names the values it passed over.
+                ...(result.decision === "select-proposed"
+                    ? result.unselectedCandidates.filter((candidate) => candidate.role === "proposed").flatMap((candidate) => withTraceLinks([{ label: "Not chosen candidate", value: candidate.id, kind: "candidate" }], { item, candidate }, adapter))
+                    : []),
+            ]
             : [{ label: "Survey ReviewItem", value: result.reviewItemName, kind: "review-item" }],
     };
 }

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

@@ -1,5 +1,15 @@
 import { type ReviewCandidate, type ReviewItem, type ReviewSession, type ReviewSessionEvent, type ReviewSessionEventSpec } from "../../src/review-resource.js";
-export type ReviewWorkbenchDecision = "accept-proposed" | "keep-current" | "reject-proposed" | "could-not-confirm";
+/**
+ * The decisions a reviewer can record on a ReviewItem.
+ *
+ * `select-proposed` chooses one value of a conflict (two or more `proposed`
+ * candidates) by candidate id, which the state carries beside the decision
+ * (`selectedCandidateId` / `selectedCandidateIdsByItemName`). It is its own
+ * kind rather than `accept-proposed` with an id so that the record always says
+ * a rival was seen and not chosen, and `accept-proposed` keeps its meaning:
+ * accept the one proposed value, refused on a conflict.
+ */
+export type ReviewWorkbenchDecision = "accept-proposed" | "select-proposed" | "keep-current" | "reject-proposed" | "could-not-confirm";
 export type ReviewQueueRowStatus = "pending" | "in-review" | "resolved" | "rejected" | "could-not-confirm" | "escalated";
 export declare const reviewWorkbenchSessionStorageKey = "kontourai.survey.review-workbench.session-events.v1";
 export declare const defaultReviewSessionName = "review-workbench-session";
@@ -16,6 +26,11 @@ export interface ReviewWorkbenchState {
      */
     readonly editedValue?: unknown;
     readonly attemptEvidenceIds?: readonly string[];
+    /**
+     * The candidate a `select-proposed` decision chose. Required for that
+     * decision and ignored for every other one.
+     */
+    readonly selectedCandidateId?: string;
 }
 export interface ReviewQueueSessionState {
     readonly items: readonly ReviewItem[];
@@ -32,6 +47,12 @@ export interface ReviewQueueSessionState {
      */
     readonly editedValuesByItemName?: Readonly<Record<string, unknown>>;
     readonly attemptEvidenceIdsByItemName?: Readonly<Record<string, readonly string[]>>;
+    /**
+     * The candidate each `select-proposed` decision chose, keyed by ReviewItem
+     * name. Additive/optional: sessions stored before this field existed have no
+     * `select-proposed` decision and never read it.
+     */
+    readonly selectedCandidateIdsByItemName?: Readonly<Record<string, string>>;
 }
 export interface ReviewSessionSummary {
     readonly accepted: number;
@@ -48,6 +69,12 @@ export declare const workbenchDecisionDefinitions: {
         candidateRole: "proposed";
         status: "verified";
     };
+    "select-proposed": {
+        label: string;
+        effect: string;
+        candidateRole: "proposed";
+        status: "verified";
+    };
     "keep-current": {
         label: string;
         effect: string;
@@ -109,14 +136,30 @@ export declare function keepActionDecision(item: ReviewItem, flaggedWrong: boole
  * {@link decisionCandidateId} is `undefined` for it, so the decision, its
  * session events and the canonical projection name no candidate.
  */
-export declare function candidateForDecision(item: ReviewItem, decision: ReviewWorkbenchDecision): ReviewCandidate;
+export declare function candidateForDecision(item: ReviewItem, decision: ReviewWorkbenchDecision, selectedCandidateId?: string): ReviewCandidate;
+/**
+ * Why a `select-proposed` decision naming `candidateId` cannot be recorded on
+ * this item, or `undefined` when it can.
+ *
+ * The choice must name, by a unique id, one of the item's `proposed`
+ * candidates, and the item must hold at least two of them: choosing "over a
+ * rival" on an item with no rival would record a conflict that never existed
+ * (use `accept-proposed` there). Proposals excluded at import are not
+ * candidates, so they can never be chosen.
+ */
+export declare function conflictSelectionIssue(item: ReviewItem, candidateId: string | undefined): string | undefined;
+/**
+ * The proposed candidates a `select-proposed` decision saw and did not choose,
+ * in item order. Empty for every other decision.
+ */
+export declare function unchosenProposedCandidates(item: ReviewItem, decision: ReviewWorkbenchDecision, selectedCandidateId: string | undefined): ReviewCandidate[];
 /** Whether a decision on this item selects no candidate at all (see {@link candidateForDecision}). */
 export declare function decisionSelectsNoCandidate(item: ReviewItem, decision: ReviewWorkbenchDecision): boolean;
 /**
  * The candidate id a decision records: the selected candidate's, or
  * `undefined` when the decision selects no candidate.
  */
-export declare function decisionCandidateId(item: ReviewItem, decision: ReviewWorkbenchDecision): string | undefined;
+export declare function decisionCandidateId(item: ReviewItem, decision: ReviewWorkbenchDecision, selectedCandidateId?: string): string | undefined;
 /**
  * The value that should actually be applied for a decision: the reviewer's inline
  * edit when one was made for an accept-proposed decision, otherwise the selected
@@ -125,7 +168,7 @@ export declare function decisionCandidateId(item: ReviewItem, decision: ReviewWo
  * this rule; this helper exists for callers deriving the value from raw session
  * state directly.
  */
-export declare function effectiveValueForDecision(item: ReviewItem, decision: ReviewWorkbenchDecision, editedValue?: unknown): unknown;
+export declare function effectiveValueForDecision(item: ReviewItem, decision: ReviewWorkbenchDecision, editedValue?: unknown, selectedCandidateId?: string): unknown;
 export declare function selectedCandidateRole(state: ReviewWorkbenchState): ReviewCandidate["role"] | undefined;
 export declare function buildReviewSessionResource(session: ReviewQueueSessionState, events?: readonly ReviewSessionEvent[], sessionName?: string): ReviewSession;
 export declare function buildReviewSessionEvents(session: ReviewQueueSessionState, sessionName?: string): ReviewSessionEvent[];

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

@@ -11,6 +11,12 @@ export const workbenchDecisionDefinitions = {
         candidateRole: "proposed",
         status: "verified",
     },
+    "select-proposed": {
+        label: "Use this value",
+        effect: "The chosen value becomes the verified review outcome; the other proposed values were seen and not chosen.",
+        candidateRole: "proposed",
+        status: "verified",
+    },
     "keep-current": {
         label: "Keep current",
         effect: "Current value remains the verified review outcome.",
@@ -58,6 +64,7 @@ export function currentReviewWorkbenchState(session) {
         decision: session.decisionsByItemName[item.metadata.name],
         editedValue: session.editedValuesByItemName?.[item.metadata.name],
         attemptEvidenceIds: session.attemptEvidenceIdsByItemName?.[item.metadata.name],
+        selectedCandidateId: session.selectedCandidateIdsByItemName?.[item.metadata.name],
         reviewedAt: session.reviewedAt,
         actorId: session.actorId,
     };
@@ -77,7 +84,7 @@ export function deriveQueueRowStatus(item, session) {
     if (decision === "could-not-confirm") {
         return "could-not-confirm";
     }
-    if (decision === "accept-proposed" || decision === "keep-current" || item.spec.candidateSetStatus === "resolved") {
+    if (decision === "accept-proposed" || decision === "select-proposed" || decision === "keep-current" || item.spec.candidateSetStatus === "resolved") {
         return "resolved";
     }
     if (item.spec.candidateSetStatus === "escalated") {
@@ -99,7 +106,7 @@ export function nextUnresolvedItemName(session) {
 export function reviewSessionSummary(session) {
     return session.items.reduce((summary, item) => {
         const decision = session.decisionsByItemName[item.metadata.name];
-        if (decision === "accept-proposed") {
+        if (decision === "accept-proposed" || decision === "select-proposed") {
             return { ...summary, accepted: summary.accepted + 1 };
         }
         if (decision === "keep-current") {
@@ -176,7 +183,14 @@ const VALUE_NEUTRAL_DECISIONS = new Set(["reject-proposed", "could-not-confirm"]
  * {@link decisionCandidateId} is `undefined` for it, so the decision, its
  * session events and the canonical projection name no candidate.
  */
-export function candidateForDecision(item, decision) {
+export function candidateForDecision(item, decision, selectedCandidateId) {
+    if (decision === "select-proposed") {
+        const issue = conflictSelectionIssue(item, selectedCandidateId);
+        if (issue) {
+            throw new Error(issue);
+        }
+        return item.spec.candidates.find((entry) => entry.id === selectedCandidateId);
+    }
     const definition = workbenchDecisionDefinitions[decision];
     const matches = item.spec.candidates.filter((entry) => entry.role === definition.candidateRole);
     const candidate = matches[0];
@@ -189,6 +203,45 @@ export function candidateForDecision(item, decision) {
     assertSoleCandidateId(item, candidate.id);
     return candidate;
 }
+/**
+ * Why a `select-proposed` decision naming `candidateId` cannot be recorded on
+ * this item, or `undefined` when it can.
+ *
+ * The choice must name, by a unique id, one of the item's `proposed`
+ * candidates, and the item must hold at least two of them: choosing "over a
+ * rival" on an item with no rival would record a conflict that never existed
+ * (use `accept-proposed` there). Proposals excluded at import are not
+ * candidates, so they can never be chosen.
+ */
+export function conflictSelectionIssue(item, candidateId) {
+    const proposed = item.spec.candidates.filter((entry) => entry.role === "proposed");
+    if (proposed.length < 2) {
+        return `ReviewItem ${item.metadata.name} has ${proposed.length} proposed candidate${proposed.length === 1 ? "" : "s"}; select-proposed chooses between conflicting proposed values, so it needs at least two.`;
+    }
+    if (!candidateId) {
+        return `ReviewItem ${item.metadata.name}: select-proposed must name the chosen candidate id.`;
+    }
+    const matches = item.spec.candidates.filter((entry) => entry.id === candidateId);
+    if (matches.length === 0) {
+        return `ReviewItem ${item.metadata.name} has no candidate ${candidateId}; select-proposed can only choose one of its proposed candidates.`;
+    }
+    if (matches.length > 1) {
+        return `ReviewItem ${item.metadata.name} has ${matches.length} candidates with id ${candidateId}; candidate ids must be unique.`;
+    }
+    if (matches[0].role !== "proposed") {
+        return `ReviewItem ${item.metadata.name} candidate ${candidateId} has role ${matches[0].role ?? "none"}; select-proposed can only choose a proposed candidate.`;
+    }
+    return undefined;
+}
+/**
+ * The proposed candidates a `select-proposed` decision saw and did not choose,
+ * in item order. Empty for every other decision.
+ */
+export function unchosenProposedCandidates(item, decision, selectedCandidateId) {
+    return decision === "select-proposed"
+        ? item.spec.candidates.filter((entry) => entry.role === "proposed" && entry.id !== selectedCandidateId)
+        : [];
+}
 /** Whether a decision on this item selects no candidate at all (see {@link candidateForDecision}). */
 export function decisionSelectsNoCandidate(item, decision) {
     const role = workbenchDecisionDefinitions[decision].candidateRole;
@@ -198,8 +251,8 @@ export function decisionSelectsNoCandidate(item, decision) {
  * The candidate id a decision records: the selected candidate's, or
  * `undefined` when the decision selects no candidate.
  */
-export function decisionCandidateId(item, decision) {
-    const candidate = candidateForDecision(item, decision);
+export function decisionCandidateId(item, decision, selectedCandidateId) {
+    const candidate = candidateForDecision(item, decision, selectedCandidateId);
     return decisionSelectsNoCandidate(item, decision) ? undefined : candidate.id;
 }
 /**
@@ -210,8 +263,8 @@ export function decisionCandidateId(item, decision) {
  * this rule; this helper exists for callers deriving the value from raw session
  * state directly.
  */
-export function effectiveValueForDecision(item, decision, editedValue) {
-    const candidate = candidateForDecision(item, decision);
+export function effectiveValueForDecision(item, decision, editedValue, selectedCandidateId) {
+    const candidate = candidateForDecision(item, decision, selectedCandidateId);
     return decision === "accept-proposed" && editedValue !== undefined ? editedValue : candidate.value;
 }
 export function selectedCandidateRole(state) {
@@ -287,7 +340,7 @@ export function buildReviewSessionEvents(session, sessionName = defaultReviewSes
         if (decision === "could-not-confirm" && !note?.trim()) {
             throw new Error(`ReviewItem ${item.metadata.name} could not confirm requires a non-empty reason.`);
         }
-        const candidateId = decisionCandidateId(item, decision);
+        const candidateId = decisionCandidateId(item, decision, session.selectedCandidateIdsByItemName?.[item.metadata.name]);
         const definition = workbenchDecisionDefinitions[decision];
         const reviewDecisionName = `${item.metadata.name}-${decision}`;
         // Carry the reviewer's inline edit in the event itself (accept-proposed
@@ -383,11 +436,13 @@ export function replayReviewSessionEvents(startState, events) {
                 const { [itemName]: _removedDecision, ...remainingDecisions } = session.decisionsByItemName;
                 const { [itemName]: _removedEdit, ...remainingEdits } = session.editedValuesByItemName ?? {};
                 const { [itemName]: _removedAttempts, ...remainingAttempts } = session.attemptEvidenceIdsByItemName ?? {};
+                const { [itemName]: _removedSelection, ...remainingSelections } = session.selectedCandidateIdsByItemName ?? {};
                 return {
                     ...session,
                     decisionsByItemName: remainingDecisions,
                     editedValuesByItemName: remainingEdits,
                     attemptEvidenceIdsByItemName: remainingAttempts,
+                    ...(session.selectedCandidateIdsByItemName ? { selectedCandidateIdsByItemName: remainingSelections } : {}),
                 };
             }
             const decision = workbenchDecisionFromEvent(event);
@@ -419,6 +474,15 @@ export function replayReviewSessionEvents(startState, events) {
             else {
                 delete attemptEvidenceIdsByItemName[itemName];
             }
+            // A choice between conflicting values is the event's candidateId: that
+            // id is the authority for select-proposed (validated replay checks it).
+            const selectedCandidateIdsByItemName = { ...session.selectedCandidateIdsByItemName };
+            if (decision === "select-proposed" && event.spec.candidateId) {
+                selectedCandidateIdsByItemName[itemName] = event.spec.candidateId;
+            }
+            else {
+                delete selectedCandidateIdsByItemName[itemName];
+            }
             return {
                 ...session,
                 decisionsByItemName: {
@@ -427,6 +491,7 @@ export function replayReviewSessionEvents(startState, events) {
                 },
                 editedValuesByItemName,
                 attemptEvidenceIdsByItemName,
+                ...(session.selectedCandidateIdsByItemName || decision === "select-proposed" ? { selectedCandidateIdsByItemName } : {}),
             };
         }
         return session;

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

@@ -1,6 +1,6 @@
 import type { ReviewSessionEvent } from "../review-resource.js";
 import { type ReviewQueueSessionState } from "./review-queue-session.js";
-export type ReviewSessionReplayIssueCode = "invalid-sequence" | "duplicate-sequence" | "non-contiguous-sequence" | "unknown-active-item" | "unknown-review-item" | "unknown-candidate" | "missing-review-item" | "invalid-workbench-decision" | "decision-candidate-mismatch" | "decision-status-mismatch" | "decision-resolution-mismatch" | "missing-resolution-reason" | "edited-value-not-editable" | "edited-value-type-mismatch";
+export type ReviewSessionReplayIssueCode = "invalid-sequence" | "duplicate-sequence" | "non-contiguous-sequence" | "unknown-active-item" | "unknown-review-item" | "unknown-candidate" | "missing-review-item" | "invalid-workbench-decision" | "decision-candidate-mismatch" | "invalid-conflict-selection" | "decision-status-mismatch" | "decision-resolution-mismatch" | "missing-resolution-reason" | "edited-value-not-editable" | "edited-value-type-mismatch";
 export interface ReviewSessionReplayIssue {
     readonly code: ReviewSessionReplayIssueCode;
     readonly eventName: string;
@@ -37,6 +37,16 @@ export type ReviewSessionReplayWarning = {
     readonly refusedCode: "edited-value-not-editable" | "edited-value-type-mismatch";
     readonly editedValue: unknown;
     readonly message: string;
+} | {
+    /**
+     * The session's items came from an extraction import, but the apply
+     * boundary was not given the import record to check them against (see
+     * `DeriveServerReviewSessionApplyResultOptions.extractionImport`). Emitted
+     * by the server apply boundary, never by replay itself.
+     */
+    readonly code: "unverified-extraction-queue";
+    readonly itemNames: readonly string[];
+    readonly message: string;
 };
 /**
  * Lists the legacy text edits replay converts to typed values, and refused

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

@@ -1,4 +1,4 @@
-import { candidateForDecision, decisionSelectsNoCandidate, isClearedWorkbenchDecisionEvent, workbenchDecisionDefinitions, } from "./review-queue-session.js";
+import { candidateForDecision, conflictSelectionIssue, decisionSelectsNoCandidate, isClearedWorkbenchDecisionEvent, workbenchDecisionDefinitions, } from "./review-queue-session.js";
 import { checkEditedValueForItem } from "./edited-value.js";
 export function validateReviewSessionEventsForSnapshot(snapshot, events) {
     const itemsByName = new Map(snapshot.items.map((item) => [item.metadata.name, item]));
@@ -53,6 +53,40 @@ export function validateReviewSessionEventsForSnapshot(snapshot, events) {
                     message: `ReviewSessionEvent ${event.metadata.name} is a decision event but does not include a replayable workbench decision.`,
                 });
             }
+            else if (itemName && itemsByName.has(itemName) && decision === "select-proposed") {
+                // The event's candidateId is the choice; it must name one proposed
+                // candidate of an item that holds a conflict.
+                const item = itemsByName.get(itemName);
+                const selectionIssue = conflictSelectionIssue(item, event.spec.candidateId);
+                if (selectionIssue) {
+                    issues.push({
+                        ...eventRef,
+                        code: "invalid-conflict-selection",
+                        reviewItemName: itemName,
+                        candidateId: event.spec.candidateId,
+                        message: `ReviewSessionEvent ${event.metadata.name}: ${selectionIssue}`,
+                    });
+                }
+                const expectedStatus = workbenchDecisionDefinitions[decision].status;
+                if (event.spec.status !== expectedStatus) {
+                    issues.push({
+                        ...eventRef,
+                        code: "decision-status-mismatch",
+                        reviewItemName: itemName,
+                        candidateId: event.spec.candidateId,
+                        message: `ReviewSessionEvent ${event.metadata.name} decision ${decision} expects status ${expectedStatus}, but references ${event.spec.status ?? "no status"}.`,
+                    });
+                }
+                if (event.spec.resolution !== undefined) {
+                    issues.push({
+                        ...eventRef,
+                        code: "decision-resolution-mismatch",
+                        reviewItemName: itemName,
+                        candidateId: event.spec.candidateId,
+                        message: `ReviewSessionEvent ${event.metadata.name} decision ${decision} expects resolution none, but references ${event.spec.resolution}.`,
+                    });
+                }
+            }
             else if (itemName && itemsByName.has(itemName)) {
                 const item = itemsByName.get(itemName);
                 const expectedCandidate = item ? candidateForDecision(item, decision) : undefined;

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

@@ -835,6 +835,100 @@ export const REVIEW_WORKBENCH_CSS = `/* Bundled, scoped Survey Review Workbench
   font-size: 12px;
 }
 
+/* A queue that came from an extraction import but was not checked against
+   it (unverified), or that does not match it (diverges, shown instead of the
+   queue). */
+.survey-workbench-embed .queue-attestation{
+  display: flex;
+  align-items: flex-start;
+  gap: var(--k-space-2);
+  margin: 0 0 var(--k-space-3);
+  padding: var(--k-space-2) var(--k-space-3);
+  border-radius: 9px;
+  font-size: 13px;
+  line-height: 1.45;
+  color: var(--k-caution);
+  background: var(--k-caution-wash);
+}
+
+.survey-workbench-embed .queue-attestation svg{
+  flex: none;
+  margin-top: 2px;
+}
+
+.survey-workbench-embed .queue-attestation.diverges{
+  color: var(--k-negative);
+  background: var(--k-negative-wash);
+}
+
+/* Conflicting proposed values: each value is listed with its own choice
+   control until the field is decided, then marked chosen or not chosen. */
+.survey-workbench-embed .conflict-values ul{
+  list-style: none;
+  margin: var(--k-space-2) 0 0;
+  padding: 0;
+  display: grid;
+  gap: var(--k-space-2);
+}
+
+.survey-workbench-embed .conflict-values li{
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: var(--k-space-3);
+  flex-wrap: wrap;
+  padding: var(--k-space-2) var(--k-space-3);
+  border: 1px solid var(--k-line);
+  border-radius: 9px;
+}
+
+.survey-workbench-embed .conflict-values li[data-chosen="true"]{
+  border-color: var(--k-positive);
+  background: var(--k-positive-wash);
+}
+
+.survey-workbench-embed .conflict-values .conflict-text{
+  display: inline-flex;
+  align-items: baseline;
+  gap: var(--k-space-2);
+  flex-wrap: wrap;
+  min-width: 0;
+}
+
+.survey-workbench-embed .conflict-values .vtext{
+  font-weight: 600;
+  overflow-wrap: anywhere;
+}
+
+.survey-workbench-embed .conflict-values q{
+  color: var(--k-muted);
+  font-size: 12.5px;
+  overflow-wrap: anywhere;
+}
+
+.survey-workbench-embed .conflict-values .btn.choose{
+  min-height: 36px;
+  padding: 0 14px;
+  font-size: 13px;
+}
+
+.survey-workbench-embed .choice-tag{
+  font-size: 12px;
+  font-weight: 600;
+  padding: 2px 8px;
+  border-radius: 999px;
+}
+
+.survey-workbench-embed .choice-tag.chosen{
+  color: var(--k-positive);
+  background: var(--k-positive-wash);
+}
+
+.survey-workbench-embed .choice-tag.not-chosen{
+  color: var(--k-muted);
+  background: var(--k-sunken);
+}
+
 .survey-workbench-embed .excerpt-verification,
 .survey-workbench-embed .support-verification{
   margin: 0;

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

@@ -34,6 +34,7 @@
  */
 import { type ReviewQueueSessionState, type ReviewWorkbenchState } from "./review-workbench.js";
 import type { ReviewPresentationAdapter } from "./review-presentation.js";
+import type { ExtractionEnvelopeImport, ExtractionEnvelopeImportResult } from "../extraction-envelope.js";
 import { type ExtractionInspectorInput } from "./extraction-inspector.js";
 export declare class SurveyReviewWorkbenchElement extends HTMLElement {
     #private;
@@ -45,6 +46,15 @@ export declare class SurveyReviewWorkbenchElement extends HTMLElement {
     /** Optional presentation adapter for custom labels, value summaries, and links. */
     get presentationAdapter(): ReviewPresentationAdapter | undefined;
     set presentationAdapter(value: ReviewPresentationAdapter | undefined);
+    /**
+     * The extraction import record the queue was built from, as stored beside
+     * it. The workbench checks the queue against it (see
+     * `MountReviewWorkbenchOptions.extractionImport`). When unset, the import of
+     * a single-import `extractionInspector` is used; with neither, a queue whose
+     * items came from an extraction import shows an "Unverified queue" notice.
+     */
+    get extractionImport(): ExtractionEnvelopeImport | ExtractionEnvelopeImportResult | null;
+    set extractionImport(value: ExtractionEnvelopeImport | ExtractionEnvelopeImportResult | null | undefined);
     /** Optional read-only source pane attached to this workbench's existing review lifecycle. */
     get extractionInspector(): ExtractionInspectorInput | null;
     set extractionInspector(value: ExtractionInspectorInput | null | undefined);

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

@@ -169,6 +169,7 @@ export class SurveyReviewWorkbenchElement extends HTMLElement {
     #session = null;
     #presentationAdapter = undefined;
     #extractionInspector = null;
+    #extractionImport = null;
     #unmountInspector;
     #root;
     #mountRoot;
@@ -340,6 +341,18 @@ export class SurveyReviewWorkbenchElement extends HTMLElement {
         this.#presentationAdapter = value;
         this.#remount();
     }
+    /**
+     * The extraction import record the queue was built from, as stored beside
+     * it. The workbench checks the queue against it (see
+     * `MountReviewWorkbenchOptions.extractionImport`). When unset, the import of
+     * a single-import `extractionInspector` is used; with neither, a queue whose
+     * items came from an extraction import shows an "Unverified queue" notice.
+     */
+    get extractionImport() { return this.#extractionImport; }
+    set extractionImport(value) {
+        this.#extractionImport = value ?? null;
+        this.#remount();
+    }
     /** Optional read-only source pane attached to this workbench's existing review lifecycle. */
     get extractionInspector() { return this.#extractionInspector; }
     set extractionInspector(value) {
@@ -423,9 +436,14 @@ export class SurveyReviewWorkbenchElement extends HTMLElement {
             this.#renderEmpty();
             return;
         }
-        const options = this.#presentationAdapter
-            ? { presentationAdapter: this.#presentationAdapter }
-            : {};
+        const inspectorImport = this.#extractionInspector && !("imports" in this.#extractionInspector)
+            ? this.#extractionInspector.importResult
+            : undefined;
+        const extractionImport = this.#extractionImport ?? inspectorImport;
+        const options = {
+            ...(this.#presentationAdapter ? { presentationAdapter: this.#presentationAdapter } : {}),
+            ...(extractionImport ? { extractionImport } : {}),
+        };
         this.#applyThemeClasses();
         mountReviewWorkbench(this.#mountRoot, this.#session, options);
         this.#unmountInspector?.();