@kontourai/survey 1.19.0 → 2.0.0

package/README.md

@@ -103,7 +103,7 @@ One observation, one chain: the page it came from, what the extractor read, who
 
 Keep producer operational state outside Survey. Queue status, reviewer form state, retries, source caches, and product policy decisions belong in the producer's own data model. Survey carries only the portable evidence chain records needed by Surface.
 
-Need Anthropic-backed `MappingProposer`/`UtteranceClaimExtractor` implementations for step 1? `@kontourai/survey/anthropic` ships production adapters as proposers-only — every output still goes through the normal review path. It's a separate subpath (not re-exported from the package root) so consumers without `@anthropic-ai/sdk` installed pay nothing.
+Model-backed producers implement `MappingProposer` or `UtteranceClaimExtractor` in the product that owns the prompt, parsing, runtime policy, and domain mapping. Survey accepts their normalized proposals through the same framework-neutral interfaces and review path; it does not acquire credentials or depend on an AI runtime.
 
 When you build an `authorized-action` authorizing block outside the workbench, pair `buildAuthorizedActionAuthorizing` with `buildPromptRef({ module, component, version?, scheme? })` — `buildPromptRef` formats a well-formed, versioned `promptRef` (bare `"review-workbench/decision-card@v1"` or scheme-prefixed `"survey://<module>/<component>@v1"`) that `buildAuthorizedActionAuthorizing` accepts directly, instead of hand-formatting the string.
 

package/dist/src/agent-utterance.js

@@ -22,17 +22,16 @@ 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
+ * Extractors do not normalize `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
+ * differences like "Healthy" vs "healthy") is plausible in producer 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
+ * supported by the portable record contract) 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

package/dist/src/canonical-reviewed-trust-input.d.ts

@@ -0,0 +1,31 @@
+import type { SurveyInput } from "./types.js";
+import type { ReviewItem } from "./review-resource.js";
+import type { ReviewWorkbenchResult } from "./review-workbench/review-workbench.js";
+export interface BuildCanonicalReviewedTrustInputOptions {
+    /** Producer identity for the resulting SurveyInput batch. */
+    readonly source: string;
+    /** Server-controlled projection time. */
+    readonly generatedAt: string;
+    /** Stable producer-owned identity for this review projection. */
+    readonly projectionContextId: string;
+    /** Canonical ReviewItems from the server-owned pre-decision snapshot. */
+    readonly items: readonly ReviewItem[];
+    /** Results derived by Survey's server apply boundary from snapshot + events. */
+    readonly results: readonly ReviewWorkbenchResult[];
+}
+export interface CanonicalReviewedTrustInput {
+    readonly surveyInput: SurveyInput;
+    /** Pass unchanged to buildSurveyTrustBundle's projectionContextId option. */
+    readonly projectionContextId: string;
+}
+/**
+ * Projects server-applied review records into the complete SurveyInput consumed
+ * by buildSurveyTrustBundle. The ReviewItem and ReviewWorkbenchResult are the
+ * authority: callers cannot override status, value, identity, or provenance.
+ *
+ * The helper deliberately returns the projection context beside SurveyInput
+ * because repeated append-only projections need that context at the Surface
+ * projection boundary, while SurveyInput's existing byte shape remains
+ * unchanged for compatibility.
+ */
+export declare function buildCanonicalReviewedTrustInput(options: BuildCanonicalReviewedTrustInputOptions): CanonicalReviewedTrustInput;

package/dist/src/canonical-reviewed-trust-input.js

@@ -0,0 +1,265 @@
+import { SURVEY_INPUT_CONTRACT_VERSION } from "./types.js";
+import { canonicalJson } from "./review-workbench/canonical.js";
+import { workbenchDecisionDefinitions } from "./review-workbench/review-queue-session.js";
+/**
+ * Projects server-applied review records into the complete SurveyInput consumed
+ * by buildSurveyTrustBundle. The ReviewItem and ReviewWorkbenchResult are the
+ * authority: callers cannot override status, value, identity, or provenance.
+ *
+ * The helper deliberately returns the projection context beside SurveyInput
+ * because repeated append-only projections need that context at the Surface
+ * projection boundary, while SurveyInput's existing byte shape remains
+ * unchanged for compatibility.
+ */
+export function buildCanonicalReviewedTrustInput(options) {
+    requireNonEmpty(options.source, "source");
+    requireTimestamp(options.generatedAt, "generatedAt");
+    if (!/^[A-Za-z0-9][A-Za-z0-9._:-]*$/.test(options.projectionContextId)) {
+        throw new Error("projectionContextId must be a non-empty portable resource-name fragment.");
+    }
+    const itemsByName = uniqueBy(options.items, (item) => item.metadata.name, "ReviewItem");
+    const resultsByName = uniqueBy(options.results, (result) => result.reviewItemName, "ReviewWorkbenchResult");
+    if (itemsByName.size !== resultsByName.size) {
+        throw new Error("Canonical review projection requires exactly one resolved result for every ReviewItem.");
+    }
+    const rawSources = new Map();
+    const extractions = new Map();
+    const candidateSets = new Map();
+    const reviewOutcomes = new Map();
+    const claims = new Map();
+    for (const item of options.items) {
+        const result = resultsByName.get(item.metadata.name);
+        if (!result) {
+            throw new Error(`ReviewItem ${item.metadata.name} has no canonical server-applied result.`);
+        }
+        assertCanonicalResult(item, result);
+        const candidates = item.spec.candidates.map((candidate) => {
+            const records = projectCandidate(item, candidate);
+            addConsistent(rawSources, records.rawSource, "raw source");
+            addConsistent(extractions, records.extraction, "extraction");
+            return records.candidate;
+        });
+        const selected = item.spec.candidates.find((candidate) => candidate.id === result.selectedCandidateId);
+        const selectedRecordId = selected.projection?.candidateId ?? selected.id;
+        const candidateSetId = selected.projection?.candidateSetId
+            ?? item.spec.projection?.candidateSetId
+            ?? `${item.metadata.name}.candidates`;
+        if (candidates.some((candidate) => candidate.metadata?.candidateSetId !== candidateSetId)) {
+            throw new Error(`ReviewItem ${item.metadata.name} carries conflicting candidate-set projection ids.`);
+        }
+        const candidateSet = {
+            id: candidateSetId,
+            target: item.spec.target,
+            candidates: candidates.map(({ metadata, ...candidate }) => ({
+                ...candidate,
+                ...(metadata && Object.keys(metadata).length > 1
+                    ? { metadata: Object.fromEntries(Object.entries(metadata).filter(([key]) => key !== "candidateSetId")) }
+                    : {}),
+            })),
+            selectedCandidateId: selectedRecordId,
+            status: result.decision === "could-not-confirm"
+                ? (item.spec.candidateSetStatus ?? "needs-review")
+                : "resolved",
+            ...(result.rationale ?? item.spec.rationale
+                ? { rationale: result.rationale ?? item.spec.rationale }
+                : {}),
+        };
+        addConsistent(candidateSets, candidateSet, "candidate set");
+        const decision = result.reviewDecision.spec;
+        const reviewOutcomeId = decision.projection?.reviewOutcomeId
+            ?? selected.projection?.reviewOutcomeId
+            ?? `${item.metadata.name}.${result.decision}.review-outcome`;
+        const reviewOutcome = {
+            id: reviewOutcomeId,
+            candidateSetId,
+            candidateId: selectedRecordId,
+            status: result.status,
+            ...(decision.resolution ? { resolution: decision.resolution } : {}),
+            ...(decision.resolutionReason ? { resolutionReason: decision.resolutionReason } : {}),
+            ...(decision.attemptEvidenceIds?.length ? { attemptEvidenceIds: [...decision.attemptEvidenceIds] } : {}),
+            ...(decision.actor?.id ? { actor: decision.actor.id } : {}),
+            ...(decision.reviewedAt ? { reviewedAt: decision.reviewedAt } : {}),
+            ...(decision.rationale ? { rationale: decision.rationale } : {}),
+            ...(decision.evidenceIds?.length ? { evidenceIds: [...decision.evidenceIds] } : {}),
+            ...(decision.withinComfortZone !== undefined ? { withinComfortZone: decision.withinComfortZone } : {}),
+            ...(decision.comfortZoneNote ? { comfortZoneNote: decision.comfortZoneNote } : {}),
+            ...(decision.authorizing ? { authorizing: decision.authorizing } : {}),
+            metadata: {
+                workbenchDecision: result.decision,
+                ...(result.editedValue !== undefined ? { editedValue: result.editedValue } : {}),
+            },
+        };
+        addConsistent(reviewOutcomes, reviewOutcome, "review outcome");
+        const hint = selected.claimTarget;
+        assertSingleProjectionId("claim", item.metadata.name, [
+            decision.projection?.claimId,
+            item.spec.projection?.claimId,
+            ...item.spec.candidates.flatMap((candidate) => [candidate.projection?.claimId, candidate.claimTarget.claimId]),
+        ]);
+        const claimId = decision.projection?.claimId
+            ?? selected.projection?.claimId
+            ?? item.spec.projection?.claimId
+            ?? hint.claimId
+            ?? `${item.metadata.name}.claim`;
+        const claim = {
+            id: claimId,
+            candidateSetId,
+            candidateId: selectedRecordId,
+            subjectType: hint.subjectType,
+            subjectId: hint.subjectId,
+            facet: hint.facet,
+            claimType: hint.claimType,
+            fieldOrBehavior: hint.fieldOrBehavior,
+            value: result.effectiveValue,
+            status: result.status,
+            impactLevel: hint.impactLevel,
+            updatedAt: decision.reviewedAt ?? options.generatedAt,
+            ...(hint.evidenceType ? { evidenceType: hint.evidenceType } : {}),
+            ...(hint.evidenceMethod ? { evidenceMethod: hint.evidenceMethod } : {}),
+            ...(hint.derivedFrom ? { derivedFrom: [...hint.derivedFrom] } : {}),
+            collectedBy: hint.collectedBy ?? selected.extraction.extractor ?? options.source,
+            ...(decision.actor?.id ? { actor: decision.actor.id } : {}),
+        };
+        addConsistent(claims, claim, "claim target");
+    }
+    return {
+        projectionContextId: options.projectionContextId,
+        surveyInput: {
+            contractVersion: SURVEY_INPUT_CONTRACT_VERSION,
+            source: options.source,
+            generatedAt: options.generatedAt,
+            rawSources: [...rawSources.values()],
+            extractions: [...extractions.values()],
+            candidateSets: [...candidateSets.values()],
+            reviewOutcomes: [...reviewOutcomes.values()],
+            claims: [...claims.values()],
+        },
+    };
+}
+function assertCanonicalResult(item, result) {
+    const selected = item.spec.candidates.find((candidate) => candidate.id === result.selectedCandidateId);
+    if (!selected) {
+        throw new Error(`Review result ${result.reviewItemName} selects an unknown candidate.`);
+    }
+    if (canonicalJson(selected) !== canonicalJson(result.selectedCandidate)) {
+        throw new Error(`Review result ${result.reviewItemName} selected candidate does not match its canonical ReviewItem.`);
+    }
+    const unselected = item.spec.candidates.filter((candidate) => candidate.id !== selected.id);
+    if (canonicalJson(unselected) !== canonicalJson(result.unselectedCandidates)) {
+        throw new Error(`Review result ${result.reviewItemName} unselected candidates do not match its canonical ReviewItem.`);
+    }
+    if (result.selectedCandidateRole !== selected.role || canonicalJson(result.selectedValue) !== canonicalJson(selected.value)) {
+        throw new Error(`Review result ${result.reviewItemName} selected identity does not match its canonical ReviewItem.`);
+    }
+    const decision = result.reviewDecision.spec;
+    const definition = workbenchDecisionDefinitions[result.decision];
+    if (decision.reviewItemName !== item.metadata.name
+        || decision.candidateId !== result.selectedCandidateId
+        || decision.status !== result.status
+        || decision.status !== definition.status
+        || decision.rationale !== result.rationale
+        || canonicalJson(decision.editedValue) !== canonicalJson(result.editedValue)) {
+        throw new Error(`Review result ${result.reviewItemName} contradicts its canonical ReviewDecision.`);
+    }
+    if ((result.decision === "could-not-confirm") !== (decision.resolution === "could_not_confirm")) {
+        throw new Error(`Review result ${result.reviewItemName} contradicts its canonical review resolution.`);
+    }
+    const expectedEffective = result.editedValue !== undefined && result.decision === "accept-proposed"
+        ? result.editedValue
+        : selected.value;
+    if (canonicalJson(expectedEffective) !== canonicalJson(result.effectiveValue)) {
+        throw new Error(`Review result ${result.reviewItemName} effective value is not canonical.`);
+    }
+    for (const candidate of item.spec.candidates) {
+        if (canonicalJson(claimTargetIdentity(candidate.claimTarget)) !== canonicalJson(claimTargetIdentity(selected.claimTarget))) {
+            throw new Error(`ReviewItem ${item.metadata.name} candidates carry conflicting claim targets.`);
+        }
+    }
+}
+function claimTargetIdentity(target) {
+    const { claimId: _claimId, ...identity } = target;
+    return identity;
+}
+function projectCandidate(item, input) {
+    const rawSourceId = input.projection?.rawSourceId ?? input.source.sourceId ?? `${item.metadata.name}.${input.id}.source`;
+    const extractionId = input.projection?.extractionId ?? input.extraction.extractionId ?? `${item.metadata.name}.${input.id}.extraction`;
+    const candidateSetId = input.projection?.candidateSetId ?? item.spec.projection?.candidateSetId ?? `${item.metadata.name}.candidates`;
+    const sourceKind = input.source.kind;
+    const observedAt = input.source.observedAt;
+    const locatorScheme = input.source.locatorScheme ?? input.locator?.scheme;
+    const extractor = input.extraction.extractor;
+    const extractedAt = input.extraction.extractedAt;
+    if (!sourceKind || !observedAt || !locatorScheme || !extractor || !extractedAt) {
+        throw new Error(`ReviewCandidate ${input.id} lacks source or extraction provenance required for TrustInput projection.`);
+    }
+    const rawSource = {
+        id: rawSourceId,
+        kind: sourceKind,
+        sourceRef: input.source.sourceRef,
+        observedAt,
+        ...(input.source.fetchedAt ? { fetchedAt: input.source.fetchedAt } : {}),
+        ...(input.source.checksum ? { checksum: input.source.checksum } : {}),
+        locatorScheme,
+    };
+    const extraction = {
+        id: extractionId,
+        sourceId: rawSourceId,
+        target: input.extraction.target,
+        value: input.value,
+        ...(input.extraction.confidence ?? input.confidence) !== undefined
+            ? { confidence: input.extraction.confidence ?? input.confidence }
+            : {},
+        ...(input.locator?.locator ? { locator: input.locator.locator } : {}),
+        ...(input.locator?.excerpt ? { excerpt: input.locator.excerpt } : {}),
+        extractor,
+        extractedAt,
+        ...(input.extraction.model ? { metadata: { model: input.extraction.model } } : {}),
+    };
+    const candidate = {
+        id: input.projection?.candidateId ?? input.id,
+        extractionId,
+        value: input.value,
+        ...(input.confidence !== undefined ? { confidence: input.confidence } : {}),
+        ...(input.sourceRank !== undefined ? { sourceRank: input.sourceRank } : {}),
+        ...(input.rejectionReason ? { rejectionReason: input.rejectionReason } : {}),
+        metadata: {
+            candidateSetId,
+            ...(input.role ? { role: input.role } : {}),
+            ...(input.producer ? { producer: input.producer } : {}),
+        },
+    };
+    return { rawSource, extraction, candidate };
+}
+function uniqueBy(values, id, label) {
+    const output = new Map();
+    for (const value of values) {
+        const key = requireNonEmpty(id(value), `${label} identity`);
+        if (output.has(key)) {
+            throw new Error(`Canonical review projection received duplicate ${label} ${key}.`);
+        }
+        output.set(key, value);
+    }
+    return output;
+}
+function addConsistent(records, value, label) {
+    const existing = records.get(value.id);
+    if (existing && canonicalJson(existing) !== canonicalJson(value)) {
+        throw new Error(`Canonical review projection found conflicting ${label} ${value.id}.`);
+    }
+    records.set(value.id, value);
+}
+function requireNonEmpty(value, label) {
+    if (!value.trim())
+        throw new Error(`${label} must be non-empty.`);
+    return value;
+}
+function requireTimestamp(value, label) {
+    if (!value.trim() || Number.isNaN(Date.parse(value)))
+        throw new Error(`${label} must be an ISO timestamp.`);
+}
+function assertSingleProjectionId(label, itemName, values) {
+    const ids = new Set(values.filter((value) => value !== undefined));
+    if (ids.size > 1) {
+        throw new Error(`ReviewItem ${itemName} carries conflicting ${label} projection ids.`);
+    }
+}

package/dist/src/extraction-improvement-proposal.d.ts

@@ -123,6 +123,23 @@ export interface RejectExtractionImprovementProposalInput {
 }
 /** One producer/store disposition is allowed for each shared dispositionKey. */
 export type ExtractionImprovementDisposition = ExtractionImprovementActivationRequest | ExtractionImprovementRejection;
+export interface ExtractionImprovementDispositionConflict {
+    kind: "survey.extraction-improvement-disposition-conflict";
+    dispositionKey: string;
+    /** Canonically ordered distinct records. The fold never selects a winner. */
+    dispositions: readonly ExtractionImprovementDisposition[];
+}
+export interface FoldExtractionImprovementDispositionsResult {
+    /** One canonically ordered record for each uncontested disposition key. */
+    dispositions: readonly ExtractionImprovementDisposition[];
+    /** Canonically ordered conflicts for keys with more than one distinct record. */
+    conflicts: readonly ExtractionImprovementDispositionConflict[];
+}
+/**
+ * Folds producer-owned disposition records without performing I/O or selecting
+ * between conflicting decisions. Byte-equivalent replay is idempotent.
+ */
+export declare function foldExtractionImprovementDispositions(input: readonly ExtractionImprovementDisposition[]): FoldExtractionImprovementDispositionsResult;
 /** Builds a frozen draft from validated canonical records. Performs no I/O. */
 export declare function buildExtractionImprovementProposal(input: BuildExtractionImprovementProposalInput): ExtractionImprovementDraft;
 /** Emits a reversible activation request, never an activation. */

package/dist/src/extraction-improvement-proposal.js

@@ -2,6 +2,39 @@ import { createHash } from "node:crypto";
 import { buildReviewItemsFromExtractionEnvelopeImport } from "./extraction-envelope.js";
 import { reviewResourceApiVersion } from "./review-resource.js";
 import { canonicalJson } from "./review-workbench/canonical.js";
+/**
+ * Folds producer-owned disposition records without performing I/O or selecting
+ * between conflicting decisions. Byte-equivalent replay is idempotent.
+ */
+export function foldExtractionImprovementDispositions(input) {
+    const byKey = new Map();
+    for (const disposition of input) {
+        const records = byKey.get(disposition.dispositionKey) ?? new Map();
+        records.set(canonicalJson(disposition), disposition);
+        byKey.set(disposition.dispositionKey, records);
+    }
+    const dispositions = [];
+    const conflicts = [];
+    for (const dispositionKey of [...byKey.keys()].sort()) {
+        const records = [...byKey.get(dispositionKey).entries()]
+            .sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0)
+            .map(([, disposition]) => disposition);
+        if (records.length === 1) {
+            dispositions.push(records[0]);
+        }
+        else {
+            conflicts.push(Object.freeze({
+                kind: "survey.extraction-improvement-disposition-conflict",
+                dispositionKey,
+                dispositions: Object.freeze(records),
+            }));
+        }
+    }
+    return Object.freeze({
+        dispositions: Object.freeze(dispositions),
+        conflicts: Object.freeze(conflicts),
+    });
+}
 /** Builds a frozen draft from validated canonical records. Performs no I/O. */
 export function buildExtractionImprovementProposal(input) {
     const diagnosis = normalizeDiagnosis(input.diagnosis);

package/dist/src/index.d.ts

@@ -14,12 +14,14 @@ export { reviewedCurrentProposedResolution } from "./reviewed-current-proposed-r
 export type { CurrentProposedCandidateRole, ReviewedCurrentProposedResolutionInput, } from "./reviewed-current-proposed-resolution.js";
 export { buildSurveyTrustBundle } from "./to-surface.js";
 export type { BuildSurveyTrustBundleOptions } from "./to-surface.js";
+export { buildCanonicalReviewedTrustInput } from "./canonical-reviewed-trust-input.js";
+export type { BuildCanonicalReviewedTrustInputOptions, CanonicalReviewedTrustInput, } from "./canonical-reviewed-trust-input.js";
 export { buildSurveyLearningProjections } from "./learning-projections.js";
 export type { LearningProjection, LearningProjectionKind, LearningProjectionSeverity, LearningProjectionSignal, } from "./learning-projections.js";
 export { buildReviewedLearningUpdateProposal } from "./learning-update-proposal.js";
 export type { LearningUpdateEvidenceReference, LearningUpdateProposal, OpaqueEvidenceReference, ProvenanceReference, ReviewedLearningUpdateProposalInput, ReviewProofReference, } from "./learning-update-proposal.js";
-export { approveExtractionImprovementProposal, buildExtractionImprovementProposal, rejectExtractionImprovementProposal, } from "./extraction-improvement-proposal.js";
-export type { ApproveExtractionImprovementProposalInput, AcceptedExtractionDiagnosis, BadExtractionDiagnosis, BuildExtractionImprovementProposalInput, ExtractionImprovementActivationRequest, ExtractionImprovementDiagnosis, ExtractionImprovementDisposition, ExtractionImprovementDraft, ExtractionImprovementLineage, ExtractionImprovementRejection, ExtractionImprovementRecordDigests, ExtractionImprovementReview, ExtractionTaskSpecReference, InsufficientSourceEvidenceDiagnosis, ProducerApproval, RejectExtractionImprovementProposalInput, } from "./extraction-improvement-proposal.js";
+export { approveExtractionImprovementProposal, buildExtractionImprovementProposal, foldExtractionImprovementDispositions, rejectExtractionImprovementProposal, } from "./extraction-improvement-proposal.js";
+export type { ApproveExtractionImprovementProposalInput, AcceptedExtractionDiagnosis, BadExtractionDiagnosis, BuildExtractionImprovementProposalInput, ExtractionImprovementActivationRequest, ExtractionImprovementDiagnosis, ExtractionImprovementDisposition, ExtractionImprovementDispositionConflict, ExtractionImprovementDraft, ExtractionImprovementLineage, ExtractionImprovementRejection, ExtractionImprovementRecordDigests, ExtractionImprovementReview, ExtractionTaskSpecReference, FoldExtractionImprovementDispositionsResult, InsufficientSourceEvidenceDiagnosis, ProducerApproval, RejectExtractionImprovementProposalInput, } from "./extraction-improvement-proposal.js";
 export { buildCanonicalReviewProofPayload, buildReviewProofAnchor, canonicalReviewProofJson, hashCanonicalReviewProofPayload, verifyCanonicalReviewProofPayload, REVIEW_PROOF_CONTRACT_VERSION, REVIEW_PROOF_PACKAGE_NAME, REVIEW_PROOF_SCHEMA, REVIEW_PROOF_SCHEMA_VERSION, } from "./review-proof.js";
 export type { CanonicalReviewProofPayload, CanonicalReviewProofPayloadV1, CanonicalReviewProofPayloadV2, ReviewProofInput, } from "./review-proof.js";
 export { fieldObservation } from "./field-observation.js";

package/dist/src/index.js

@@ -6,9 +6,10 @@ export { candidateReviewRecord, candidateSetStatusFor, SurveyInputBuilder } from
 export { reviewedCandidateResolution } from "./reviewed-candidate-resolution.js";
 export { reviewedCurrentProposedResolution } from "./reviewed-current-proposed-resolution.js";
 export { buildSurveyTrustBundle } from "./to-surface.js";
+export { buildCanonicalReviewedTrustInput } from "./canonical-reviewed-trust-input.js";
 export { buildSurveyLearningProjections } from "./learning-projections.js";
 export { buildReviewedLearningUpdateProposal } from "./learning-update-proposal.js";
-export { approveExtractionImprovementProposal, buildExtractionImprovementProposal, rejectExtractionImprovementProposal, } from "./extraction-improvement-proposal.js";
+export { approveExtractionImprovementProposal, buildExtractionImprovementProposal, foldExtractionImprovementDispositions, rejectExtractionImprovementProposal, } from "./extraction-improvement-proposal.js";
 export { buildCanonicalReviewProofPayload, buildReviewProofAnchor, canonicalReviewProofJson, hashCanonicalReviewProofPayload, verifyCanonicalReviewProofPayload, REVIEW_PROOF_CONTRACT_VERSION, REVIEW_PROOF_PACKAGE_NAME, REVIEW_PROOF_SCHEMA, REVIEW_PROOF_SCHEMA_VERSION, } from "./review-proof.js";
 export { fieldObservation } from "./field-observation.js";
 export { repeatedObservation } from "./repeated-observation.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kontourai/survey",
-  "version": "1.19.0",
+  "version": "2.0.0",
   "description": "Producer-side source, extraction, candidate, and review contracts for projecting verified claims into Surface.",
   "license": "Apache-2.0",
   "type": "module",
@@ -18,10 +18,6 @@
   },
   "exports": {
     ".": "./dist/src/index.js",
-    "./anthropic": {
-      "types": "./dist/src/anthropic.d.ts",
-      "default": "./dist/src/anthropic.js"
-    },
     "./review-workbench": {
       "types": "./dist/src/review-workbench/review-workbench.d.ts",
       "default": "./dist/src/review-workbench/review-workbench.js"
@@ -55,7 +51,8 @@
     "typecheck": "tsc --noEmit",
     "test": "npm run build && node --test dist/tests/*.test.js",
     "test:browser": "playwright test",
-    "verify": "node scripts/check-content-boundary.cjs && npm run check:decisions && npm run typecheck && npm test && npm run check:review-workbench-assets && npm run check:review-workbench && npm run test:browser",
+    "test:browser:concurrent": "npm run build && node scripts/test-playwright-concurrency.mjs",
+    "verify": "node scripts/check-content-boundary.cjs && npm run check:decisions && npm run typecheck && npm test && npm run check:review-workbench-assets && npm run check:review-workbench && npm run test:browser && npm run test:browser:concurrent",
     "check:content-boundary": "node scripts/check-content-boundary.cjs",
     "check:decisions": "node scripts/check-decisions.cjs check",
     "gen:decisions-index": "node scripts/check-decisions.cjs gen-index",
@@ -74,19 +71,14 @@
     "@kontourai/surface": "^2.9.0"
   },
   "peerDependencies": {
-    "@anthropic-ai/sdk": ">=0.20.0",
     "typescript": ">=5.0.0"
   },
   "peerDependenciesMeta": {
-    "@anthropic-ai/sdk": {
-      "optional": true
-    },
     "typescript": {
       "optional": true
     }
   },
   "devDependencies": {
-    "@anthropic-ai/sdk": "^0.54.0",
     "@kontourai/traverse": "^0.19.0",
     "@kontourai/ui": "^1.1.0",
     "@playwright/test": "^1.60.0",

package/dist/src/anthropic.d.ts

@@ -1,104 +0,0 @@
-/**
- * Anthropic production adapters for Survey's pluggable interfaces.
- *
- * ADR 0003 §4 compliance: these implementations are PROPOSERS only. Every
- * output is a proposal (MappingProposal / ExtractedStatement) that goes
- * through the existing review/auto-accept machinery before counting.
- * Nothing here bypasses review.
- *
- * Subpath export: import from "@kontourai/survey/anthropic" — this module is
- * NOT re-exported from the main index.ts so consumers without @anthropic-ai/sdk
- * pay nothing.
- *
- * Injected client: both factories accept an optional pre-built client so tests
- * can inject a fake without hitting the network. If no client is provided, one
- * is constructed from opts.apiKey (falling back to process.env.ANTHROPIC_API_KEY).
- */
-import type { MappingProposer } from "./inquiry-mapping.js";
-import type { UtteranceClaimExtractor } from "./agent-utterance.js";
-export interface AnthropicToolResultBlock {
-    type: "tool_result";
-    tool_use_id: string;
-    content: string;
-}
-export interface AnthropicToolUseBlock {
-    type: "tool_use";
-    id: string;
-    name: string;
-    input: unknown;
-}
-export type AnthropicContentBlock = {
-    type: "text";
-    text: string;
-} | AnthropicToolUseBlock;
-export interface AnthropicMessage {
-    id: string;
-    type: "message";
-    role: "assistant";
-    content: AnthropicContentBlock[];
-    model: string;
-    stop_reason: string | null;
-    usage: {
-        input_tokens: number;
-        output_tokens: number;
-    };
-}
-export interface AnthropicTool {
-    name: string;
-    description: string;
-    input_schema: {
-        type: "object";
-        properties: Record<string, unknown>;
-        required?: string[];
-    };
-}
-export interface AnthropicMessageCreateParams {
-    model: string;
-    max_tokens: number;
-    messages: Array<{
-        role: "user" | "assistant";
-        content: string;
-    }>;
-    tools: AnthropicTool[];
-    tool_choice: {
-        type: "tool";
-        name: string;
-    };
-}
-/**
- * Minimal interface matching @anthropic-ai/sdk Anthropic.messages.create.
- * Accept the real SDK client or a test double.
- */
-export interface AnthropicMessagesClient {
-    create(params: AnthropicMessageCreateParams): Promise<AnthropicMessage>;
-}
-export interface AnthropicAdapterOptions {
-    /** Injected client (real or mock). If absent, one is built from apiKey. */
-    client?: AnthropicMessagesClient;
-    /** API key. Falls back to ANTHROPIC_API_KEY env var. */
-    apiKey?: string;
-    /** Model to use. Defaults to "claude-sonnet-4-6". */
-    model?: string;
-}
-/**
- * Create a MappingProposer backed by Anthropic's API using forced tool-use.
- *
- * ADR 0003 §4: returns PROPOSALS only — they flow through the existing
- * review/auto-accept machinery before counting as mappings.
- *
- * Tool output is validated strictly: malformed items (missing required fields,
- * out-of-range confidence, no target and no rule) are filtered out rather than
- * silently accepted.
- */
-export declare function createAnthropicMappingProposer(opts?: AnthropicAdapterOptions): MappingProposer;
-/**
- * Create a UtteranceClaimExtractor backed by Anthropic's API using forced tool-use.
- *
- * ADR 0003 §4: returns EXTRACTED STATEMENTS only — they carry full provenance
- * (excerpt, span, extractor name, confidence) and flow through the Inquiry
- * pipeline. They are never treated as authoritative.
- *
- * Malformed tool output is rejected/filtered — items missing required fields
- * (subjectId, fieldOrBehavior, excerpt, confidence) are dropped.
- */
-export declare function createAnthropicUtteranceExtractor(opts?: AnthropicAdapterOptions): UtteranceClaimExtractor;

package/dist/src/anthropic.js

@@ -1,383 +0,0 @@
-/**
- * Anthropic production adapters for Survey's pluggable interfaces.
- *
- * ADR 0003 §4 compliance: these implementations are PROPOSERS only. Every
- * output is a proposal (MappingProposal / ExtractedStatement) that goes
- * through the existing review/auto-accept machinery before counting.
- * Nothing here bypasses review.
- *
- * Subpath export: import from "@kontourai/survey/anthropic" — this module is
- * NOT re-exported from the main index.ts so consumers without @anthropic-ai/sdk
- * pay nothing.
- *
- * Injected client: both factories accept an optional pre-built client so tests
- * can inject a fake without hitting the network. If no client is provided, one
- * is constructed from opts.apiKey (falling back to process.env.ANTHROPIC_API_KEY).
- */
-const DEFAULT_MODEL = "claude-sonnet-4-6";
-/**
- * Build or return a messages client from options.
- * Dynamic-imports @anthropic-ai/sdk only when no client is injected,
- * keeping the optional peer dep out of the eager module graph.
- */
-async function resolveClient(opts) {
-    if (opts.client)
-        return opts.client;
-    // Dynamically load the SDK — only reachable when no client is injected.
-    // Uses a variable module specifier so TypeScript does not try to resolve
-    // the optional peer dep at compile time. At runtime the SDK must be installed.
-    const sdkModule = "@anthropic-ai/sdk";
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-    const sdkImport = await Function("m", "return import(m)")(sdkModule);
-    const { default: Anthropic } = sdkImport;
-    const apiKey = opts.apiKey ?? process.env["ANTHROPIC_API_KEY"];
-    if (!apiKey) {
-        throw new Error("AnthropicAdapter: no API key. Provide opts.apiKey, set ANTHROPIC_API_KEY, or inject opts.client.");
-    }
-    const sdk = new Anthropic({ apiKey });
-    return sdk.messages;
-}
-// ---------------------------------------------------------------------------
-// JSON tool schemas
-// ---------------------------------------------------------------------------
-const MAPPING_PROPOSAL_TOOL = {
-    name: "submit_mapping_proposals",
-    description: "Submit an array of candidate mappings from the natural-language question to registered canonical claim targets or derivation rules. " +
-        "You are PROPOSING for human review — every proposal must carry a rationale and confidence score. " +
-        "Per ADR 0003 §4, proposals are reviewable records; they do not resolve questions by themselves.",
-    input_schema: {
-        type: "object",
-        properties: {
-            proposals: {
-                type: "array",
-                items: {
-                    type: "object",
-                    properties: {
-                        proposedTargetSubjectType: {
-                            type: "string",
-                            description: "subjectType of the canonical claim target (omit if proposing a rule)",
-                        },
-                        proposedTargetSubjectId: {
-                            type: "string",
-                            description: "subjectId of the canonical claim target (omit if proposing a rule)",
-                        },
-                        proposedTargetFieldOrBehavior: {
-                            type: "string",
-                            description: "fieldOrBehavior of the canonical claim target (omit if proposing a rule)",
-                        },
-                        proposedRuleId: {
-                            type: "string",
-                            description: "Id of the derivation rule this question maps to (omit if proposing a target)",
-                        },
-                        confidence: {
-                            type: "number",
-                            description: "Confidence in this mapping (0.0–1.0)",
-                        },
-                        rationale: {
-                            type: "string",
-                            description: "Human-readable explanation of why this mapping is proposed",
-                        },
-                        excerpt: {
-                            type: "string",
-                            description: "Verbatim excerpt from the question that drove the suggestion",
-                        },
-                    },
-                    required: ["confidence", "rationale"],
-                },
-            },
-        },
-        required: ["proposals"],
-    },
-};
-const UTTERANCE_EXTRACTION_TOOL = {
-    name: "submit_extracted_statements",
-    description: "Submit an array of factual statements extracted from the agent utterance. " +
-        "Each statement maps to a canonical claim target with full provenance (excerpt, span, confidence). " +
-        "You are EXTRACTING FOR REVIEW — output is a proposal queue, not authoritative truth. " +
-        "Per ADR 0003 §4, every extracted statement requires a rationale and confidence score.",
-    input_schema: {
-        type: "object",
-        properties: {
-            statements: {
-                type: "array",
-                items: {
-                    type: "object",
-                    properties: {
-                        subjectType: {
-                            type: "string",
-                            description: "The canonical subjectType (use 'unknown' if uncertain)",
-                        },
-                        subjectId: {
-                            type: "string",
-                            description: "The entity or resource the statement is about",
-                        },
-                        fieldOrBehavior: {
-                            type: "string",
-                            description: "The property or behavior being claimed",
-                        },
-                        value: {
-                            description: "The claimed value (string, number, boolean, or null)",
-                        },
-                        excerpt: {
-                            type: "string",
-                            description: "Verbatim text from the utterance that contains this claim",
-                        },
-                        spanStart: {
-                            type: "number",
-                            description: "0-indexed character offset where the excerpt starts in the utterance",
-                        },
-                        spanEnd: {
-                            type: "number",
-                            description: "0-indexed character offset where the excerpt ends in the utterance",
-                        },
-                        confidence: {
-                            type: "number",
-                            description: "Extraction confidence (0.0–1.0)",
-                        },
-                    },
-                    required: ["subjectId", "fieldOrBehavior", "excerpt", "confidence"],
-                },
-            },
-        },
-        required: ["statements"],
-    },
-};
-// ---------------------------------------------------------------------------
-// Tool output parsing helpers
-// ---------------------------------------------------------------------------
-/**
- * Extract the first tool_use block with the given name from a message.
- * Returns undefined if not found (malformed output is rejected, never silently accepted).
- */
-function extractToolUseInput(message, toolName) {
-    for (const block of message.content) {
-        if (block.type === "tool_use" && block.name === toolName) {
-            return block.input;
-        }
-    }
-    return undefined;
-}
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function isArray(value) {
-    return Array.isArray(value);
-}
-function stringOrUndefined(value) {
-    return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
-}
-function numberInRange(value, min, max) {
-    if (typeof value !== "number" || !isFinite(value))
-        return undefined;
-    if (value < min || value > max)
-        return undefined;
-    return value;
-}
-// ---------------------------------------------------------------------------
-// createAnthropicMappingProposer
-// ---------------------------------------------------------------------------
-/**
- * Create a MappingProposer backed by Anthropic's API using forced tool-use.
- *
- * ADR 0003 §4: returns PROPOSALS only — they flow through the existing
- * review/auto-accept machinery before counting as mappings.
- *
- * Tool output is validated strictly: malformed items (missing required fields,
- * out-of-range confidence, no target and no rule) are filtered out rather than
- * silently accepted.
- */
-export function createAnthropicMappingProposer(opts = {}) {
-    const model = opts.model ?? DEFAULT_MODEL;
-    return {
-        name: `anthropic-mapping-proposer:${model}`,
-        async propose(question, context) {
-            const client = await resolveClient(opts);
-            // Build context summary for the prompt
-            const claimsContext = buildClaimsContext(context.bundle);
-            const rulesContext = buildRulesContext(context.rules);
-            const systemPrompt = [
-                "You are a mapping proposer for the Kontour trust ledger.",
-                "Your role is to PROPOSE (not decide) how a natural-language question maps to a registered canonical claim or derivation rule.",
-                "Every proposal you return will be reviewed by a human or auto-accept policy before it counts.",
-                "Do not make up claim targets that are not in the registered list below.",
-                "Return only proposals you genuinely believe are plausible mappings — with honest confidence scores.",
-                "",
-                claimsContext,
-                rulesContext,
-            ]
-                .filter(Boolean)
-                .join("\n");
-            const userMessage = `Question to map: "${question}"`;
-            const message = await client.create({
-                model,
-                max_tokens: 1024,
-                messages: [{ role: "user", content: `${systemPrompt}\n\n${userMessage}` }],
-                tools: [MAPPING_PROPOSAL_TOOL],
-                tool_choice: { type: "tool", name: "submit_mapping_proposals" },
-            });
-            const input = extractToolUseInput(message, "submit_mapping_proposals");
-            if (!isRecord(input))
-                return [];
-            const rawProposals = input["proposals"];
-            if (!isArray(rawProposals))
-                return [];
-            const proposedAt = new Date().toISOString();
-            const results = [];
-            for (const item of rawProposals) {
-                const proposal = parseMappingProposalItem(item, question, model, proposedAt);
-                if (proposal)
-                    results.push(proposal);
-            }
-            return results;
-        },
-    };
-}
-function parseMappingProposalItem(item, question, proposedBy, proposedAt) {
-    if (!isRecord(item))
-        return undefined;
-    const raw = item;
-    const confidence = numberInRange(raw.confidence, 0, 1);
-    const rationale = stringOrUndefined(raw.rationale);
-    // Both required fields must be present
-    if (confidence === undefined || rationale === undefined)
-        return undefined;
-    const subjectType = stringOrUndefined(raw.proposedTargetSubjectType);
-    const subjectId = stringOrUndefined(raw.proposedTargetSubjectId);
-    const fieldOrBehavior = stringOrUndefined(raw.proposedTargetFieldOrBehavior);
-    const ruleId = stringOrUndefined(raw.proposedRuleId);
-    const excerpt = stringOrUndefined(raw.excerpt);
-    // Exactly one of (target triple) or ruleId must be present
-    const hasTarget = subjectType !== undefined && subjectId !== undefined && fieldOrBehavior !== undefined;
-    const hasRule = ruleId !== undefined;
-    if (!hasTarget && !hasRule)
-        return undefined;
-    const proposedTarget = hasTarget
-        ? { subjectType: subjectType, subjectId: subjectId, fieldOrBehavior: fieldOrBehavior }
-        : undefined;
-    const id = `proposal.anthropic.${encodeId(question)}.${Date.now()}`;
-    return {
-        id,
-        question,
-        proposedTarget,
-        proposedRuleId: hasRule ? ruleId : undefined,
-        confidence,
-        rationale,
-        excerpt,
-        proposedBy,
-        proposedAt,
-    };
-}
-// ---------------------------------------------------------------------------
-// createAnthropicUtteranceExtractor
-// ---------------------------------------------------------------------------
-/**
- * Create a UtteranceClaimExtractor backed by Anthropic's API using forced tool-use.
- *
- * ADR 0003 §4: returns EXTRACTED STATEMENTS only — they carry full provenance
- * (excerpt, span, extractor name, confidence) and flow through the Inquiry
- * pipeline. They are never treated as authoritative.
- *
- * Malformed tool output is rejected/filtered — items missing required fields
- * (subjectId, fieldOrBehavior, excerpt, confidence) are dropped.
- */
-export function createAnthropicUtteranceExtractor(opts = {}) {
-    const model = opts.model ?? DEFAULT_MODEL;
-    return {
-        name: `anthropic-utterance-extractor:${model}`,
-        async extract(utterance) {
-            const client = await resolveClient(opts);
-            const systemPrompt = [
-                "You are a factual statement extractor for the Kontour trust ledger.",
-                "Your role is to identify every factual claim in the agent utterance and extract it with full provenance.",
-                "Each extracted statement will be reviewed for trust coverage — you are NOT deciding truth, only extracting for review.",
-                "Extract only statements that assert factual properties of named entities.",
-                "Skip opinions, predictions, and procedural descriptions.",
-                "Provide honest confidence scores — low confidence for ambiguous phrasing.",
-                "Include the exact verbatim excerpt and 0-indexed character span offsets.",
-            ].join("\n");
-            const userMessage = `Extract factual statements from this agent utterance:\n\n"${utterance}"`;
-            const message = await client.create({
-                model,
-                max_tokens: 2048,
-                messages: [{ role: "user", content: `${systemPrompt}\n\n${userMessage}` }],
-                tools: [UTTERANCE_EXTRACTION_TOOL],
-                tool_choice: { type: "tool", name: "submit_extracted_statements" },
-            });
-            const input = extractToolUseInput(message, "submit_extracted_statements");
-            if (!isRecord(input))
-                return [];
-            const rawStatements = input["statements"];
-            if (!isArray(rawStatements))
-                return [];
-            const results = [];
-            for (const item of rawStatements) {
-                const statement = parseExtractedStatementItem(item, utterance);
-                if (statement)
-                    results.push(statement);
-            }
-            return results;
-        },
-    };
-}
-function parseExtractedStatementItem(item, utterance) {
-    if (!isRecord(item))
-        return undefined;
-    const raw = item;
-    const subjectId = stringOrUndefined(raw.subjectId);
-    const fieldOrBehavior = stringOrUndefined(raw.fieldOrBehavior);
-    const excerpt = stringOrUndefined(raw.excerpt);
-    const confidence = numberInRange(raw.confidence, 0, 1);
-    // All required fields must be present
-    if (!subjectId || !fieldOrBehavior || !excerpt || confidence === undefined)
-        return undefined;
-    const subjectType = stringOrUndefined(raw.subjectType) ?? "unknown";
-    // Validate span if provided — both start and end must be valid integers
-    // within the utterance length
-    let span;
-    if (typeof raw.spanStart === "number" && typeof raw.spanEnd === "number") {
-        const start = Math.trunc(raw.spanStart);
-        const end = Math.trunc(raw.spanEnd);
-        if (Number.isFinite(start) &&
-            Number.isFinite(end) &&
-            start >= 0 &&
-            end > start &&
-            end <= utterance.length) {
-            span = { start, end };
-        }
-    }
-    return {
-        target: { subjectType, subjectId, fieldOrBehavior },
-        value: raw.value ?? undefined,
-        excerpt,
-        span,
-        confidence,
-    };
-}
-// ---------------------------------------------------------------------------
-// Prompt context builders
-// ---------------------------------------------------------------------------
-function buildClaimsContext(bundle) {
-    if (!bundle || bundle.claims.length === 0)
-        return "";
-    const lines = [
-        "Registered canonical claim targets (use ONLY these as proposedTarget):",
-        ...bundle.claims.map((c) => `  - subjectType="${c.subjectType}" subjectId="${c.subjectId}" fieldOrBehavior="${c.fieldOrBehavior}"`),
-    ];
-    return lines.join("\n");
-}
-function buildRulesContext(rules) {
-    if (!rules || rules.length === 0)
-        return "";
-    const lines = [
-        "Registered derivation rules (use rule id as proposedRuleId):",
-        ...rules.map((r) => `  - id="${r.id}" name="${r.name}"`),
-    ];
-    return lines.join("\n");
-}
-function encodeId(value) {
-    return value
-        .toLowerCase()
-        .replace(/\s+/g, "-")
-        .replace(/[^a-z0-9\-]/g, "")
-        .slice(0, 40);
-}