rea-agents 3.1.0 → 3.2.0

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,43 +159,42 @@ 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)
@@ -218,11 +217,10 @@ const findingSchema = z.strictObject({
     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,
@@ -262,7 +260,7 @@ export const reconstructionReadinessReportSchema = z.strictObject({
             seen.add(stage.stage_id);
         });
     }),
-    findings: z.array(findingSchema).max(10_000),
-    evidence_links: z.array(evidenceIdSchema).max(100_000),
+    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]);

package/dist/domain/reconstructionVerificationSchemas.js

@@ -2,8 +2,8 @@ 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 digestSchema = z.string().regex(/^[a-f0-9]{64}$/u);
-const claimIdSchema = z.string().regex(/^[A-Za-z][A-Za-z0-9._-]{0,99}$/u);
-const titleSchema = z.string().trim().min(1).max(500);
+const claimIdSchema = z.string().regex(/^[A-Za-z][A-Za-z0-9._-]*$/u);
+const titleSchema = z.string().trim().min(1);
 const verificationStatusSchema = z.enum(["pass", "fail", "unknown"]);
 const commonClaim = {
     claim_id: claimIdSchema,
@@ -52,9 +52,8 @@ const reconstructionClaimSchema = z.discriminatedUnion("kind", [
 /** Finite, typed behavioral and structural specification. */
 export const reconstructionSpecificationSchema = z
     .object({
-    schema_version: z.literal(1),
-    name: z.string().trim().min(1).max(200),
-    claims: z.array(reconstructionClaimSchema).min(1).max(100),
+    name: z.string().trim().min(1),
+    claims: z.array(reconstructionClaimSchema).min(1),
 })
     .superRefine((value, context) => {
     const ids = value.claims.map(({ claim_id: id }) => id);
@@ -67,20 +66,9 @@ export const reconstructionSpecificationSchema = z
             message: "Claim comparison selectors must be unique",
         });
 });
-/** Bounded reconstruction-verification input. */
+/** Reconstruction-verification input. */
 export const reconstructionVerificationInputSchema = z.strictObject({
     specification: reconstructionSpecificationSchema,
-    coverage: z
-        .strictObject({
-        workspace_id: z.string().regex(/^rcw_[a-f0-9]{64}$/u),
-        revision: z.number().int().min(1),
-        revision_sha256: digestSchema,
-        boundary_id: z.string().min(1).max(200),
-    })
-        .optional(),
-    offset: z.number().int().min(0).default(0),
-    limit: z.number().int().min(1).max(100).default(100),
-    unknown_registry_approved: z.literal(true).optional(),
 });
 export const reconstructionClaimResultSchema = z.object({
     claim_id: claimIdSchema,
@@ -97,18 +85,19 @@ export const reconstructionClaimResultSchema = z.object({
         "contradiction",
     ]),
     comparison_evidence_id: evidenceIdSchema,
-    left_evidence_ids: z.array(evidenceIdSchema).min(1).max(100),
-    right_evidence_ids: z.array(evidenceIdSchema).min(1).max(100),
-    evidence_links: z.array(evidenceIdSchema).min(3).max(201),
-    unknown_ids: z.array(unknownIdSchema).max(100),
+    left_evidence_ids: z.array(evidenceIdSchema).min(1),
+    right_evidence_ids: z.array(evidenceIdSchema).min(1),
+    evidence_links: z.array(evidenceIdSchema).min(3),
+    unknown_ids: z.array(unknownIdSchema),
     limitations: z.array(z.string()),
 });
-/** Evidence-cited result over every declared claim, independently paged. */
-export const reconstructionVerificationResultSchema = z.object({
+/** Evidence-cited result over every declared claim. */
+export const reconstructionVerificationResultSchema = z
+    .object({
     status: verificationStatusSchema,
     specification_sha256: digestSchema,
     summary: z.object({
-        total: z.number().int().min(1).max(100),
+        total: z.number().int().min(1),
         passed: z.number().int().min(0),
         failed: z.number().int().min(0),
         unknown: z.number().int().min(0),
@@ -116,20 +105,43 @@ export const reconstructionVerificationResultSchema = z.object({
         structural: z.number().int().min(0),
     }),
     claims: z.object({
-        items: z.array(reconstructionClaimResultSchema).max(100),
-        offset: z.number().int().min(0),
-        limit: z.number().int().min(1).max(100),
-        total: z.number().int().min(1).max(100),
-        next_offset: z.number().int().min(0).nullable(),
+        items: z.array(reconstructionClaimResultSchema),
     }),
-    recommended_probes: z
-        .array(z.object({
-        operation: z.string().min(1).max(200),
-        rationale: z.string().min(1).max(1_000),
-        claim_ids: z.array(claimIdSchema).min(1).max(100),
-        unknown_ids: z.array(unknownIdSchema).max(100),
-    }))
-        .max(2_000),
-    evidence_links: z.array(evidenceIdSchema).min(3).max(20_100),
+    recommended_probes: z.array(z.object({
+        operation: z.string().min(1),
+        rationale: z.string().min(1),
+        claim_ids: z.array(claimIdSchema).min(1),
+        unknown_ids: z.array(unknownIdSchema),
+    })),
+    evidence_links: z.array(evidenceIdSchema).min(3),
     limitations: z.array(z.string()),
+})
+    .superRefine((result, context) => {
+    const { summary } = result;
+    const expectedStatus = summary.failed > 0 ? "fail" : summary.unknown > 0 ? "unknown" : "pass";
+    const issues = [
+        [
+            summary.total !== summary.passed + summary.failed + summary.unknown,
+            "Claim status counts must equal the summary total",
+            ["summary", "total"],
+        ],
+        [
+            summary.total !== summary.behavioral + summary.structural,
+            "Claim kind counts must equal the summary total",
+            ["summary", "total"],
+        ],
+        [
+            result.claims.items.length !== summary.total,
+            "Retained claims must equal the summary total",
+            ["claims", "items"],
+        ],
+        [
+            result.status !== expectedStatus,
+            "Verification status must summarize claim statuses",
+            ["status"],
+        ],
+    ];
+    for (const [invalid, message, path] of issues)
+        if (invalid)
+            context.addIssue({ code: "custom", message, path: [...path] });
 });