rea-agents 3.0.0 → 3.2.0

package/dist/domain/reconstructionObligationLedgerSchemas.js

@@ -3,8 +3,8 @@ import { z } from "zod";
 import { evidenceBundleSchema } from "./evidenceBundle.js";
 const digestSchema = z.string().regex(/^[a-f0-9]{64}$/u);
 const evidenceIdSchema = z.string().regex(/^ev_[a-f0-9]{64}$/u);
-const stableIdSchema = z.string().regex(/^[A-Za-z][A-Za-z0-9._:/-]{0,199}$/u);
-const boundedTextSchema = z.string().trim().min(1).max(4_096);
+const stableIdSchema = z.string().regex(/^[A-Za-z][A-Za-z0-9._:/-]*$/u);
+const textSchema = z.string().trim().min(1);
 export const obligationStatusSchema = z.enum([
     "unowned",
     "characterized",
@@ -60,7 +60,7 @@ const obligationTargetSchema = z.strictObject({
         .string()
         .regex(/^jsrg_node_[a-f0-9]{64}$/u)
         .nullable(),
-    location: boundedTextSchema,
+    location: textSchema,
 });
 const authorityReferenceSchema = z.strictObject({
     evidence_id: evidenceIdSchema,
@@ -72,80 +72,77 @@ const authorityReferenceSchema = z.strictObject({
         "analyst-inference",
     ]),
     state: z.enum(["candidate", "observed", "reviewed", "unknown"]),
-    location: boundedTextSchema,
+    location: textSchema,
 });
 const observedCaseSchema = z.strictObject({
     kind: obligationCaseKindSchema,
     evidence_id: evidenceIdSchema,
-    location: boundedTextSchema,
+    location: textSchema,
 });
 const ownerBindingSchema = z.strictObject({
-    module_path: boundedTextSchema,
-    symbol: z.string().trim().min(1).max(1_024),
+    module_path: textSchema,
+    symbol: textSchema,
     owner_sha256: digestSchema,
 });
 const parserTypeBindingSchema = z.strictObject({
-    parser: boundedTextSchema,
-    schema: boundedTextSchema,
-    domain_type: boundedTextSchema,
+    parser: textSchema,
+    schema: textSchema,
+    domain_type: textSchema,
 });
 const fixtureBindingSchema = z.strictObject({
     fixture_id: stableIdSchema,
     case_kind: obligationCaseKindSchema,
     authority: obligationProofAuthoritySchema,
-    evidence_ids: z.array(evidenceIdSchema).min(1).max(100),
+    evidence_ids: z.array(evidenceIdSchema).min(1),
 });
 const nondeterminismSchema = z.strictObject({
     mode: z.enum(["total-order", "partial-order", "finite-traces"]),
-    specification: boundedTextSchema,
+    specification: textSchema,
 });
 const verifierBindingSchema = z.strictObject({
     verifier_id: stableIdSchema,
     claim_id: stableIdSchema,
-    command: boundedTextSchema,
+    command: textSchema,
     authority: obligationProofAuthoritySchema,
     status: z.enum(["pass", "fail", "unknown", "unsupported", "skipped"]),
     result_evidence_id: evidenceIdSchema,
-    enumerated_obligation_ids: z.array(stableIdSchema).min(1).max(10_000),
+    enumerated_obligation_ids: z.array(stableIdSchema).min(1),
     nondeterminism: nondeterminismSchema,
 });
 export const reconstructionObligationManifestBindingSchema = z.strictObject({
     obligation_id: stableIdSchema,
     owner: ownerBindingSchema,
     parser_type: parserTypeBindingSchema.nullable(),
-    original_cases: z.array(observedCaseSchema).max(100),
-    fixtures: z.array(fixtureBindingSchema).max(100),
+    original_cases: z.array(observedCaseSchema),
+    fixtures: z.array(fixtureBindingSchema),
     verifier: verifierBindingSchema.nullable(),
 });
 export const reconstructionObligationManifestSchema = z.strictObject({
-    schema_version: z.literal(1),
-    bindings: z.array(reconstructionObligationManifestBindingSchema).max(10_000),
-    contradictions: z
-        .array(z.strictObject({
+    bindings: z.array(reconstructionObligationManifestBindingSchema),
+    contradictions: z.array(z.strictObject({
         obligation_id: stableIdSchema,
-        evidence_ids: z.array(evidenceIdSchema).min(2).max(100),
-    }))
-        .max(10_000),
+        evidence_ids: z.array(evidenceIdSchema).min(2),
+    })),
 });
 export const reviewedReconstructionObligationSchema = z.strictObject({
     obligation_id: stableIdSchema,
     obligation_version: z.number().int().min(1),
-    title: z.string().trim().min(1).max(500),
+    title: textSchema,
     application_layer: obligationLayerSchema,
-    family: z.string().trim().min(1).max(100),
+    family: textSchema,
     target: obligationTargetSchema,
     required: z.boolean(),
-    required_case_kinds: z.array(obligationCaseKindSchema).min(1).max(5),
+    required_case_kinds: z.array(obligationCaseKindSchema).min(1),
     required_original_authority: obligationOriginalAuthoritySchema,
     required_fixture_authority: obligationProofAuthoritySchema,
     required_verifier_authority: obligationProofAuthoritySchema,
     requires_parser_type: z.boolean(),
-    dependency_obligation_ids: z.array(stableIdSchema).max(1_000),
-    residual_unknown_ids: z.array(stableIdSchema).max(1_000),
-    unavailable_authority: z.array(boundedTextSchema).max(100),
-    required_next_evidence: z.array(boundedTextSchema).max(100),
+    dependency_obligation_ids: z.array(stableIdSchema),
+    residual_unknown_ids: z.array(stableIdSchema),
+    unavailable_authority: z.array(textSchema),
+    required_next_evidence: z.array(textSchema),
     disposition: z.enum(["active", "blocked", "out-of-scope"]),
-    review_evidence_ids: z.array(evidenceIdSchema).min(1).max(100),
+    review_evidence_ids: z.array(evidenceIdSchema).min(1),
 });
 const diagnosticSchema = z.strictObject({
     code: z.enum([
@@ -172,32 +169,32 @@ const diagnosticSchema = z.strictObject({
         "blocked",
         "out-of-scope",
     ]),
-    detail: boundedTextSchema,
+    detail: textSchema,
 });
 export const reconstructionObligationSchema = z.strictObject({
     obligation_id: stableIdSchema,
     obligation_version: z.number().int().min(1),
-    title: z.string().trim().min(1).max(500),
+    title: textSchema,
     origin: z.enum(["generated", "reviewed"]),
     application_layer: obligationLayerSchema,
-    family: z.string().trim().min(1).max(100),
+    family: textSchema,
     target: obligationTargetSchema,
-    authority_references: z.array(authorityReferenceSchema).min(1).max(1_000),
+    authority_references: z.array(authorityReferenceSchema).min(1),
     source_state: z.enum(["candidate", "observed", "reviewed", "unknown"]),
-    observed_cases: z.array(observedCaseSchema).max(100),
+    observed_cases: z.array(observedCaseSchema),
     required: z.boolean(),
-    required_case_kinds: z.array(obligationCaseKindSchema).min(1).max(5),
+    required_case_kinds: z.array(obligationCaseKindSchema).min(1),
     required_original_authority: obligationOriginalAuthoritySchema,
     required_fixture_authority: obligationProofAuthoritySchema,
     required_verifier_authority: obligationProofAuthoritySchema,
     requires_parser_type: z.boolean(),
-    dependency_obligation_ids: z.array(stableIdSchema).max(1_000),
-    residual_unknown_ids: z.array(stableIdSchema).max(1_000),
-    unavailable_authority: z.array(boundedTextSchema).max(100),
-    required_next_evidence: z.array(boundedTextSchema).max(100),
+    dependency_obligation_ids: z.array(stableIdSchema),
+    residual_unknown_ids: z.array(stableIdSchema),
+    unavailable_authority: z.array(textSchema),
+    required_next_evidence: z.array(textSchema),
     binding: reconstructionObligationManifestBindingSchema.nullable(),
     status: obligationStatusSchema,
-    diagnostics: z.array(diagnosticSchema).max(1_000),
+    diagnostics: z.array(diagnosticSchema),
 });
 const countBySchema = (key) => z.array(z.strictObject({
     key,
@@ -205,15 +202,11 @@ const countBySchema = (key) => z.array(z.strictObject({
 }));
 export const reconstructionObligationLedgerSchema = z.strictObject({
     schema: z.literal("ReconstructionObligationLedger"),
-    schema_version: z.literal(1),
     ledger_id: z.string().regex(/^rol_[a-f0-9]{64}$/u),
     closure_digest: digestSchema,
     status: z.enum(["ready", "open", "failed", "unknown"]),
     coverage: z.strictObject({
         status: z.enum(["complete", "partial"]),
-        truncated: z.boolean(),
-        omitted_count: z.number().int().min(0),
-        max_obligations: z.number().int().min(1),
     }),
     summary: z.strictObject({
         total: z.number().int().min(0),
@@ -232,41 +225,21 @@ export const reconstructionObligationLedgerSchema = z.strictObject({
     }),
     ownership_graph: z.array(z.strictObject({
         obligation_id: stableIdSchema,
-        module_path: boundedTextSchema,
-        symbol: z.string().trim().min(1).max(1_024),
+        module_path: textSchema,
+        symbol: textSchema,
     })),
     dependency_graph: z.array(z.strictObject({
         obligation_id: stableIdSchema,
         depends_on_obligation_id: stableIdSchema,
     })),
-    obligations: z.array(reconstructionObligationSchema).max(10_000),
-    evidence_links: z.array(evidenceIdSchema).max(100_000),
-    limitations: z.array(boundedTextSchema).max(1_000),
+    obligations: z.array(reconstructionObligationSchema),
+    evidence_links: z.array(evidenceIdSchema),
+    limitations: z.array(textSchema),
 });
 export const reconstructionObligationLedgerInputSchema = z.strictObject({
     evidence_bundle: evidenceBundleSchema,
-    reviewed_obligations: z
-        .array(reviewedReconstructionObligationSchema)
-        .max(10_000),
+    reviewed_obligations: z.array(reviewedReconstructionObligationSchema),
     manifest: reconstructionObligationManifestSchema,
-    limits: z.strictObject({
-        max_obligations: z.number().int().min(1).max(10_000),
-    }),
-    page: z.strictObject({
-        offset: z.number().int().min(0).max(10_000),
-        limit: z.number().int().min(1).max(100),
-    }),
-});
-export const reconstructionObligationLedgerPageSchema = z.strictObject({
-    ...reconstructionObligationLedgerSchema.omit({ obligations: true }).shape,
-    page: z.strictObject({
-        offset: z.number().int().min(0),
-        limit: z.number().int().min(1).max(100),
-        total: z.number().int().min(0),
-        returned: z.number().int().min(0),
-        next_offset: z.number().int().min(0).nullable(),
-    }),
-    obligations: z.array(reconstructionObligationSchema).max(100),
 });
 /** Parse and canonically serialize one complete reconstruction obligation ledger. */
 export const serializeReconstructionObligationLedger = (input) => {

package/dist/domain/reconstructionReadiness.js

@@ -34,12 +34,11 @@ export const createReconstructionReadinessReport = (inputValue) => {
         snapshot: input,
     };
     const reportDigest = digest({
-        schema: "rea.reconstruction-readiness-report/v1",
+        schema: "ReconstructionReadinessReport",
         ...semantic,
     });
     return reconstructionReadinessReportSchema.parse({
         schema: "ReconstructionReadinessReport",
-        schema_version: 1,
         report_id: `rr_${reportDigest}`,
         report_digest: reportDigest,
         ...semantic,

package/dist/domain/reconstructionReadinessSchemas.js

@@ -3,8 +3,8 @@ import { evidenceBundleSchema } from "./evidenceBundle.js";
 import { reconstructionObligationLedgerSchema } from "./reconstructionObligationLedgerSchemas.js";
 const digestSchema = z.string().regex(/^[a-f0-9]{64}$/u);
 const evidenceIdSchema = z.string().regex(/^ev_[a-f0-9]{64}$/u);
-const stableIdSchema = z.string().regex(/^[A-Za-z][A-Za-z0-9._:/-]{0,199}$/u);
-const boundedTextSchema = z.string().trim().min(1).max(4_096);
+const stableIdSchema = z.string().regex(/^[A-Za-z][A-Za-z0-9._:/-]*$/u);
+const boundedTextSchema = z.string().trim().min(1);
 export const readinessStatusSchema = z.enum([
     "pass",
     "fail",
@@ -54,8 +54,8 @@ const capabilitySchema = z.strictObject({
         "writes-workspace",
         "network-observation",
     ]),
-    authority_scopes: z.array(stableIdSchema).max(100),
-    limits: z.array(limitSchema).max(100),
+    authority_scopes: z.array(stableIdSchema),
+    limits: z.array(limitSchema),
     unavailable_reason: boundedTextSchema.nullable(),
 });
 const fixtureSchema = z.strictObject({
@@ -69,7 +69,7 @@ const fixtureSchema = z.strictObject({
     ]),
     artifact_sha256: digestSchema,
     environment_id: stableIdSchema,
-    deliberate_faults: z.array(stableIdSchema).min(1).max(100),
+    deliberate_faults: z.array(stableIdSchema).min(1),
 });
 const workflowCandidateSchema = z.strictObject({
     fixture_id: stableIdSchema,
@@ -85,7 +85,7 @@ const grantSchema = z.strictObject({
     scope: stableIdSchema,
     decision: z.enum(["granted", "denied", "cancelled", "restart-required"]),
     launched_process: z.boolean(),
-    evidence_ids: z.array(evidenceIdSchema).max(100),
+    evidence_ids: z.array(evidenceIdSchema),
 });
 const comparisonSchema = z.strictObject({
     comparison_id: stableIdSchema,
@@ -96,17 +96,17 @@ const comparisonSchema = z.strictObject({
     unavailable_authority: z.boolean(),
     unstable: z.boolean(),
     deliberate_divergence_ref: boundedTextSchema.nullable(),
-    divergence_refs: z.array(boundedTextSchema).max(100),
-    contradiction_ids: z.array(stableIdSchema).max(100),
-    evidence_ids: z.array(evidenceIdSchema).min(1).max(1_000),
+    divergence_refs: z.array(boundedTextSchema),
+    contradiction_ids: z.array(stableIdSchema),
+    evidence_ids: z.array(evidenceIdSchema).min(1),
 });
 const contradictionSchema = z.strictObject({
     contradiction_id: stableIdSchema,
     declared_sha256: digestSchema,
     observed_sha256: digestSchema,
     policy: z.literal("record-and-continue"),
-    affected_comparison_ids: z.array(stableIdSchema).min(1).max(100),
-    evidence_ids: z.array(evidenceIdSchema).min(2).max(100),
+    affected_comparison_ids: z.array(stableIdSchema).min(1),
+    evidence_ids: z.array(evidenceIdSchema).min(2),
 });
 const operationOutcomeSchema = z.strictObject({
     sequence: z.number().int().min(0),
@@ -126,32 +126,32 @@ const operationOutcomeSchema = z.strictObject({
     mcp_status: z.enum(["success", "non-success"]).nullable(),
     error_code: stableIdSchema.nullable(),
     recovered: z.boolean(),
-    evidence_ids: z.array(evidenceIdSchema).max(100),
+    evidence_ids: z.array(evidenceIdSchema),
 });
 const cleanupSchema = z.strictObject({
     run_id: stableIdSchema,
     cancelled: z.boolean(),
     owned_resources_remaining: z.number().int().min(0),
-    diagnostic_evidence_ids: z.array(evidenceIdSchema).max(100),
+    diagnostic_evidence_ids: z.array(evidenceIdSchema),
 });
 const closureObservationSchema = z.strictObject({
     sequence: z.number().int().min(0),
     ledger_digest: digestSchema,
     status: z.enum(["ready", "open", "failed", "unknown"]),
     required_open: z.number().int().min(0),
-    newly_verified_obligation_ids: z.array(stableIdSchema).max(10_000),
-    evidence_ids: z.array(evidenceIdSchema).min(1).max(1_000),
+    newly_verified_obligation_ids: z.array(stableIdSchema),
+    evidence_ids: z.array(evidenceIdSchema).min(1),
 });
 const delegationCheckSchema = z.strictObject({
     candidate_id: stableIdSchema,
     delegates_to_authority: z.boolean(),
-    evidence_ids: z.array(evidenceIdSchema).min(1).max(100),
+    evidence_ids: z.array(evidenceIdSchema).min(1),
 });
 const stageCheckSchema = z.strictObject({
     check_id: stableIdSchema,
     status: readinessStatusSchema,
     detail: boundedTextSchema,
-    evidence_ids: z.array(evidenceIdSchema).max(100),
+    evidence_ids: z.array(evidenceIdSchema),
 });
 const stageSchema = z.strictObject({
     stage_id: readinessStageIdSchema,
@@ -159,56 +159,68 @@ const stageSchema = z.strictObject({
     status: readinessStatusSchema,
     capability_issue: stableIdSchema.nullable(),
     next_action: boundedTextSchema.nullable(),
-    evidence_ids: z.array(evidenceIdSchema).max(1_000),
-    checks: z.array(stageCheckSchema).max(100),
+    evidence_ids: z.array(evidenceIdSchema),
+    checks: z.array(stageCheckSchema),
 });
 const replaySchema = z.strictObject({
     expected_source_digest: digestSchema.nullable(),
     deterministic: z.boolean(),
     tamper_detected: z.boolean(),
     stale_input_detected: z.boolean(),
-    evidence_ids: z.array(evidenceIdSchema).max(100),
+    evidence_ids: z.array(evidenceIdSchema),
 });
 export const reconstructionReadinessInputSchema = z.strictObject({
-    schema_version: z.literal(1),
     identity: z.strictObject({
         cli_version: boundedTextSchema,
         server_version: boundedTextSchema,
         catalog_digest: digestSchema,
         skill_digest: digestSchema.nullable(),
-        versions: z.array(versionObservationSchema).min(1).max(100),
-        providers: z.array(providerIdentitySchema).max(100),
+        versions: z.array(versionObservationSchema).min(1),
+        providers: z.array(providerIdentitySchema),
     }),
     client: z.strictObject({
         name: boundedTextSchema,
         version: boundedTextSchema,
-        negotiated_capabilities: z.array(stableIdSchema).max(100),
+        negotiated_capabilities: z.array(stableIdSchema),
     }),
-    capabilities: z.array(capabilitySchema).min(1).max(1_000),
-    fixtures: z.array(fixtureSchema).min(1).max(100),
-    workflow_candidates: z.array(workflowCandidateSchema).min(1).max(1_000),
-    grants: z.array(grantSchema).max(1_000),
+    capabilities: z.array(capabilitySchema).min(1),
+    fixtures: z.array(fixtureSchema).min(1),
+    workflow_candidates: z.array(workflowCandidateSchema).min(1),
+    grants: z.array(grantSchema),
     evidence_bundle: evidenceBundleSchema,
-    comparisons: z.array(comparisonSchema).max(1_000),
-    contradictions: z.array(contradictionSchema).max(1_000),
+    comparisons: z.array(comparisonSchema),
+    contradictions: z.array(contradictionSchema),
     obligation_ledger: reconstructionObligationLedgerSchema,
-    operation_outcomes: z.array(operationOutcomeSchema).max(10_000),
-    cleanup: z.array(cleanupSchema).max(1_000),
-    closure_history: z.array(closureObservationSchema).min(2).max(1_000),
-    delegation_checks: z.array(delegationCheckSchema).min(1).max(1_000),
+    operation_outcomes: z.array(operationOutcomeSchema),
+    cleanup: z.array(cleanupSchema),
+    closure_history: z.array(closureObservationSchema).min(2),
+    delegation_checks: z.array(delegationCheckSchema).min(1),
     replay: replaySchema,
-    stages: z.array(stageSchema).max(20),
+    stages: z
+        .array(stageSchema)
+        .length(9)
+        .superRefine((stages, context) => {
+        const seen = new Set();
+        stages.forEach((stage, index) => {
+            if (seen.has(stage.stage_id))
+                context.addIssue({
+                    code: "custom",
+                    path: [index, "stage_id"],
+                    message: "Readiness stage IDs must be unique",
+                });
+            seen.add(stage.stage_id);
+        });
+    }),
 });
 const findingSchema = z.strictObject({
     code: stableIdSchema,
     stage_id: readinessStageIdSchema,
     status: z.enum(["fail", "unknown"]),
     detail: boundedTextSchema,
-    evidence_ids: z.array(evidenceIdSchema).max(100),
+    evidence_ids: z.array(evidenceIdSchema),
 });
 export const reconstructionReadinessReportSchema = z.strictObject({
     schema: z.literal("ReconstructionReadinessReport"),
-    schema_version: z.literal(1),
     report_id: z.string().regex(/^rr_[a-f0-9]{64}$/u),
     source_digest: digestSchema,
     report_digest: digestSchema,
@@ -233,8 +245,22 @@ export const reconstructionReadinessReportSchema = z.strictObject({
         cleanup_leak_count: z.number().int().min(0),
         nondeterministic_replay_count: z.number().int().min(0),
     }),
-    stages: z.array(stageSchema).max(20),
-    findings: z.array(findingSchema).max(10_000),
-    evidence_links: z.array(evidenceIdSchema).max(100_000),
+    stages: z
+        .array(stageSchema)
+        .length(9)
+        .superRefine((stages, context) => {
+        const seen = new Set();
+        stages.forEach((stage, index) => {
+            if (seen.has(stage.stage_id))
+                context.addIssue({
+                    code: "custom",
+                    path: [index, "stage_id"],
+                    message: "Readiness stage IDs must be unique",
+                });
+            seen.add(stage.stage_id);
+        });
+    }),
+    findings: z.array(findingSchema),
+    evidence_links: z.array(evidenceIdSchema),
     snapshot: reconstructionReadinessInputSchema,
 });

package/dist/domain/reconstructionUnknowns.js

@@ -45,7 +45,7 @@ export const reconstructionClaimUnknowns = (heads, comparisonId, sourceIds) => {
     })
         .sort((left, right) => left.unknown_id.localeCompare(right.unknown_id, "en"));
 };
-/** Aggregate and bound deterministic probes for unresolved claims. */
+/** Aggregate deterministic probes for unresolved claims. */
 export const reconstructionProbes = (results, heads) => {
     const output = new Map();
     for (const result of results.filter(({ status }) => status === "unknown")) {
@@ -71,7 +71,7 @@ export const reconstructionProbes = (results, heads) => {
         }
     }
     const sorted = [...output.values()].sort((left, right) => `${left.operation}\0${left.rationale}`.localeCompare(`${right.operation}\0${right.rationale}`, "en"));
-    return { items: sorted.slice(0, 2_000), truncated: sorted.length > 2_000 };
+    return sorted;
 };
 const defaultProbe = (kind) => kind === "behavioral"
     ? {
@@ -84,7 +84,7 @@ const defaultProbe = (kind) => kind === "behavioral"
             rationale: "Capture complete function dossiers under equal limits.",
         }
         : {
-            operation: "inventory_artifact",
+            operation: "inspect_artifact",
             rationale: "Capture complete artifact inventories under equal limits.",
         };
 const uniqueSorted = (values) => [...new Set(values)].sort((left, right) => left.localeCompare(right, "en"));

package/dist/domain/reconstructionVerification.js

@@ -12,51 +12,40 @@ import { reconstructionClaimResultSchema, reconstructionSpecificationSchema, rec
 import { reconstructionClaimUnknowns, reconstructionProbes, reconstructionUnknownHeads, } from "./reconstructionUnknowns.js";
 const evidenceIdSchema = z.string().regex(/^ev_[a-f0-9]{64}$/u);
 export { reconstructionVerificationInputSchema, reconstructionVerificationResultSchema, } from "./reconstructionVerificationSchemas.js";
-const MAX_BUNDLE_RECORDS = 20_100;
-const MAX_UNKNOWN_REVISIONS = 10_000;
-const MAX_CANONICAL_BYTES = 32 * 1024 * 1024;
 const providers = {
     behavioral: {
         operation: "compare_process_captures",
-        predicates: ["rea.process-comparison/v3", "rea.process-comparison/v4"],
+        predicates: ["rea.process-comparison"],
         id: "rea-process",
         name: "REA deterministic process harness",
     },
     "structural-function": {
         operation: "compare_functions",
-        predicates: ["rea.function-comparison/v1"],
+        predicates: ["rea.function-comparison"],
         id: "rea-function-comparison",
         name: "REA function comparison",
     },
     "structural-artifact": {
         operation: "compare_artifacts",
-        predicates: ["rea.artifact-comparison/v1"],
+        predicates: ["rea.artifact-comparison"],
         id: "rea-artifact-comparison",
         name: "REA artifact comparison",
     },
 };
 const acceptsPredicate = (expected, actual) => expected.some((predicate) => predicate === actual);
 /** Verify only explicitly declared claims; no global equivalence is inferred. */
-export const verifyReconstruction = (specificationInput, bundleInput, offset, limit) => {
+export const verifyReconstruction = (specificationInput, bundleInput) => {
     const specification = reconstructionSpecificationSchema.parse(specificationInput);
-    enforceInputSize(bundleInput);
     const bundle = parseEvidenceBundle(bundleInput);
-    if (bundle.records.length > MAX_BUNDLE_RECORDS)
-        throw new TypeError("Reconstruction Evidence record limit exceeded");
-    if (bundle.unknowns.length > MAX_UNKNOWN_REVISIONS)
-        throw new TypeError("Reconstruction unknown revision limit exceeded");
     const records = new Map(bundle.records.map((item) => [item.evidence_id, item]));
     const heads = reconstructionUnknownHeads(bundle.unknowns);
     const results = specification.claims
         .map((claim) => evaluateClaim(claim, records, heads))
         .sort((left, right) => left.claim_id.localeCompare(right.claim_id, "en"));
-    const page = results.slice(offset, offset + limit);
     const failed = count(results, "fail");
     const unresolved = count(results, "unknown");
     const probes = reconstructionProbes(results, heads);
     const evidenceLinks = uniqueSorted(results.flatMap(({ evidence_links: links }) => links));
-    if (evidenceLinks.length > 20_100)
-        throw new TypeError("Reconstruction Evidence closure exceeds limit");
     const output = {
         status: failed > 0 ? "fail" : unresolved > 0 ? "unknown" : "pass",
         specification_sha256: digest({
@@ -72,19 +61,12 @@ export const verifyReconstruction = (specificationInput, bundleInput, offset, li
             structural: results.filter(({ kind }) => kind !== "behavioral").length,
         },
         claims: {
-            items: page,
-            offset,
-            limit,
-            total: results.length,
-            next_offset: offset + page.length < results.length ? offset + page.length : null,
+            items: results,
         },
-        recommended_probes: probes.items,
+        recommended_probes: probes,
         evidence_links: evidenceLinks,
         limitations: [
             "Pass means every declared claim passed; it does not establish global implementation equivalence.",
-            ...(probes.truncated
-                ? ["Recommended probes were truncated at the 2,000-item limit."]
-                : []),
         ],
     };
     return reconstructionVerificationResultSchema.parse(output);
@@ -111,8 +93,7 @@ const evaluateClaim = (claim, records, heads) => {
     const limitations = authorityLimitations(claim, sources, sides);
     const relevantUnknowns = reconstructionClaimUnknowns(heads, comparison.evidence_id, allSourceIds);
     const status = classify(observed, limitations, relevantUnknowns);
-    const displayedUnknowns = relevantUnknowns.slice(0, 100);
-    const hiddenUnknownCount = relevantUnknowns.length - displayedUnknowns.length;
+    const displayedUnknowns = relevantUnknowns;
     return reconstructionClaimResultSchema.parse({
         claim_id: claim.claim_id,
         kind: claim.kind,
@@ -128,20 +109,15 @@ const evaluateClaim = (claim, records, heads) => {
             ...comparison.limitations,
             ...limitations,
             ...displayedUnknowns.map(({ question }) => `Residual unknown: ${question}`),
-            ...(hiddenUnknownCount > 0
-                ? [
-                    `${hiddenUnknownCount} additional active residual unknowns affect this claim but are omitted by the 100-item display limit.`,
-                ]
-                : []),
         ]),
     });
 };
 const validateSourceKinds = (claim, sources) => {
     const expected = claim.kind === "behavioral"
-        ? ["capture_process_scenario", "rea.process-capture/v4"]
+        ? ["capture_process_scenario", "rea.process-capture"]
         : claim.kind === "structural-function"
-            ? ["analyze_function", "rea.analysis/v2"]
-            : ["inventory_artifact", "rea.analysis/v2"];
+            ? ["analyze_function", "rea.analysis"]
+            : ["inventory_artifact", "rea.analysis"];
     if (sources.some((source) => source.operation !== expected[0] ||
         source.predicate_type !== expected[1]))
         throw new TypeError("Comparison source Evidence has an unexpected observation type");
@@ -184,8 +160,8 @@ const sourceSides = (claim, evidence) => {
     }
     const parsed = z
         .object({
-        left_evidence_ids: z.array(evidenceIdSchema).min(1).max(100),
-        right_evidence_ids: z.array(evidenceIdSchema).min(1).max(100),
+        left_evidence_ids: z.array(evidenceIdSchema).min(1),
+        right_evidence_ids: z.array(evidenceIdSchema).min(1),
     })
         .passthrough()
         .parse(parameters);
@@ -211,11 +187,7 @@ const observedStatus = (claim, evidence) => {
         return dimension.status;
     }
     const result = artifactComparisonResultSchema.parse(evidence.normalized_result);
-    if (result.changes.offset !== 0 ||
-        result.changes.next_offset !== null ||
-        result.changes.items.length !== result.changes.total)
-        return "unknown";
-    if (result.changes.items.some((item) => item.evidence_links.some((id) => !evidence.evidence_links.includes(id))))
+    if (result.changes.some((item) => item.evidence_links.some((id) => !evidence.evidence_links.includes(id))))
         throw new TypeError("Artifact change cites Evidence outside comparison closure");
     return result.status;
 };
@@ -261,12 +233,6 @@ const digest = (value) => {
         throw new TypeError("Specification canonicalization failed");
     return createHash("sha256").update(encoded).digest("hex");
 };
-const enforceInputSize = (value) => {
-    const encoded = canonicalize(value);
-    if (encoded === undefined ||
-        Buffer.byteLength(encoded, "utf8") > MAX_CANONICAL_BYTES)
-        throw new TypeError("Reconstruction Evidence bundle exceeds byte limit");
-};
 const count = (items, status) => items.filter((item) => item.status === status).length;
 const sameSet = (left, right) => left.length === right.length &&
     uniqueSorted(left).every((id, index) => id === uniqueSorted(right)[index]);