rea-agents 3.1.0 → 3.2.1

package/dist/domain/replayMachineValues.js

@@ -0,0 +1,84 @@
+/** Compare JSON-compatible replay values without recursive stack growth. */
+export const replayValuesEqual = (left, right) => {
+    const pending = [[left, right]];
+    while (pending.length > 0) {
+        const pair = pending.pop();
+        if (pair === undefined)
+            continue;
+        const [currentLeft, currentRight] = pair;
+        const primitive = equalPrimitiveReplayValues(currentLeft, currentRight);
+        if (primitive !== undefined) {
+            if (!primitive)
+                return false;
+            continue;
+        }
+        const array = compareReplayArrays(currentLeft, currentRight, pending);
+        if (array !== undefined) {
+            if (!array)
+                return false;
+            continue;
+        }
+        if (!compareReplayRecords(currentLeft, currentRight, pending))
+            return false;
+    }
+    return true;
+};
+/** Check that captured values can be serialized as JSON without recursion. */
+export const isJsonCompatible = (value) => {
+    const pending = [value];
+    while (pending.length > 0) {
+        const candidate = pending.pop();
+        if (candidate === null ||
+            typeof candidate === "string" ||
+            typeof candidate === "boolean")
+            continue;
+        if (typeof candidate === "number") {
+            if (!Number.isFinite(candidate))
+                return false;
+            continue;
+        }
+        if (Array.isArray(candidate)) {
+            for (const item of candidate)
+                pending.push(item);
+            continue;
+        }
+        if (typeof candidate !== "object")
+            return false;
+        for (const item of Object.values(candidate))
+            pending.push(item);
+    }
+    return true;
+};
+const equalPrimitiveReplayValues = (left, right) => {
+    if (left === null || typeof left === "string" || typeof left === "boolean")
+        return left === right;
+    if (typeof left !== "number")
+        return undefined;
+    return (Number.isFinite(left) &&
+        left === right &&
+        typeof right === "number" &&
+        Number.isFinite(right));
+};
+const compareReplayArrays = (left, right, pending) => {
+    if (!Array.isArray(left))
+        return undefined;
+    if (!Array.isArray(right) || left.length !== right.length)
+        return false;
+    for (let index = 0; index < left.length; index += 1)
+        pending.push([left[index], right[index]]);
+    return true;
+};
+const compareReplayRecords = (left, right, pending) => {
+    if (typeof left !== "object" || left === null)
+        return undefined;
+    if (typeof right !== "object" || right === null || Array.isArray(right))
+        return false;
+    const leftKeys = Object.keys(left).sort();
+    const rightKeys = Object.keys(right).sort();
+    if (leftKeys.length !== rightKeys.length ||
+        leftKeys.some((key, index) => key !== rightKeys[index]))
+        return false;
+    for (const key of leftKeys)
+        pending.push([Reflect.get(left, key), Reflect.get(right, key)]);
+    return true;
+};

package/dist/domain/residualUnknown.js

@@ -3,18 +3,18 @@ import canonicalize from "canonicalize";
 import { z } from "zod";
 const evidenceIdSchema = z.string().regex(/^ev_[a-f0-9]{64}$/u);
 const unknownIdSchema = z.string().regex(/^unk_[a-f0-9]{64}$/u);
-const boundedText = z.string().trim().min(1).max(1_000);
+const text = z.string().trim().min(1);
 const environmentRequirementSchema = z.object({
-    id: z.string().min(1).max(200).nullable(),
-    platform: z.string().min(1).max(100).nullable(),
-    architecture: z.string().min(1).max(100).nullable(),
+    id: z.string().min(1).nullable(),
+    platform: z.string().min(1).nullable(),
+    architecture: z.string().min(1).nullable(),
     isolation: z
         .enum(["none", "process", "container", "virtual-machine"])
         .nullable(),
 });
 const probeSchema = z.object({
-    operation: z.string().min(1).max(200),
-    rationale: boundedText,
+    operation: z.string().min(1),
+    rationale: text,
 });
 const relationshipSchema = z.object({
     type: z.enum(["depends-on", "related-to", "contradicts"]),
@@ -23,18 +23,17 @@ const relationshipSchema = z.object({
 const resolutionSchema = z.discriminatedUnion("disposition", [
     z.object({
         disposition: z.literal("verified"),
-        rationale: boundedText,
-        evidence_ids: z.array(evidenceIdSchema).min(1).max(100),
+        rationale: text,
+        evidence_ids: z.array(evidenceIdSchema).min(1),
     }),
     z.object({
         disposition: z.enum(["withdrawn", "out-of-scope"]),
-        rationale: boundedText,
-        evidence_ids: z.array(evidenceIdSchema).max(100),
+        rationale: text,
+        evidence_ids: z.array(evidenceIdSchema),
     }),
 ]);
 /** Strict durable record for one unresolved or evidence-qualified question. */
 const residualUnknownObjectSchema = z.object({
-    registry_version: z.literal(1),
     unknown_id: unknownIdSchema,
     revision: z.number().int().min(1),
     previous_revision_digest: z
@@ -46,7 +45,7 @@ const residualUnknownObjectSchema = z.object({
         .string()
         .regex(/^[a-f0-9]{64}$/u)
         .nullable(),
-    question: boundedText,
+    question: text,
     status: z.enum([
         "open",
         "investigating",
@@ -55,9 +54,9 @@ const residualUnknownObjectSchema = z.object({
         "resolved",
     ]),
     severity: z.enum(["low", "medium", "high", "critical"]),
-    domain: z.string().trim().min(1).max(100),
-    supporting_evidence_ids: z.array(evidenceIdSchema).max(100),
-    contradicting_evidence_ids: z.array(evidenceIdSchema).max(100),
+    domain: text,
+    supporting_evidence_ids: z.array(evidenceIdSchema),
+    contradicting_evidence_ids: z.array(evidenceIdSchema),
     required_authority: z
         .enum([
         "shipped-artifact",
@@ -69,10 +68,10 @@ const residualUnknownObjectSchema = z.object({
         .nullable(),
     required_confidence: z.enum(["observed", "derived", "inferred"]),
     required_environment: environmentRequirementSchema.nullable(),
-    recommended_probes: z.array(probeSchema).max(20),
-    relationships: z.array(relationshipSchema).max(100),
+    recommended_probes: z.array(probeSchema),
+    relationships: z.array(relationshipSchema),
     resolution: resolutionSchema.nullable(),
-    mutation_evidence_ids: z.array(evidenceIdSchema).min(1).max(100),
+    mutation_evidence_ids: z.array(evidenceIdSchema).min(1),
 });
 export const residualUnknownSchema = residualUnknownObjectSchema.superRefine((value, context) => {
     if (computeRevisionDigest(value) !== value.revision_digest)
@@ -116,7 +115,8 @@ export const residualUnknownSchema = residualUnknownObjectSchema.superRefine((va
                 code: "custom",
                 message: "Evidence IDs must be unique",
             });
-    if (value.supporting_evidence_ids.some((id) => value.contradicting_evidence_ids.includes(id)))
+    const contradictingEvidence = new Set(value.contradicting_evidence_ids);
+    if (value.supporting_evidence_ids.some((id) => contradictingEvidence.has(id)))
         context.addIssue({
             code: "custom",
             message: "Evidence cannot simultaneously support and contradict",
@@ -132,7 +132,6 @@ export const residualUnknownSchema = residualUnknownObjectSchema.superRefine((va
 /** Input for deterministic creation of one residual unknown. */
 export const recordUnknownInputSchema = residualUnknownObjectSchema
     .omit({
-    registry_version: true,
     unknown_id: true,
     revision: true,
     previous_revision_digest: true,
@@ -145,24 +144,22 @@ export const recordUnknownInputSchema = residualUnknownObjectSchema
     mutation_evidence_ids: true,
 })
     .extend({
-    supporting_evidence_ids: z.array(evidenceIdSchema).max(100).default([]),
-    contradicting_evidence_ids: z.array(evidenceIdSchema).max(100).default([]),
-    approved: z.literal(true),
+    supporting_evidence_ids: z.array(evidenceIdSchema).default([]),
+    contradicting_evidence_ids: z.array(evidenceIdSchema).default([]),
 });
 /** Explicit optimistic-concurrency update command for one unknown. */
 export const updateUnknownInputSchema = z.object({
     unknown_id: unknownIdSchema,
     expected_revision: z.number().int().min(1),
-    approved: z.literal(true),
     status: residualUnknownObjectSchema.shape.status,
     severity: residualUnknownObjectSchema.shape.severity,
-    supporting_evidence_ids: z.array(evidenceIdSchema).max(100),
-    contradicting_evidence_ids: z.array(evidenceIdSchema).max(100),
+    supporting_evidence_ids: z.array(evidenceIdSchema),
+    contradicting_evidence_ids: z.array(evidenceIdSchema),
     required_authority: residualUnknownObjectSchema.shape.required_authority,
     required_confidence: residualUnknownObjectSchema.shape.required_confidence,
     required_environment: environmentRequirementSchema.nullable(),
-    recommended_probes: z.array(probeSchema).max(20),
-    relationships: z.array(relationshipSchema).max(100),
+    recommended_probes: z.array(probeSchema),
+    relationships: z.array(relationshipSchema),
     resolution: resolutionSchema.nullable(),
 });
 /** Create stable identity from immutable question and domain fields. */
@@ -174,7 +171,6 @@ export const createResidualUnknown = (input, mutationEvidenceId, scopeDigest) =>
         scope_digest: scopeDigest,
     });
     const revision = {
-        registry_version: 1,
         unknown_id: `unk_${createHash("sha256").update(identity).digest("hex")}`,
         revision: 1,
         previous_revision_digest: null,
@@ -194,7 +190,6 @@ export const createResidualUnknown = (input, mutationEvidenceId, scopeDigest) =>
 /** Apply a complete, revision-guarded replacement while preserving identity. */
 export const updateResidualUnknown = (current, input, mutationEvidenceId) => {
     const revision = {
-        registry_version: 1,
         unknown_id: current.unknown_id,
         revision: current.revision + 1,
         previous_revision_digest: current.revision_digest,

package/dist/domain/runtimeCharacterization.js

@@ -2,24 +2,24 @@ import { createHash } from "node:crypto";
 import canonicalize from "canonicalize";
 import { z } from "zod";
 const digestSchema = z.string().regex(/^[a-f0-9]{64}$/u);
-const stableIdSchema = z.string().regex(/^[A-Za-z][A-Za-z0-9._:/-]{0,199}$/u);
+const stableIdSchema = z.string().regex(/^[A-Za-z][A-Za-z0-9._:/-]*$/u);
 const runtimeIdentitySchema = z.strictObject({
-    family: z.string().trim().min(1).max(100),
+    family: z.string().trim().min(1),
     provider_id: stableIdSchema,
-    executable_path: z.string().min(1).max(4_096),
+    executable_path: z.string().min(1),
     executable_sha256: digestSchema,
-    version: z.string().trim().min(1).max(500),
+    version: z.string().trim().min(1),
     profile_sha256: digestSchema,
 });
 const artifactIdentitySchema = z.strictObject({
-    path: z.string().min(1).max(4_096),
+    path: z.string().min(1),
     sha256: digestSchema,
     byte_length: z.number().int().min(0).max(Number.MAX_SAFE_INTEGER),
 });
 const callableIdentitySchema = z.strictObject({
     callable_id: stableIdSchema,
     module_id: stableIdSchema,
-    export_name: z.string().min(1).max(1_000),
+    export_name: z.string().min(1),
     semantic_evidence_id: z
         .string()
         .regex(/^ev_[a-f0-9]{64}$/u)
@@ -27,24 +27,23 @@ const callableIdentitySchema = z.strictObject({
     selector_sha256: digestSchema,
 });
 export const runtimeCharacterizationPlanSchema = z.strictObject({
-    schema_version: z.literal(1),
     plan_sha256: digestSchema,
     preparation_sha256: digestSchema,
     artifact: artifactIdentitySchema,
     runtime: runtimeIdentitySchema,
     callable: callableIdentitySchema,
-    working_directory: z.string().min(1).max(4_096),
-    isolated_home: z.string().min(1).max(4_096),
+    working_directory: z.string().min(1),
+    isolated_home: z.string().min(1),
     expected_effect: z.enum(["pure", "bounded-effects", "observation-only"]),
-    allowed_boundaries: z.array(stableIdSchema).max(1_000),
+    allowed_boundaries: z.array(stableIdSchema),
     limits: z.strictObject({
-        max_calls: z.number().int().min(1).max(10_000),
-        max_processes: z.number().int().min(0).max(1_000),
-        max_files: z.number().int().min(0).max(100_000),
+        max_calls: z.number().int().min(1),
+        max_processes: z.number().int().min(0),
+        max_files: z.number().int().min(0),
         max_bytes: z.number().int().min(1).max(Number.MAX_SAFE_INTEGER),
-        max_handles: z.number().int().min(0).max(100_000),
-        timeout_ms: z.number().int().min(1).max(300_000),
-        idle_timeout_ms: z.number().int().min(1).max(300_000),
+        max_handles: z.number().int().min(0),
+        timeout_ms: z.number().int().min(1),
+        idle_timeout_ms: z.number().int().min(1),
     }),
     determinism: z.strictObject({
         clock: z.enum(["fixed", "real"]),

package/dist/domain/runtimeIdentification.js

@@ -14,45 +14,51 @@ const runtimeFamilySchema = z.enum([
     "webassembly",
 ]);
 const observationSchema = z.strictObject({
-    path: z.string().min(1).max(4_096),
+    path: z.string().min(1),
     artifact_id: z.string().regex(/^art_[a-f0-9]{64}$/u),
     sha256: digestSchema,
-    format: z.string().min(1).max(100),
+    format: z.string().min(1),
 });
+const runtimeObservationShape = {
+    family: runtimeFamilySchema,
+    observations: z.array(observationSchema),
+};
+const identifiedRuntimeSchema = z.discriminatedUnion("inspection", [
+    z.strictObject({
+        ...runtimeObservationShape,
+        inspection: z.literal("available"),
+        provider_id: z.string().min(1),
+        reason: z.null(),
+    }),
+    z.strictObject({
+        ...runtimeObservationShape,
+        inspection: z.literal("provider-missing"),
+        provider_id: z.null(),
+        reason: z.string().min(1),
+    }),
+    z.strictObject({
+        ...runtimeObservationShape,
+        inspection: z.literal("provider-selection-required"),
+        provider_id: z.null(),
+        reason: z.string().min(1),
+    }),
+]);
 /** Authenticated artifact inventory pages to classify by runtime family. */
 const runtimeIdentificationInputSchema = z.strictObject({
-    inventory_evidence: z.array(evidenceSchema).min(1).max(100),
-    limits: z
-        .strictObject({
-        max_observations: z.number().int().min(1).max(10_000).default(1_000),
-    })
-        .default({ max_observations: 1_000 }),
+    inventory_evidence: z.array(evidenceSchema).min(1),
 });
 /** Provider-neutral runtime identification with explicit tooling availability. */
 export const runtimeIdentificationResultSchema = z.strictObject({
-    schema_version: z.literal(1),
     identification_id: z.string().regex(/^rid_[a-f0-9]{64}$/u),
     root_sha256: digestSchema,
-    root_format: z.string().min(1).max(100),
-    source_evidence_ids: z.array(evidenceIdSchema).min(1).max(100),
-    runtimes: z.array(z.strictObject({
-        family: runtimeFamilySchema,
-        inspection: z.enum([
-            "available",
-            "provider-missing",
-            "provider-selection-required",
-        ]),
-        provider_id: z.string().min(1).max(200).nullable(),
-        reason: z.string().min(1).max(1_000).nullable(),
-        observations: z.array(observationSchema),
-        omitted_observations: z.number().int().min(0),
-    })),
+    root_format: z.string().min(1),
+    source_evidence_ids: z.array(evidenceIdSchema).min(1),
+    runtimes: z.array(identifiedRuntimeSchema),
     coverage: z.strictObject({
-        status: z.enum(["complete-within-inventory", "partial", "truncated"]),
+        status: z.enum(["complete-within-inventory", "partial"]),
         inventory_complete: z.boolean(),
-        omitted_observations: z.number().int().min(0),
     }),
-    limitations: z.array(z.string().min(1).max(4_096)).max(100),
+    limitations: z.array(z.string().min(1)),
 });
 const PROVIDERS = {
     android: {
@@ -117,24 +123,15 @@ export const identifyRuntimes = (input) => {
                 sha256: rootObservation.sha256,
                 format: rootObservation.format,
             });
-    let remaining = parsed.limits.max_observations;
-    let omitted = 0;
     const runtimes = [...grouped.entries()]
         .sort(([left], [right]) => compare(left, right))
         .map(([family, values]) => {
         const unique = deduplicate(values);
-        const observations = unique.slice(0, remaining);
-        remaining -= observations.length;
-        const omittedObservations = unique.length - observations.length;
-        omitted += omittedObservations;
         const provider = providerFor(family, inventory.manifest.root_format);
         return {
             family,
-            inspection: provider.inspection,
-            provider_id: provider.id,
-            reason: provider.reason,
-            observations,
-            omitted_observations: omittedObservations,
+            ...runtimeInspection(provider),
+            observations: unique,
         };
     });
     const limitations = [
@@ -143,13 +140,9 @@ export const identifyRuntimes = (input) => {
                 "Source inventory pages are incomplete; absent runtimes remain unknown.",
             ]
             : []),
-        ...(omitted > 0
-            ? [`${String(omitted)} runtime observations were omitted by the limit.`]
-            : []),
         "Runtime families are identified from exact artifact formats and paths; semantic claims require the named provider.",
     ];
     const withoutId = {
-        schema_version: 1,
         root_sha256: inventory.manifest.root_sha256,
         root_format: inventory.manifest.root_format,
         source_evidence_ids: evidence
@@ -157,13 +150,10 @@ export const identifyRuntimes = (input) => {
             .sort(compare),
         runtimes,
         coverage: {
-            status: omitted > 0
-                ? "truncated"
-                : inventory.complete
-                    ? "complete-within-inventory"
-                    : "partial",
+            status: inventory.complete
+                ? "complete-within-inventory"
+                : "partial",
             inventory_complete: inventory.complete,
-            omitted_observations: omitted,
         },
         limitations,
     };
@@ -179,6 +169,17 @@ const providerFor = (family, rootFormat) => family === "android" && rootFormat !
         reason: "Extract or select an APK root before using the Android application provider.",
     }
     : PROVIDERS[family];
+const runtimeInspection = (provider) => provider.inspection === "available"
+    ? {
+        inspection: provider.inspection,
+        provider_id: provider.id,
+        reason: null,
+    }
+    : {
+        inspection: provider.inspection,
+        provider_id: null,
+        reason: provider.reason,
+    };
 const familiesFor = (format, path) => {
     const families = new Set();
     if (format === "apk" ||

package/dist/domain/sourceToBundleComparison.js

@@ -8,15 +8,12 @@ export const compareSourceToBundle = (input) => {
     const mappings = compareMappings(input, projection);
     const factors = {
         ...projection.factors,
-        omittedCandidateEvaluations: mappings.omittedCandidateEvaluations,
-        omittedCandidateReferences: mappings.omittedCandidateReferences,
     };
     const mappedCurrentIds = new Set(mappings.items.flatMap(({ current_node_ids: nodeIds }) => nodeIds));
     const unmappedCurrentNodeIds = projection.currentNodes
         .map(({ node_id: nodeId }) => nodeId)
         .filter((nodeId) => !mappedCurrentIds.has(nodeId));
     const semanticResult = {
-        schema_version: 1,
         reference: {
             root_sha256: input.reference.root_sha256,
             inventory_state: input.reference.inventory_state,
@@ -42,10 +39,8 @@ export const compareSourceToBundle = (input) => {
 const projectComparison = (input) => {
     const allSources = historicalSourceFiles(input.reference);
     const allCurrentNodes = sourceBearingNodes(input.application.graph.nodes);
-    const sources = allSources.slice(0, input.limits.max_source_files);
-    const currentNodes = allCurrentNodes.slice(0, input.limits.max_application_nodes);
-    const omittedSourceFiles = allSources.length - sources.length;
-    const omittedApplicationNodes = allCurrentNodes.length - currentNodes.length;
+    const sources = allSources;
+    const currentNodes = allCurrentNodes;
     const index = buildSourceToBundleCandidateIndex(currentNodes);
     return {
         sources,
@@ -53,41 +48,23 @@ const projectComparison = (input) => {
         index,
         absenceComplete: input.reference.inventory_state === "complete" &&
             input.application.graph.coverage.status === "complete" &&
-            !input.application.graph.coverage.truncated &&
-            omittedSourceFiles === 0 &&
-            omittedApplicationNodes === 0 &&
-            !index.pathIndexTruncated,
+            !input.application.graph.coverage.truncated,
         factors: {
             input,
-            omittedSourceFiles,
-            omittedApplicationNodes,
-            omittedCandidateEvaluations: 0,
-            omittedCandidateReferences: 0,
-            pathIndexTruncated: index.pathIndexTruncated,
         },
     };
 };
 const compareMappings = (input, projection) => {
-    let evaluationsRemaining = input.limits.max_candidate_evaluations;
     let candidateEvaluations = 0;
-    let omittedCandidateEvaluations = 0;
-    let omittedCandidateReferences = 0;
     const provisionalItems = [];
     for (const source of projection.sources) {
         const candidateIds = candidateIdsForSource(source, projection.index);
-        const retainedIds = candidateIds.slice(0, evaluationsRemaining);
-        const omittedEvaluations = candidateIds.length - retainedIds.length;
-        evaluationsRemaining -= retainedIds.length;
-        candidateEvaluations += retainedIds.length;
-        omittedCandidateEvaluations += omittedEvaluations;
-        const scored = retainedIds
+        candidateEvaluations += candidateIds.length;
+        const scored = candidateIds
             .map((nodeId) => scoreSourceToBundleCandidate(source, nodeId, projection.index))
             .filter((candidate) => candidate !== null)
             .sort(compareCandidates);
-        const retainedCandidates = scored.slice(0, input.limits.max_candidate_nodes);
-        const omittedCandidates = omittedEvaluations + scored.length - retainedCandidates.length;
-        omittedCandidateReferences += omittedCandidates;
-        const classification = classifyMapping(retainedCandidates, omittedCandidates === 0, projection.absenceComplete);
+        const classification = classifyMapping(scored, projection.absenceComplete);
         const semantic = {
             source_path: source.path,
             source_sha256: source.sha256,
@@ -95,16 +72,10 @@ const compareMappings = (input, projection) => {
             status: classification.status,
             confidence: classification.confidence,
             current_node_ids: classification.currentNodeIds,
-            candidates: retainedCandidates,
-            omitted_candidates: omittedCandidates,
+            candidates: scored,
             limitations: uniqueSorted([
                 ...source.limitations,
                 ...classification.limitations,
-                ...(omittedCandidates > 0
-                    ? [
-                        `${String(omittedCandidates)} candidate references were omitted by comparison limits.`,
-                    ]
-                    : []),
             ]),
         };
         provisionalItems.push({
@@ -115,8 +86,6 @@ const compareMappings = (input, projection) => {
     return {
         items: markMergedMappings(input, provisionalItems),
         candidateEvaluations,
-        omittedCandidateEvaluations,
-        omittedCandidateReferences,
     };
 };
 const comparisonCoverage = (projection, mappings, factors) => ({
@@ -124,32 +93,18 @@ const comparisonCoverage = (projection, mappings, factors) => ({
     reference_inventory_state: factors.input.reference.inventory_state,
     application_graph_status: factors.input.application.graph.coverage.status,
     retained_source_files: projection.sources.length,
-    omitted_source_files: factors.omittedSourceFiles,
     retained_application_nodes: projection.currentNodes.length,
-    omitted_application_nodes: factors.omittedApplicationNodes,
     candidate_evaluations: mappings.candidateEvaluations,
-    omitted_candidate_evaluations: mappings.omittedCandidateEvaluations,
-    omitted_candidate_references: mappings.omittedCandidateReferences,
-    omitted_unmapped_current_nodes: 0,
 });
 const scoringModel = () => ({
-    algorithm: "rea-source-to-bundle-signals/v1",
+    algorithm: "rea-source-to-bundle-signals",
     minimum_candidate_score: 20,
     weights: SOURCE_TO_BUNDLE_SIGNAL_WEIGHTS.map(([signal, weight]) => ({
         signal,
         weight,
     })),
 });
-const classifyMapping = (candidates, evaluationComplete, absenceComplete) => {
-    if (!evaluationComplete)
-        return {
-            status: "unknown",
-            confidence: "unknown",
-            currentNodeIds: [],
-            limitations: [
-                "Candidate evaluation stopped at the declared limit; a stronger match may be omitted.",
-            ],
-        };
+const classifyMapping = (candidates, absenceComplete) => {
     const exact = candidates.filter((candidate) => hasSignal(candidate, "exact-source-digest"));
     if (exact.length === 1)
         return {
@@ -271,12 +226,6 @@ const comparisonSummary = (items) => ({
 });
 const countStatus = (items, status) => items.filter((item) => item.status === status).length;
 const coverageStatus = (factors) => {
-    if (factors.omittedSourceFiles > 0 ||
-        factors.omittedApplicationNodes > 0 ||
-        factors.omittedCandidateEvaluations > 0 ||
-        factors.omittedCandidateReferences > 0 ||
-        factors.pathIndexTruncated)
-        return "truncated";
     return factors.input.reference.inventory_state === "complete" &&
         factors.input.application.graph.coverage.status === "complete"
         ? "complete-within-inputs"
@@ -296,31 +245,6 @@ const comparisonLimitations = (factors) => uniqueSorted([
         : [
             `Application graph coverage is ${factors.input.application.graph.coverage.status}; unmatched files remain unknown.`,
         ]),
-    ...(factors.omittedSourceFiles > 0
-        ? [
-            `${String(factors.omittedSourceFiles)} historical source files were omitted by max_source_files.`,
-        ]
-        : []),
-    ...(factors.omittedApplicationNodes > 0
-        ? [
-            `${String(factors.omittedApplicationNodes)} source-bearing application nodes were omitted by max_application_nodes.`,
-        ]
-        : []),
-    ...(factors.omittedCandidateEvaluations > 0
-        ? [
-            `${String(factors.omittedCandidateEvaluations)} candidate evaluations were omitted by max_candidate_evaluations.`,
-        ]
-        : []),
-    ...(factors.omittedCandidateReferences > 0
-        ? [
-            `${String(factors.omittedCandidateReferences)} candidate references were omitted from item output.`,
-        ]
-        : []),
-    ...(factors.pathIndexTruncated
-        ? [
-            "At least one current path exceeded the 128-segment suffix index bound.",
-        ]
-        : []),
 ]);
 const hasSignal = (candidate, kind) => candidate.signals.some((signal) => signal.kind === kind);
 const compareCandidates = (left, right) => right.score - left.score ||