@kontourai/survey 1.4.0 → 1.5.0

package/dist/src/agent-utterance.d.ts

@@ -96,6 +96,30 @@ export interface UtteranceStatementRecords {
     candidate: Candidate;
     candidateSet: CandidateSet;
 }
+interface BuildUtteranceRecordsParams {
+    sourceId: string;
+    utterance: string;
+    extracted: ExtractedStatement[];
+    extractorName: string;
+    observedAt: string;
+}
+interface UtteranceRecordsResult {
+    records: UtteranceStatementRecords[];
+    extractions: Extraction[];
+    candidateSets: CandidateSet[];
+}
+/**
+ * Build the full set of Survey records for every extracted statement in one
+ * utterance: per-statement Extractions/Candidates plus per-target grouped
+ * Candidate Sets. This is the shared orchestrator both `utteranceToSurveyInput`
+ * and `surveyAgentUtterance` call, so both callers derive these records
+ * identically — Slice 1's "single derivation path" invariant, preserved.
+ *
+ * `records[idx]` corresponds to `extracted[idx]` for every idx — `items` and
+ * `records` are both built via `.map` over the same `extracted[]` array in
+ * the same order; only `candidateSets` is deduped/grouped by target.
+ */
+export declare function buildUtteranceRecords(params: BuildUtteranceRecordsParams): UtteranceRecordsResult;
 /**
  * Project an agent utterance and its extracted statements into the standard
  * SurveyInput shape so they can flow into buildSurveyTrustBundle.
@@ -164,3 +188,4 @@ export declare function surveyAgentUtterance(utterance: string, extractor: Utter
  * alone in this reference implementation.
  */
 export declare const referenceUtteranceExtractor: UtteranceClaimExtractor;
+export {};

package/dist/src/agent-utterance.js

@@ -18,6 +18,177 @@
  */
 import { resolveInquiry } from "@kontourai/surface";
 import { lookupMapping, resolveQuestion } from "./inquiry-mapping.js";
+import { projectProposalsToCandidateSet } from "./producer-profile.js";
+/**
+ * The Candidate Conflict comparison key for an utterance-proposed value.
+ *
+ * Neither extractor (the reference extractor below, nor the Anthropic-backed
+ * one in `./anthropic.js`) normalizes `value` before it reaches
+ * `ExtractedStatement` — case and internal formatting are preserved
+ * verbatim. String values are the only case where "representation noise"
+ * (leading/trailing whitespace from excerpt boundaries, incidental case
+ * differences like "Healthy" vs "healthy") is plausible given the two
+ * extractors' actual output, so this key trims + lowercases STRING values
+ * in the COMPARISON KEY ONLY — the stored `Candidate.value`/`Extraction.value`
+ * stay byte-for-byte verbatim; this function only feeds `equivalenceKey`,
+ * never `value`. Non-string values (number, boolean, null — the other types
+ * the Anthropic tool schema permits) compare via exact canonical
+ * `JSON.stringify`, so there is no cross-type coercion that could silently
+ * equate e.g. "5" and 5, or lose a genuine numeric disagreement (5 vs 6 is
+ * never noise). This mirrors the Producer Profile core's established
+ * pattern: each profile decides its own narrow equivalence definition
+ * (see `./producer-profile.js`); the core itself does not own this decision.
+ */
+function utteranceEquivalenceKey(value) {
+    const normalized = value ?? null;
+    if (typeof normalized === "string") {
+        return `str:${normalized.trim().toLowerCase()}`;
+    }
+    return `json:${JSON.stringify(normalized)}`;
+}
+/**
+ * Build the Extraction and CandidateSetProposal for a single extracted
+ * statement. This centralizes the Source Locator rule (span-first,
+ * excerpt-fallback — the single locator rule this module guarantees) and
+ * hands the resulting proposal off to `groupUtteranceExtractionsByTarget`
+ * for per-target projection through the Producer Profile core.
+ */
+function buildUtteranceExtraction(params) {
+    const { sourceId, idx, statement, utterance, extractorName, observedAt } = params;
+    const statementId = `${sourceId}.statement.${idx}`;
+    const extractionId = `${statementId}.extraction`;
+    const candidateId = `${statementId}.candidate`;
+    // Compute locator — required for non-manual-entry sources
+    // (assertProducerDiscipline throws without it). Source Locator rule:
+    // span-first, excerpt-fallback — UNCHANGED from Slice 1.
+    const locator = spanToLocator(statement.span) ?? excerptLocator(utterance, statement.excerpt);
+    const extraction = {
+        id: extractionId,
+        sourceId,
+        target: canonicalTargetKey(statement.target),
+        value: statement.value ?? null,
+        confidence: statement.confidence,
+        locator,
+        excerpt: statement.excerpt,
+        extractor: extractorName,
+        extractedAt: observedAt,
+        metadata: {
+            agentUtterance: {
+                span: statement.span,
+                excerpt: statement.excerpt,
+                extractorName,
+                confidence: statement.confidence,
+            },
+        },
+    };
+    const proposal = {
+        candidateId,
+        extractionId,
+        value: statement.value ?? null,
+        confidence: statement.confidence,
+        equivalenceKey: utteranceEquivalenceKey(statement.value),
+        metadata: {
+            span: statement.span,
+            excerpt: statement.excerpt,
+            extractorName,
+            confidence: statement.confidence,
+        },
+    };
+    return { extraction, proposal };
+}
+/**
+ * Group extraction/proposal pairs by canonical target and project each
+ * group through the Producer Profile core's `projectProposalsToCandidateSet`
+ * — one Candidate Set per target, carrying every statement's Candidate for
+ * that target. Status is `"conflict"` when the group's statements disagree
+ * under `utteranceEquivalenceKey`, `"needs-review"` otherwise (including the
+ * common single-statement case, which reproduces Slice 1's exact prior
+ * per-statement behavior).
+ *
+ * `Map` preserves insertion order, so the returned groups (and therefore the
+ * `candidateSets` array `buildUtteranceRecords` derives from them) are in
+ * deterministic first-occurrence-of-target order across the utterance's
+ * statements.
+ */
+function groupUtteranceExtractionsByTarget(sourceId, items) {
+    const order = [];
+    const byTarget = new Map();
+    for (const item of items) {
+        const key = canonicalTargetKey(item.statement.target);
+        if (!byTarget.has(key)) {
+            byTarget.set(key, []);
+            order.push(key);
+        }
+        byTarget.get(key).push(item);
+    }
+    const groups = new Map();
+    for (const targetKey of order) {
+        const groupItems = byTarget.get(targetKey);
+        const first = groupItems[0].statement.target;
+        const proposals = groupItems.map((i) => i.proposal);
+        const { candidateSet, candidates } = projectProposalsToCandidateSet(targetKey, proposals, {
+            candidateSetId: `${sourceId}.target.${targetKey}.candidate-set`,
+            candidateSetMetadata: {
+                agentUtterance: {
+                    target: {
+                        subjectType: first.subjectType,
+                        subjectId: first.subjectId,
+                        fieldOrBehavior: first.fieldOrBehavior,
+                    },
+                    statementCount: proposals.length,
+                },
+            },
+            candidateSetRationale: (status, groupProposals) => status === "conflict"
+                ? `${groupProposals.length} statement(s) disagree for ${targetKey}: ${[...new Set(groupProposals.map((p) => p.equivalenceKey))].join(", ")}`
+                : `${groupProposals.length} statement(s) agree for ${targetKey}.`,
+        });
+        // Mirrors schema-mapping's post-core convention: a winner only exists
+        // when the group agrees; a conflicting group has no selected candidate
+        // yet (nothing to select — that's the point of a Candidate Conflict,
+        // CONTEXT.md's "Candidate Conflict" entry). For a single-statement group
+        // this reproduces Slice 1's exact old behavior (selectedCandidateId ===
+        // the one candidate's id).
+        candidateSet.selectedCandidateId = candidateSet.status !== "conflict" ? candidates[0]?.id : undefined;
+        groups.set(targetKey, { targetKey, candidateSet, candidates });
+    }
+    return groups;
+}
+/**
+ * Build the full set of Survey records for every extracted statement in one
+ * utterance: per-statement Extractions/Candidates plus per-target grouped
+ * Candidate Sets. This is the shared orchestrator both `utteranceToSurveyInput`
+ * and `surveyAgentUtterance` call, so both callers derive these records
+ * identically — Slice 1's "single derivation path" invariant, preserved.
+ *
+ * `records[idx]` corresponds to `extracted[idx]` for every idx — `items` and
+ * `records` are both built via `.map` over the same `extracted[]` array in
+ * the same order; only `candidateSets` is deduped/grouped by target.
+ */
+export function buildUtteranceRecords(params) {
+    const { sourceId, utterance, extracted, extractorName, observedAt } = params;
+    const items = extracted.map((statement, idx) => {
+        const { extraction, proposal } = buildUtteranceExtraction({
+            sourceId,
+            idx,
+            statement,
+            utterance,
+            extractorName,
+            observedAt,
+        });
+        return { statement, extraction, proposal };
+    });
+    const groups = groupUtteranceExtractionsByTarget(sourceId, items);
+    const records = items.map((item) => {
+        const group = groups.get(canonicalTargetKey(item.statement.target));
+        const candidate = group.candidates.find((c) => c.id === item.proposal.candidateId);
+        return { extraction: item.extraction, candidate, candidateSet: group.candidateSet };
+    });
+    return {
+        records,
+        extractions: items.map((i) => i.extraction),
+        candidateSets: [...groups.values()].map((g) => g.candidateSet),
+    };
+}
 // ---------------------------------------------------------------------------
 // SurveyInput projection
 // ---------------------------------------------------------------------------
@@ -60,80 +231,35 @@ export function utteranceToSurveyInput(utterance, extracted, context) {
         inlineText: utterance,
         metadata: { agentId },
     };
-    const extractions = [];
-    const candidateSets = [];
-    const claims = [];
-    for (let idx = 0; idx < extracted.length; idx++) {
-        const statement = extracted[idx];
+    // Batched, per-target-grouped provenance construction (Producer Profile
+    // core) — replaces the old per-statement builder call. Claims below stay
+    // one-per-statement; `record.candidateSet.id`/`record.candidate.id` may be
+    // shared across several claims when statements share a target (legal).
+    const { records, extractions, candidateSets } = buildUtteranceRecords({
+        sourceId,
+        utterance,
+        extracted,
+        extractorName,
+        observedAt,
+    });
+    const claims = extracted.map((statement, idx) => {
         const statementId = `${sourceId}.statement.${idx}`;
-        const extractionId = `${statementId}.extraction`;
-        const candidateId = `${statementId}.candidate`;
-        const candidateSetId = `${statementId}.candidate-set`;
         const claimId = `${statementId}.claim`;
-        // Compute locator — required for non-manual-entry sources
-        // (assertProducerDiscipline throws without it)
-        const locator = spanToLocator(statement.span) ?? excerptLocator(utterance, statement.excerpt);
-        const extraction = {
-            id: extractionId,
-            sourceId,
-            target: canonicalTargetKey(statement.target),
-            value: statement.value ?? null,
-            confidence: statement.confidence,
-            locator,
-            excerpt: statement.excerpt,
-            extractor: extractorName,
-            extractedAt: observedAt,
-            metadata: {
-                agentUtterance: {
-                    span: statement.span,
-                    excerpt: statement.excerpt,
-                    extractorName,
-                    confidence: statement.confidence,
-                },
-            },
-        };
-        const candidate = {
-            id: candidateId,
-            extractionId,
-            value: statement.value ?? null,
-            confidence: statement.confidence,
-            metadata: {
-                agentUtterance: {
-                    span: statement.span,
-                    excerpt: statement.excerpt,
-                    extractorName,
-                    confidence: statement.confidence,
-                },
-            },
-        };
-        // needs-review status → statusFor returns "proposed" (no review outcome)
-        const candidateSet = {
-            id: candidateSetId,
-            target: canonicalTargetKey(statement.target),
-            candidates: [candidate],
-            selectedCandidateId: candidateId,
-            status: "needs-review",
-            metadata: {
-                agentUtterance: {
-                    subjectType: statement.target.subjectType,
-                    subjectId: statement.target.subjectId,
-                    fieldOrBehavior: statement.target.fieldOrBehavior,
-                },
-            },
-        };
-        // Unreviewed: status is omitted so statusFor() computes "proposed"
-        // assertProducerDiscipline: no verified/assumed without review → compliant
-        const claimTarget = {
+        const record = records[idx];
+        // Unreviewed: status is omitted so statusFor() computes "proposed" (or
+        // "disputed" for a claim whose shared candidateSet.status is "conflict").
+        // assertProducerDiscipline: no verified/assumed without review → compliant.
+        return {
             id: claimId,
-            candidateSetId,
-            candidateId,
+            candidateSetId: record.candidateSet.id,
+            candidateId: record.candidate.id,
             subjectType: statement.target.subjectType,
             subjectId: statement.target.subjectId,
             facet: "agent-utterance.profile",
             claimType: "agent-extraction",
             fieldOrBehavior: statement.target.fieldOrBehavior,
             value: statement.value,
-            // status intentionally omitted → computed as "proposed" by statusFor
+            // status intentionally omitted → computed by statusFor
             impactLevel: "low",
             collectedBy: extractorName,
             metadata: {
@@ -144,15 +270,12 @@ export function utteranceToSurveyInput(utterance, extracted, context) {
                         excerpt: statement.excerpt,
                         span: statement.span,
                         confidence: statement.confidence,
-                        locator,
+                        locator: record.extraction.locator,
                     },
                 },
             },
         };
-        extractions.push(extraction);
-        candidateSets.push(candidateSet);
-        claims.push(claimTarget);
-    }
+    });
     return {
         source,
         generatedAt: observedAt,
@@ -196,31 +319,22 @@ export async function surveyAgentUtterance(utterance, extractor, context) {
     };
     // Step 2: Extract statements
     const extracted = await Promise.resolve(extractor.extract(utterance));
+    // Batched, grouped provenance construction — kept for provenance/doc-comment
+    // fidelity across the whole utterance (grouping needs every statement of a
+    // target's group present at once; a per-statement call cannot compute it).
+    // Still not surfaced on UtteranceStatement/UtteranceTrustReport this slice
+    // (unchanged from Slice 1's own scoping note) — wiring is left for a future
+    // slice, same as before.
+    buildUtteranceRecords({
+        sourceId,
+        utterance,
+        extracted,
+        extractorName: extractor.name,
+        observedAt,
+    });
     // Step 3 & 4: Resolve each statement and build the report
     const statements = [];
     for (const statement of extracted) {
-        const statementId = `${sourceId}.statement.${statements.length}`;
-        // Build Survey records for provenance
-        const extractionId = `${statementId}.extraction`;
-        const extraction = {
-            id: extractionId,
-            sourceId,
-            target: canonicalTargetKey(statement.target),
-            value: statement.value ?? null,
-            confidence: statement.confidence,
-            locator: statement.span ? `text-span:${statement.span.start}-${statement.span.end}` : undefined,
-            excerpt: statement.excerpt,
-            extractor: extractor.name,
-            extractedAt: observedAt,
-            metadata: {
-                agentUtterance: {
-                    span: statement.span,
-                    excerpt: statement.excerpt,
-                    extractorName: extractor.name,
-                    confidence: statement.confidence,
-                },
-            },
-        };
         // Resolve the claim
         let inquiryRecord;
         if (mappings && mappings.length > 0) {
@@ -253,8 +367,6 @@ export async function surveyAgentUtterance(utterance, extractor, context) {
             inquiryRecord,
             badge,
         });
-        // Suppress unused-variable warning for extraction
-        void extraction;
     }
     return { source, statements };
 }

package/dist/src/console/review-console-server.js

@@ -15,8 +15,8 @@ import { watch } from "node:fs";
 import { readFile as readFileAsync, writeFile as writeFileAsync, rename as renameAsync } from "node:fs/promises";
 import { resolve, join, dirname, extname, normalize, sep } from "node:path";
 import { fileURLToPath } from "node:url";
-import { replayReviewSessionEvents, defaultReviewSessionName, } from "../review-workbench/review-workbench.js";
-import { createServerReviewSessionRecord, deriveServerReviewSessionApplyResult, } from "../review-workbench/server-review-session.js";
+import { defaultReviewSessionName, } from "../review-workbench/review-workbench.js";
+import { createServerReviewSessionRecord, currentSessionState, deriveServerReviewSessionApplyResult, } from "../review-workbench/server-review-session.js";
 // ---------------------------------------------------------------------------
 // Constants
 // ---------------------------------------------------------------------------
@@ -63,10 +63,6 @@ async function writeSessionAtomic(path, content) {
     await writeFileAsync(tmp, JSON.stringify(content, null, 2), "utf8");
     await renameAsync(tmp, path);
 }
-function currentState(content) {
-    const { snapshot, events } = content;
-    return events.length > 0 ? replayReviewSessionEvents(snapshot, events) : snapshot;
-}
 // ---------------------------------------------------------------------------
 // SSE broadcaster
 // ---------------------------------------------------------------------------
@@ -496,7 +492,7 @@ export async function startReviewConsoleServer(options) {
                     session: content.session,
                     snapshot: content.snapshot,
                     events: content.events,
-                    state: currentState(content),
+                    state: currentSessionState(content.snapshot, content.events),
                 });
                 return;
             }

package/dist/src/field-observation.d.ts

@@ -1,20 +1,6 @@
 import type { SurveyObservationInput } from "./builder.js";
-export interface FieldObservationInput<TValue> {
-    id: string;
-    field: string;
-    value: TValue;
-    rawSource: SurveyObservationInput["rawSource"];
-    extraction: Omit<SurveyObservationInput["extraction"], "target" | "value" | "excerpt"> & {
-        target?: string;
-        excerpt?: string | null;
-    };
-    reviewOutcome?: SurveyObservationInput["reviewOutcome"];
-    claim: Omit<SurveyObservationInput["claim"], "fieldOrBehavior" | "value"> & {
-        fieldOrBehavior?: string;
-    };
-    candidate?: SurveyObservationInput["candidate"];
-    candidateSet?: SurveyObservationInput["candidateSet"];
+import { type ObservationAuthoringInput } from "./observation-helper.js";
+export interface FieldObservationInput<TValue> extends ObservationAuthoringInput<TValue> {
     representation?: "scalar";
-    metadata?: Record<string, unknown>;
 }
 export declare function fieldObservation<TValue>(input: FieldObservationInput<TValue>): SurveyObservationInput;

package/dist/src/field-observation.js

@@ -1,16 +1,4 @@
-import { buildObservation } from "./observation-helper.js";
+import { buildFieldObservation } from "./observation-helper.js";
 export function fieldObservation(input) {
-    const representation = input.representation ?? "scalar";
-    return buildObservation({
-        ...input,
-        surveyMetadata: {
-            field: { representation },
-        },
-        defaultExcerpt: `${input.field}: ${valueSummary(input.value)}`,
-    });
-}
-function valueSummary(value) {
-    if (value === null || value === undefined)
-        return "<empty>";
-    return String(value);
+    return buildFieldObservation(input);
 }

package/dist/src/inquiry-mapping.d.ts

@@ -20,6 +20,7 @@
 import type { DerivationRule, InquiryRecord, TrustBundle } from "@kontourai/surface";
 import type { CanonicalClaimTarget } from "@kontourai/surface";
 import type { Candidate, CandidateSet, ReviewOutcome } from "./types.js";
+import type { ReviewItem } from "./review-resource.js";
 /**
  * A single machine- or human-generated suggestion that a natural-language
  * question maps to a canonical claim target or a named derivation rule.
@@ -197,52 +198,7 @@ export declare function resolveQuestion(bundle: TrustBundle, question: string, o
 export declare function buildMappingReviewItems(candidateSets: Array<{
     candidateSet: CandidateSet;
     candidates: Candidate[];
-}>): Array<{
-    apiVersion: "survey.kontourai.io/v1alpha1";
-    kind: "ReviewItem";
-    metadata: {
-        name: string;
-        labels?: Record<string, string>;
-    };
-    spec: {
-        target: string;
-        candidates: Array<{
-            id: string;
-            role: "proposed";
-            value: unknown;
-            confidence?: number;
-            source: {
-                sourceRef: string;
-                kind: "inquiry-question";
-                observedAt: string;
-                locatorScheme: "text";
-            };
-            extraction: {
-                target: string;
-                confidence?: number;
-                extractor: string;
-                extractedAt: string;
-            };
-            claimTarget: {
-                subjectType: string;
-                subjectId: string;
-                facet: string;
-                claimType: string;
-                fieldOrBehavior: string;
-                impactLevel: "low";
-            };
-            projection?: {
-                candidateSetId: string;
-                candidateId: string;
-            };
-        }>;
-        candidateSetStatus: "needs-review" | "conflict";
-        rationale?: string;
-    };
-    status: {
-        observedCandidateCount: number;
-    };
-}>;
+}>): ReviewItem[];
 /**
  * Reference MappingProposer for tests.
  *

package/dist/src/inquiry-mapping.js

@@ -18,6 +18,8 @@
  * and lives in the flow-agents repo.
  */
 import { resolveInquiry } from "@kontourai/surface";
+import { AUTO_ACCEPT_ACTOR, AUTO_ACCEPT_WITHIN_COMFORT_ZONE, getProducerProposal, hasCandidateConflict, meetsAutoAcceptThreshold, projectProposalsToCandidateSet, } from "./producer-profile.js";
+import { reviewResourceApiVersion } from "./review-resource.js";
 // ---------------------------------------------------------------------------
 // Question normalization
 // ---------------------------------------------------------------------------
@@ -42,9 +44,18 @@ export function normalizeQuestion(question) {
         .trim()
         .replace(/[.?!,;]+$/u, "");
 }
-// ---------------------------------------------------------------------------
-// Proposal → CandidateSet projection
-// ---------------------------------------------------------------------------
+/**
+ * The Candidate Conflict comparison key for a single mapping proposal: keys
+ * by canonical claim target (subjectType/subjectId/fieldOrBehavior) or by
+ * derivation rule id. Two proposals with the same key "agree"; more than one
+ * distinct key across a group of proposals is a conflict (see
+ * hasCandidateConflict).
+ */
+function mappingEquivalenceKey(proposal) {
+    return proposal.proposedTarget
+        ? `target:${proposal.proposedTarget.subjectType}/${proposal.proposedTarget.subjectId}/${proposal.proposedTarget.fieldOrBehavior}`
+        : `rule:${proposal.proposedRuleId}`;
+}
 /**
  * Project an array of proposals for a single question into Survey's existing
  * Candidate / CandidateSet shapes so they flow through the existing review
@@ -60,46 +71,33 @@ export function normalizeQuestion(question) {
  */
 export function proposalsToCandidateSet(question, proposals) {
     const normalized = normalizeQuestion(question);
-    const candidates = proposals.map((proposal) => ({
-        id: `mapping-candidate.${proposal.id}`,
+    const candidateSetProposals = proposals.map((proposal) => ({
+        candidateId: `mapping-candidate.${proposal.id}`,
         extractionId: proposal.id,
         value: proposal.proposedTarget ?? proposal.proposedRuleId ?? null,
         confidence: proposal.confidence,
+        equivalenceKey: mappingEquivalenceKey(proposal),
         metadata: {
-            mappingProposal: {
-                proposalId: proposal.id,
-                proposedTarget: proposal.proposedTarget,
-                proposedRuleId: proposal.proposedRuleId,
-                confidence: proposal.confidence,
-                rationale: proposal.rationale,
-                excerpt: proposal.excerpt,
-                proposedBy: proposal.proposedBy,
-                proposedAt: proposal.proposedAt,
-            },
+            proposalId: proposal.id,
+            proposedTarget: proposal.proposedTarget,
+            proposedRuleId: proposal.proposedRuleId,
+            confidence: proposal.confidence,
+            rationale: proposal.rationale,
+            excerpt: proposal.excerpt,
+            proposedBy: proposal.proposedBy,
+            proposedAt: proposal.proposedAt,
         },
     }));
-    // Determine status: conflict if proposals disagree on target/rule
-    const status = proposals.length > 1 && proposalsDisagree(proposals) ? "conflict" : "needs-review";
-    const candidateSet = {
-        id: `mapping-candidate-set.${normalized}`,
-        target: normalized,
-        candidates,
-        status,
-        metadata: {
+    return projectProposalsToCandidateSet(normalized, candidateSetProposals, {
+        candidateSetId: `mapping-candidate-set.${normalized}`,
+        candidateSetMetadata: {
             inquiryMapping: {
                 question,
                 normalizedQuestion: normalized,
                 kind: "inquiry-question",
             },
         },
-    };
-    return { candidateSet, candidates };
-}
-function proposalsDisagree(proposals) {
-    const keys = new Set(proposals.map((p) => p.proposedTarget
-        ? `target:${p.proposedTarget.subjectType}/${p.proposedTarget.subjectId}/${p.proposedTarget.fieldOrBehavior}`
-        : `rule:${p.proposedRuleId}`));
-    return keys.size > 1;
+    });
 }
 // ---------------------------------------------------------------------------
 // Review outcome → InquiryMapping
@@ -119,7 +117,7 @@ export function applyMappingReview(candidateSet, reviewOutcome) {
     if (!candidate) {
         throw new Error(`applyMappingReview: no candidate found for id ${candidateId ?? "<none>"}`);
     }
-    const meta = candidate.metadata?.mappingProposal;
+    const meta = getProducerProposal(candidate);
     const proposalId = meta?.proposalId ?? candidate.extractionId;
     const status = reviewOutcome.status === "verified" || reviewOutcome.status === "assumed" || reviewOutcome.status === "rejected"
         ? reviewOutcome.status
@@ -152,20 +150,20 @@ export function applyAutoAcceptPolicy(proposals, policy) {
     if (proposals.length === 0)
         return [];
     // If proposals disagree, none can be auto-accepted
-    if (proposals.length > 1 && proposalsDisagree(proposals))
+    if (hasCandidateConflict(proposals.map((p) => ({ equivalenceKey: mappingEquivalenceKey(p) }))))
         return [];
     return proposals
-        .filter((p) => p.confidence >= policy.minConfidence)
+        .filter((p) => meetsAutoAcceptThreshold(p.confidence, policy.minConfidence))
         .map((proposal) => ({
         id: `inquiry-mapping.auto.${normalizeQuestion(proposal.question)}`,
         normalizedQuestion: normalizeQuestion(proposal.question),
         target: proposal.proposedTarget,
         ruleId: proposal.proposedRuleId,
         status: "assumed",
-        reviewedBy: "auto-accept-policy",
+        reviewedBy: AUTO_ACCEPT_ACTOR,
         reviewedAt: proposal.proposedAt,
         rationale: `Auto-accepted: confidence ${proposal.confidence} >= threshold ${policy.minConfidence}. ${proposal.rationale}`,
-        withinComfortZone: true,
+        withinComfortZone: AUTO_ACCEPT_WITHIN_COMFORT_ZONE,
         proposalId: proposal.id,
     }));
 }
@@ -266,7 +264,7 @@ export function resolveQuestion(bundle, question, options) {
  */
 export function buildMappingReviewItems(candidateSets) {
     return candidateSets.map(({ candidateSet, candidates }) => ({
-        apiVersion: "survey.kontourai.io/v1alpha1",
+        apiVersion: reviewResourceApiVersion,
         kind: "ReviewItem",
         metadata: {
             name: candidateSet.id,
@@ -275,7 +273,7 @@ export function buildMappingReviewItems(candidateSets) {
         spec: {
             target: candidateSet.target,
             candidates: candidates.map((candidate) => {
-                const meta = candidate.metadata?.mappingProposal;
+                const meta = getProducerProposal(candidate);
                 const targetOrRule = meta?.proposedTarget
                     ? `${meta.proposedTarget.subjectType}/${meta.proposedTarget.subjectId}/${meta.proposedTarget.fieldOrBehavior}`
                     : `rule:${meta?.proposedRuleId ?? "unknown"}`;