rea-agents 3.1.0 → 3.2.0

package/dist/domain/managedApplicationGraphCoverage.js

@@ -1,170 +1,38 @@
-import { assessKnownPageCoverage, } from "./knownPageCoverage.js";
-/** Complete application-graph fact coverage. */
-const completeManagedGraphCoverage = () => ({
+const completeCoverage = () => ({
     status: "complete",
     truncated: false,
     omitted_count: 0,
     limits: [],
 });
-/** Translate one managed parser coverage state without inventing omissions. */
+/** Preserve the source parser's coverage state on projected observations. */
 export const managedSourceCoverage = (state) => state === "complete"
-    ? completeManagedGraphCoverage()
+    ? completeCoverage()
     : {
         status: state,
         truncated: false,
         omitted_count: null,
         limits: [],
     };
-/** Preserve one known source page's coverage on a projected graph fact. */
-export const managedSourcePageCoverage = (state, page, scope) => {
-    if (state !== "complete")
-        return managedSourceCoverage(state);
-    const assessment = assessKnownPageCoverage(page);
-    if (assessment.complete)
-        return completeManagedGraphCoverage();
-    return {
-        status: "partial",
-        truncated: assessment.omittedCount > 0,
-        omitted_count: assessment.omittedCount,
-        limits: assessment.omittedCount > 0
-            ? [
-                { name: `${scope}_offset`, value: page.offset, unit: "items" },
-                { name: `${scope}_limit`, value: page.limit, unit: "items" },
-            ]
-            : [],
-    };
-};
-/** Assess exact source-page and local-limit omissions for graph projection. */
-export const assessManagedGraphOmissions = (sources, limits) => {
-    const { typeAssessment, methodAssessment, fieldAssessment } = assessMemberPages(sources.members, limits);
-    const { pinvokeAssessment, implementationAssessment } = assessBoundaryPages(sources.boundaries, limits);
-    const pageAssessments = [
-        typeAssessment,
-        methodAssessment,
-        fieldAssessment,
-        pinvokeAssessment,
-        implementationAssessment,
-    ];
-    const unknownInputCoverage = hasUnknownInputCoverage(sources);
-    return {
-        limits,
-        unknownInputCoverage,
-        partialInput: pageAssessments.some(({ sourceComplete }) => !sourceComplete) ||
-            unknownInputCoverage,
-        types: typeAssessment.omittedCount,
-        methods: methodAssessment.omittedCount,
-        fields: fieldAssessment.omittedCount,
-        pinvokeImports: pinvokeAssessment.omittedCount,
-        nativeImplementations: implementationAssessment.omittedCount,
-        sourceLimits: [
-            ...memberSourceLimits(sources.members),
-            ...boundarySourceLimits(sources.boundaries),
-        ],
-    };
-};
-/** Project aggregate omissions into the application graph coverage contract. */
-export const managedGraphEvidenceCoverage = (omissions) => {
-    const omitted = totalManagedGraphOmitted(omissions);
-    if (omissions.unknownInputCoverage)
-        return {
-            status: "partial",
-            truncated: false,
-            omitted_count: null,
-            limits: [],
-        };
-    return {
-        status: omitted === 0 && !omissions.partialInput ? "complete" : "partial",
-        truncated: omitted > 0,
-        omitted_count: omitted > 0 ? omitted : omissions.partialInput ? null : 0,
-        limits: omitted > 0 ? projectionLimits(omissions) : [],
-    };
-};
-/** Project aggregate omissions into the managed workflow result contract. */
-export const managedGraphResultCoverage = (omissions) => {
-    const omitted = totalManagedGraphOmitted(omissions);
-    return {
-        status: omissions.unknownInputCoverage
-            ? "partial"
-            : omitted > 0
-                ? "truncated"
-                : omissions.partialInput
-                    ? "partial"
-                    : "complete-within-inputs",
-        omitted_types: omissions.types,
-        omitted_methods: omissions.methods,
-        omitted_fields: omissions.fields,
-        omitted_pinvoke_imports: omissions.pinvokeImports,
-        omitted_native_implementations: omissions.nativeImplementations,
-    };
-};
-/** Sum all exact entity omissions represented by the managed graph result. */
-export const totalManagedGraphOmitted = (omissions) => omissions.types +
-    omissions.methods +
-    omissions.fields +
-    omissions.pinvokeImports +
-    omissions.nativeImplementations;
-const COMPLETE_EMPTY_PAGE = {
-    complete: true,
-    sourceComplete: true,
-    includedCount: 0,
-    omittedCount: 0,
-    sourceOmittedCount: 0,
-};
-const assessMemberPages = (members, limits) => members === null
-    ? {
-        typeAssessment: COMPLETE_EMPTY_PAGE,
-        methodAssessment: COMPLETE_EMPTY_PAGE,
-        fieldAssessment: COMPLETE_EMPTY_PAGE,
-    }
-    : {
-        typeAssessment: assessKnownPageCoverage(members.types, limits.max_types),
-        methodAssessment: assessKnownPageCoverage(members.methods, limits.max_methods),
-        fieldAssessment: assessKnownPageCoverage(members.fields, limits.max_fields),
-    };
-const assessBoundaryPages = (boundaries, limits) => boundaries === null
+/** Determine whether any supplied managed inspection was partial. */
+export const assessManagedGraphOmissions = (sources) => ({
+    partialInput: [
+        sources.members?.coverage.state,
+        sources.boundaries?.coverage.state,
+        sources.artifact?.coverage.state,
+    ].some((state) => state !== undefined && state !== "complete"),
+});
+/** Derive graph coverage solely from the coverage of supplied source evidence. */
+export const managedGraphEvidenceCoverage = (omissions) => omissions.partialInput
     ? {
-        pinvokeAssessment: COMPLETE_EMPTY_PAGE,
-        implementationAssessment: COMPLETE_EMPTY_PAGE,
+        status: "partial",
+        truncated: false,
+        omitted_count: null,
+        limits: [],
     }
-    : {
-        pinvokeAssessment: assessKnownPageCoverage(boundaries.pinvoke_imports, limits.max_pinvoke_imports),
-        implementationAssessment: assessKnownPageCoverage(boundaries.native_implementations, limits.max_native_implementations),
-    };
-const hasUnknownInputCoverage = (sources) => [
-    sources.members?.coverage.state,
-    sources.boundaries?.coverage.state,
-    sources.artifact?.coverage.state,
-].some((state) => state !== undefined && state !== "complete");
-const pageLimits = (name, page) => [
-    { name: `${name}_offset`, value: page.offset, unit: "items" },
-    { name: `${name}_limit`, value: page.limit, unit: "items" },
-];
-const memberSourceLimits = (members) => members === null
-    ? []
-    : [
-        ...pageLimits("source_types", members.types),
-        ...pageLimits("source_methods", members.methods),
-        ...pageLimits("source_fields", members.fields),
-    ];
-const boundarySourceLimits = (boundaries) => boundaries === null
-    ? []
-    : [
-        ...pageLimits("source_pinvoke_imports", boundaries.pinvoke_imports),
-        ...pageLimits("source_native_implementations", boundaries.native_implementations),
-    ];
-const projectionLimits = (omissions) => [
-    { name: "max_types", value: omissions.limits.max_types, unit: "items" },
-    { name: "max_methods", value: omissions.limits.max_methods, unit: "items" },
-    { name: "max_fields", value: omissions.limits.max_fields, unit: "items" },
-    {
-        name: "max_pinvoke_imports",
-        value: omissions.limits.max_pinvoke_imports,
-        unit: "items",
-    },
-    {
-        name: "max_native_implementations",
-        value: omissions.limits.max_native_implementations,
-        unit: "items",
-    },
-    ...omissions.sourceLimits,
-];
+    : completeCoverage();
+/** Report whether all supplied source evidence was complete. */
+export const managedGraphResultCoverage = (omissions) => ({
+    status: omissions.partialInput
+        ? "partial"
+        : "complete-within-inputs",
+});

package/dist/domain/managedApplicationGraphNodes.js

@@ -1,6 +1,6 @@
 import { basename } from "node:path";
 import { createJavaScriptApplicationEdge, createJavaScriptApplicationNode, } from "./javascriptApplicationGraph.js";
-import { managedSourceCoverage, managedSourcePageCoverage, } from "./managedApplicationGraphCoverage.js";
+import { managedSourceCoverage } from "./managedApplicationGraphCoverage.js";
 import {} from "./managedArtifact.js";
 import { moduleCoverageState } from "./managedApplicationGraphNodeCoverage.js";
 /** Add the root managed artifact node to the graph state. */
@@ -82,16 +82,14 @@ export const addArtifactIdentityNodes = (state, artifactNode, parsed) => {
     }
 };
 /** Add managed type, method, and field nodes from member evidence. */
-export const addMemberNodes = (state, artifactNode, parsed, limits) => {
+export const addMemberNodes = (state, artifactNode, parsed) => {
     const members = parsed.members?.result;
     if (members === undefined)
         return { types: 0, methods: 0, fields: 0 };
-    const types = members.types.items.slice(0, limits.max_types);
-    const methods = members.methods.items.slice(0, limits.max_methods);
-    const fields = members.fields.items.slice(0, limits.max_fields);
-    const typeCoverage = managedSourcePageCoverage(members.coverage.state, members.types, "types");
-    const methodCoverage = managedSourcePageCoverage(members.coverage.state, members.methods, "methods");
-    const fieldCoverage = managedSourcePageCoverage(members.coverage.state, members.fields, "fields");
+    const { types, methods, fields } = members;
+    const typeCoverage = managedSourceCoverage(members.coverage.state);
+    const methodCoverage = managedSourceCoverage(members.coverage.state);
+    const fieldCoverage = managedSourceCoverage(members.coverage.state);
     for (const type of types) {
         const node = typeNode(state, type, typeCoverage);
         state.nodes.push(node);
@@ -198,14 +196,13 @@ const fieldNode = (state, field, coverage) => createJavaScriptApplicationNode({
     ],
 });
 /** Add P/Invoke import and native implementation boundary nodes. */
-export const addBoundaryNodes = (state, artifactNode, parsed, limits) => {
+export const addBoundaryNodes = (state, artifactNode, parsed) => {
     const boundaries = parsed.boundaries?.result;
     if (boundaries === undefined)
         return { pinvoke_imports: 0, native_implementations: 0 };
-    const pinvokes = boundaries.pinvoke_imports.items.slice(0, limits.max_pinvoke_imports);
-    const implementations = boundaries.native_implementations.items.slice(0, limits.max_native_implementations);
-    const pinvokeCoverage = managedSourcePageCoverage(boundaries.coverage.state, boundaries.pinvoke_imports, "pinvoke_imports");
-    const implementationCoverage = managedSourcePageCoverage(boundaries.coverage.state, boundaries.native_implementations, "native_implementations");
+    const { pinvoke_imports: pinvokes, native_implementations: implementations } = boundaries;
+    const pinvokeCoverage = managedSourceCoverage(boundaries.coverage.state);
+    const implementationCoverage = managedSourceCoverage(boundaries.coverage.state);
     for (const pinvoke of pinvokes) {
         const node = pinvokeNode(state, pinvoke, pinvokeCoverage);
         state.nodes.push(node);

package/dist/domain/managedArtifact.js

@@ -6,15 +6,6 @@ const offsetSchema = z.number().int().min(0);
 export const cliMetadataGuidSchema = z
     .string()
     .regex(/^[0-9a-fA-F]{8}(?:-[0-9a-fA-F]{4}){3}-[0-9a-fA-F]{12}$/u);
-const managedPage = (item) => z.object({
-    items: z.array(item),
-    offset: offsetSchema,
-    limit: z.number().int().min(1),
-    total: z.number().int().min(0),
-    returned: z.number().int().min(0),
-    dropped: z.number().int().min(0),
-    complete: z.boolean(),
-});
 const publicKeyIdentitySchema = z.object({
     kind: z.enum(["none", "public-key", "public-key-token"]),
     byte_length: z.number().int().min(0),
@@ -146,7 +137,7 @@ const managedInstructionAnchorSchema = z.object({
     operand: z.string().nullable(),
 });
 const managedMethodBodySchema = z.object({
-    status: z.enum(["present", "partial", "absent", "malformed", "too-large"]),
+    status: z.enum(["present", "partial", "absent", "malformed"]),
     header_format: z.enum(["tiny", "fat", "none", "unknown"]),
     rva: z.number().int().min(0).max(0xffff_ffff),
     file_offset: offsetSchema.nullable(),
@@ -277,7 +268,6 @@ const managedParseIssueSchema = z.object({
         "invalid-blob",
         "invalid-guid",
         "invalid-resource",
-        "limit-exceeded",
     ]),
     scope: z.string().min(1),
     offset: offsetSchema.nullable(),
@@ -285,7 +275,6 @@ const managedParseIssueSchema = z.object({
 });
 /** Provider-neutral, execution-free PE/CLI triage and identity result. */
 export const managedArtifactInspectionSchema = z.object({
-    schema_version: z.literal(1),
     artifact: z.object({
         path: z.string().min(1),
         sha256: digestSchema,
@@ -297,7 +286,7 @@ export const managedArtifactInspectionSchema = z.object({
         machine_hex: z.string().regex(/^0x[0-9a-f]{4}$/u),
         architecture: z.enum(["x86", "x86_64", "arm", "arm64"]),
         optional_header: z.enum(["pe32", "pe32-plus"]),
-        section_count: z.number().int().min(1).max(96),
+        section_count: z.number().int().min(1).max(0xffff),
         characteristics: z.number().int().min(0).max(0xffff),
         cli: z
             .object({
@@ -364,9 +353,9 @@ export const managedArtifactInspectionSchema = z.object({
     module: moduleIdentitySchema.nullable(),
     assembly: assemblyIdentitySchema.nullable(),
     target_frameworks: z.array(z.string()),
-    references: managedPage(assemblyReferenceSchema),
-    resources: managedPage(managedResourceSchema),
-    attributes: managedPage(customAttributeSchema),
+    references: z.array(assemblyReferenceSchema),
+    resources: z.array(managedResourceSchema),
+    attributes: z.array(customAttributeSchema),
     coverage: z.object({
         state: z.enum(["complete", "partial", "unavailable"]),
         issues: z.array(managedParseIssueSchema),
@@ -375,7 +364,6 @@ export const managedArtifactInspectionSchema = z.object({
 });
 /** Provider-neutral, execution-free metadata/signature/IL member inspection. */
 export const managedMemberInspectionSchema = z.object({
-    schema_version: z.literal(1),
     artifact: z.object({
         path: z.string().min(1),
         sha256: digestSchema,
@@ -393,12 +381,12 @@ export const managedMemberInspectionSchema = z.object({
         requires_artifact_sha256: digestSchema,
         requires_mvid: cliMetadataGuidSchema.nullable(),
     }),
-    types: managedPage(managedTypeSchema),
-    fields: managedPage(managedFieldSchema),
-    methods: managedPage(managedMethodSchema),
-    member_refs: managedPage(managedMemberReferenceSchema),
-    call_edges: managedPage(managedCallEdgeSchema),
-    field_accesses: managedPage(managedFieldAccessSchema),
+    types: z.array(managedTypeSchema),
+    fields: z.array(managedFieldSchema),
+    methods: z.array(managedMethodSchema),
+    member_refs: z.array(managedMemberReferenceSchema),
+    call_edges: z.array(managedCallEdgeSchema),
+    field_accesses: z.array(managedFieldAccessSchema),
     coverage: z.object({
         state: z.enum(["complete", "partial", "unavailable"]),
         issues: z.array(managedParseIssueSchema),
@@ -407,7 +395,6 @@ export const managedMemberInspectionSchema = z.object({
 });
 /** Provider-neutral managed/native boundary observations from PE/CLI metadata. */
 export const managedNativeBoundaryInspectionSchema = z.object({
-    schema_version: z.literal(1),
     artifact: z.object({
         path: z.string().min(1),
         sha256: digestSchema,
@@ -434,9 +421,9 @@ export const managedNativeBoundaryInspectionSchema = z.object({
         managed_native_header_rva: z.number().int().min(0).max(0xffff_ffff),
         managed_native_header_size: z.number().int().min(0).max(0xffff_ffff),
     }),
-    module_refs: managedPage(managedModuleReferenceSchema),
-    pinvoke_imports: managedPage(managedNativeImportSchema),
-    native_implementations: managedPage(managedNativeImplementationSchema),
+    module_refs: z.array(managedModuleReferenceSchema),
+    pinvoke_imports: z.array(managedNativeImportSchema),
+    native_implementations: z.array(managedNativeImplementationSchema),
     summary: z.object({
         module_ref_count: z.number().int().min(0),
         pinvoke_import_count: z.number().int().min(0),

package/dist/domain/managedMemberComparison.js

@@ -1,29 +1,18 @@
 import { z } from "zod";
 import { evidenceSchema } from "./evidence.js";
 import { cliMetadataGuidSchema, } from "./managedArtifact.js";
-import { assessKnownPageCoverage } from "./knownPageCoverage.js";
 import { buildComparisonCoverage, buildComparisonMatching, buildComparisonSummary, comparisonLimitations, sideManifest, } from "./managedMemberComparisonCoverage.js";
-import { buildFieldItems, buildMethodItems, keyMembers, sha256, } from "./managedMemberComparisonMatch.js";
+import { buildFieldItems, buildMethodItems, } from "./managedMemberComparisonItems.js";
+import { keyMembers, sha256 } from "./managedMemberComparisonMatch.js";
 const digestSchema = z.string().regex(/^[a-f0-9]{64}$/u);
 const evidenceIdSchema = z.string().regex(/^ev_[a-f0-9]{64}$/u);
 const tokenSchema = z.string().regex(/^0x[0-9a-f]{8}$/u);
-const boundedTextSchema = z.string().min(1).max(4_096);
-const comparisonLimitsSchema = z.strictObject({
-    max_method_matches: z.number().int().min(1).max(50_000).default(10_000),
-    max_field_matches: z.number().int().min(0).max(50_000).default(5_000),
-    max_candidates: z.number().int().min(1).max(500).default(50),
-});
-/** Two authenticated managed member observations and deterministic bounds. */
+const boundedTextSchema = z.string().min(1);
+/** Two authenticated managed member observations. */
 export const compareManagedMembersInputSchema = z
     .strictObject({
     left: evidenceSchema,
     right: evidenceSchema,
-    limits: comparisonLimitsSchema.default({
-        max_method_matches: 10_000,
-        max_field_matches: 5_000,
-        max_candidates: 50,
-    }),
-    unknown_registry_approved: z.literal(true).optional(),
 })
     .superRefine((input, context) => {
     if (input.left.evidence_id === input.right.evidence_id)
@@ -33,20 +22,33 @@ export const compareManagedMembersInputSchema = z
             message: "Managed member Evidence must be distinct",
         });
 });
-const matchBasisSchema = z.enum([
+const concreteMatchBasisSchema = z.enum([
     "exact-il-signature",
     "structural-method-shape",
     "field-signature",
-    "none",
-]);
-const matchStatusSchema = z.enum(["matched", "unmatched", "ambiguous"]);
-const itemStatusSchema = z.enum([
-    "unchanged",
-    "changed",
-    "added",
-    "removed",
-    "unknown",
 ]);
+const candidateTokensSchema = z.array(tokenSchema).min(1);
+const matchedComparisonSchema = z.strictObject({
+    status: z.literal("matched"),
+    basis: concreteMatchBasisSchema,
+    confidence: z.enum(["exact", "high"]),
+    candidate_left_tokens: z.tuple([]),
+    candidate_right_tokens: z.tuple([]),
+});
+const unmatchedComparisonSchema = z.strictObject({
+    status: z.literal("unmatched"),
+    basis: z.literal("none"),
+    confidence: z.literal("unknown"),
+    candidate_left_tokens: z.tuple([]),
+    candidate_right_tokens: z.tuple([]),
+});
+const ambiguousComparisonSchema = z.strictObject({
+    status: z.literal("ambiguous"),
+    basis: concreteMatchBasisSchema,
+    confidence: z.literal("unknown"),
+    candidate_left_tokens: candidateTokensSchema,
+    candidate_right_tokens: candidateTokensSchema,
+});
 const memberIdentitySchema = z.strictObject({
     token: tokenSchema,
     declaring_type: z.string().nullable(),
@@ -54,20 +56,44 @@ const memberIdentitySchema = z.strictObject({
     signature_sha256: digestSchema,
     normalized_il_sha256: digestSchema.nullable(),
 });
-const methodComparisonItemSchema = z.strictObject({
-    item_id: z.string().regex(/^mmc_method_[a-f0-9]{64}$/u),
-    status: itemStatusSchema,
-    left: memberIdentitySchema.nullable(),
-    right: memberIdentitySchema.nullable(),
-    match: z.strictObject({
-        status: matchStatusSchema,
-        basis: matchBasisSchema,
-        confidence: z.enum(["exact", "high", "unknown"]),
-        candidate_left_tokens: z.array(tokenSchema).max(500),
-        candidate_right_tokens: z.array(tokenSchema).max(500),
+const comparisonItemSchema = (base, identity) => z.union([
+    z.strictObject({
+        ...base,
+        status: z.enum(["unchanged", "changed"]),
+        left: identity,
+        right: identity,
+        match: matchedComparisonSchema,
+    }),
+    z.strictObject({
+        ...base,
+        status: z.enum(["removed", "unknown"]),
+        left: identity,
+        right: z.null(),
+        match: unmatchedComparisonSchema,
+    }),
+    z.strictObject({
+        ...base,
+        status: z.enum(["added", "unknown"]),
+        left: z.null(),
+        right: identity,
+        match: unmatchedComparisonSchema,
     }),
-    dimensions: z
-        .array(z.enum([
+    z.strictObject({
+        ...base,
+        status: z.literal("unknown"),
+        left: z.null(),
+        right: z.null(),
+        match: ambiguousComparisonSchema,
+    }),
+]);
+const comparisonItemContextShape = {
+    evidence_links: z.array(evidenceIdSchema).length(2),
+    limitations: z.array(boundedTextSchema),
+};
+const methodComparisonItemSchema = comparisonItemSchema({
+    ...comparisonItemContextShape,
+    item_id: z.string().regex(/^mmc_method_[a-f0-9]{64}$/u),
+    dimensions: z.array(z.enum([
         "signature",
         "cil",
         "opcode-shape",
@@ -75,33 +101,17 @@ const methodComparisonItemSchema = z.strictObject({
         "field-shape",
         "exception-shape",
         "availability",
-    ]))
-        .max(7),
-    evidence_links: z.array(evidenceIdSchema).length(2),
-    limitations: z.array(boundedTextSchema).max(100),
-});
-const fieldComparisonItemSchema = z.strictObject({
+    ])),
+}, memberIdentitySchema);
+const fieldComparisonItemSchema = comparisonItemSchema({
+    ...comparisonItemContextShape,
     item_id: z.string().regex(/^mmc_field_[a-f0-9]{64}$/u),
-    status: itemStatusSchema,
-    left: memberIdentitySchema.omit({ normalized_il_sha256: true }).nullable(),
-    right: memberIdentitySchema.omit({ normalized_il_sha256: true }).nullable(),
-    match: z.strictObject({
-        status: matchStatusSchema,
-        basis: matchBasisSchema,
-        confidence: z.enum(["exact", "high", "unknown"]),
-        candidate_left_tokens: z.array(tokenSchema).max(500),
-        candidate_right_tokens: z.array(tokenSchema).max(500),
-    }),
-    evidence_links: z.array(evidenceIdSchema).length(2),
-    limitations: z.array(boundedTextSchema).max(100),
-});
+}, memberIdentitySchema.omit({ normalized_il_sha256: true }));
 /** Obfuscation-resistant, execution-free managed member comparison. */
 export const managedMemberComparisonResultSchema = z.strictObject({
-    schema_version: z.literal(1),
     comparison_id: z.string().regex(/^mmc_[a-f0-9]{64}$/u),
     algorithm: z.strictObject({
         name: z.literal("rea-managed-member-comparison"),
-        version: z.literal(1),
         token_identity: z.literal("build-local"),
         name_matching: z.literal("not-used"),
     }),
@@ -137,62 +147,50 @@ export const managedMemberComparisonResultSchema = z.strictObject({
         ambiguous: z.number().int().min(0),
         unmatched: z.number().int().min(0),
     }),
-    methods: z.array(methodComparisonItemSchema).max(50_000),
-    fields: z.array(fieldComparisonItemSchema).max(50_000),
+    methods: z.array(methodComparisonItemSchema),
+    fields: z.array(fieldComparisonItemSchema),
     coverage: z.strictObject({
-        status: z.enum(["complete-within-inputs", "partial", "truncated"]),
+        status: z.enum(["complete-within-inputs", "partial"]),
         left_status: z.enum(["complete", "partial", "unavailable"]),
         right_status: z.enum(["complete", "partial", "unavailable"]),
-        omitted_methods: z.number().int().min(0),
-        omitted_fields: z.number().int().min(0),
-        omitted_candidates: z.number().int().min(0),
     }),
     evidence_links: z.array(evidenceIdSchema).length(2),
-    limitations: z.array(boundedTextSchema).max(1_000),
+    limitations: z.array(boundedTextSchema),
 });
 /** Compare two parsed managed member observations without name-based matching. */
-export const compareManagedMembers = (left, right, limits) => {
-    const leftMethodPage = assessKnownPageCoverage(left.result.methods);
-    const rightMethodPage = assessKnownPageCoverage(right.result.methods);
-    const leftFieldPage = assessKnownPageCoverage(left.result.fields);
-    const rightFieldPage = assessKnownPageCoverage(right.result.fields);
-    const { methodMatches, fieldMatches } = keyMembers(left, right, limits.max_candidates);
+export const compareManagedMembers = (left, right) => {
+    const leftCoverage = {
+        sourceComplete: left.result.coverage.state === "complete",
+    };
+    const rightCoverage = {
+        sourceComplete: right.result.coverage.state === "complete",
+    };
+    const { methodMatches, fieldMatches } = keyMembers(left, right);
     const itemContext = {
         leftEvidenceId: left.evidenceId,
         rightEvidenceId: right.evidenceId,
-        leftComplete: leftMethodPage.sourceComplete && leftFieldPage.sourceComplete,
-        rightComplete: rightMethodPage.sourceComplete && rightFieldPage.sourceComplete,
-        limits,
+        leftComplete: leftCoverage.sourceComplete,
+        rightComplete: rightCoverage.sourceComplete,
     };
     const methodItems = buildMethodItems(methodMatches, itemContext);
     const fieldItems = buildFieldItems(fieldMatches, itemContext);
-    const allItems = [...methodItems.items, ...fieldItems.items];
+    const allItems = [...methodItems, ...fieldItems];
     const summary = buildComparisonSummary(allItems);
-    const matching = buildComparisonMatching(methodItems.items, fieldItems.items);
+    const matching = buildComparisonMatching(methodItems, fieldItems);
     const coverage = buildComparisonCoverage({
         left: left.result,
         right: right.result,
-        leftMethodPage,
-        rightMethodPage,
-        leftFieldPage,
-        rightFieldPage,
-        omittedMethodItems: methodItems.omitted,
-        omittedFieldItems: fieldItems.omitted,
-        omittedCandidates: methodMatches.omittedCandidates + fieldMatches.omittedCandidates,
     });
-    const limitations = comparisonLimitations(left.result, right.result, coverage.omitted_methods + coverage.omitted_fields, coverage.omitted_candidates);
+    const limitations = comparisonLimitations(left.result, right.result);
     const result = {
-        schema_version: 1,
         comparison_id: `mmc_${sha256({
             left: left.evidenceId,
             right: right.evidenceId,
-            methods: [...methodItems.items],
-            fields: [...fieldItems.items],
-            limits,
+            methods: [...methodItems],
+            fields: [...fieldItems],
         })}`,
         algorithm: {
             name: "rea-managed-member-comparison",
-            version: 1,
             token_identity: "build-local",
             name_matching: "not-used",
         },
@@ -200,8 +198,8 @@ export const compareManagedMembers = (left, right, limits) => {
         right: sideManifest(right),
         summary,
         matching,
-        methods: methodItems.items,
-        fields: fieldItems.items,
+        methods: methodItems,
+        fields: fieldItems,
         coverage,
         evidence_links: [left.evidenceId, right.evidenceId],
         limitations,