rea-agents 3.1.0 → 3.2.1

package/dist/domain/reconstructionCoverage.js

@@ -2,11 +2,11 @@ import { createHash } from "node:crypto";
 import canonicalize from "canonicalize";
 import { z } from "zod";
 import { evidenceBundleSchema, parseEvidenceBundle } from "./evidenceBundle.js";
-import { evaluateReconstructionClaims, evaluateReconstructionPackageProofs, evaluateReconstructionSurfaces, evaluateReconstructionWorkspaceRisks, recommendedReconstructionProbes, } from "./reconstructionCoverageEvaluation.js";
+import { evaluateReconstructionClaims, evaluateReconstructionPackageProofs, evaluateReconstructionSurfaces, evaluateReconstructionCoverageRisks, recommendedReconstructionProbes, } from "./reconstructionCoverageEvaluation.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 boundedTextSchema = z.string().trim().min(1);
 const authoritySchema = z.enum([
     "observed",
     "derived",
@@ -17,24 +17,24 @@ const authoritySchema = z.enum([
 const artifactSchema = z.strictObject({
     artifact_id: stableIdSchema,
     artifact_sha256: digestSchema,
-    version: z.string().trim().min(1).max(500),
+    version: z.string().trim().min(1),
     environment_sha256: digestSchema,
-    evidence_ids: z.array(evidenceIdSchema).min(1).max(1_000),
+    evidence_ids: z.array(evidenceIdSchema).min(1),
 });
 const surfaceSchema = z.strictObject({
     surface_id: stableIdSchema,
-    family: z.string().trim().min(1).max(100),
+    family: z.string().trim().min(1),
     artifact_id: stableIdSchema,
-    occurrence_id: z.string().trim().min(1).max(500).nullable(),
+    occurrence_id: z.string().trim().min(1).nullable(),
     location: boundedTextSchema,
     authority: authoritySchema,
-    dependency_surface_ids: z.array(stableIdSchema).max(1_000),
-    evidence_ids: z.array(evidenceIdSchema).min(1).max(1_000),
+    dependency_surface_ids: z.array(stableIdSchema),
+    evidence_ids: z.array(evidenceIdSchema).min(1),
 });
 const implementationOwnerSchema = z.strictObject({
     disposition: z.literal("implemented"),
     owner_path: boundedTextSchema,
-    owner_export: z.string().trim().min(1).max(500).nullable(),
+    owner_export: z.string().trim().min(1).nullable(),
     owner_sha256: digestSchema,
     path_state: z.enum(["present", "missing", "unknown"]),
     package_state: z.enum(["distributed", "missing", "unknown"]),
@@ -53,10 +53,10 @@ const ownerSchema = z.strictObject({
 });
 const claimSchema = z.strictObject({
     claim_id: stableIdSchema,
-    title: z.string().trim().min(1).max(500),
-    kind: z.string().trim().min(1).max(100),
-    surface_ids: z.array(stableIdSchema).min(1).max(1_000),
-    required_dimensions: z.array(stableIdSchema).min(1).max(100),
+    title: z.string().trim().min(1),
+    kind: z.string().trim().min(1),
+    surface_ids: z.array(stableIdSchema).min(1),
+    required_dimensions: z.array(stableIdSchema).min(1),
     required_authority: z.enum([
         "shipped-artifact",
         "controlled-replay",
@@ -66,16 +66,16 @@ const claimSchema = z.strictObject({
 });
 const verifierContractBaseSchema = z.strictObject({
     verifier_id: stableIdSchema,
-    claim_ids: z.array(stableIdSchema).min(1).max(1_000),
-    dimensions: z.array(stableIdSchema).min(1).max(100),
+    claim_ids: z.array(stableIdSchema).min(1),
+    dimensions: z.array(stableIdSchema).min(1),
     authority: z.enum([
         "shipped-artifact",
         "controlled-replay",
         "live-observation",
         "external",
     ]),
-    max_age_ms: z.number().int().min(1).max(Number.MAX_SAFE_INTEGER),
-    minimum_repeats: z.number().int().min(1).max(1_000),
+    max_age_ms: z.number().int().min(1),
+    minimum_repeats: z.number().int().min(1),
     normalization_sha256: digestSchema,
     normalization_removes_dimensions: z.literal(false),
 });
@@ -94,20 +94,20 @@ const verifierResultSchema = z.strictObject({
         "truncated",
         "skipped",
     ]),
-    covered_claim_ids: z.array(stableIdSchema).min(1).max(1_000),
-    covered_dimensions: z.array(stableIdSchema).min(1).max(100),
-    artifact_sha256s: z.array(digestSchema).min(1).max(1_000),
-    owner_sha256s: z.array(digestSchema).max(1_000),
+    covered_claim_ids: z.array(stableIdSchema).min(1),
+    covered_dimensions: z.array(stableIdSchema).min(1),
+    artifact_sha256s: z.array(digestSchema).min(1),
+    owner_sha256s: z.array(digestSchema),
     normalization_sha256: digestSchema,
-    repeats: z.number().int().min(1).max(1_000),
-    evidence_ids: z.array(evidenceIdSchema).min(1).max(1_000),
+    repeats: z.number().int().min(1),
+    evidence_ids: z.array(evidenceIdSchema).min(1),
 });
 const contradictionSchema = z.strictObject({
     contradiction_id: stableIdSchema,
     status: z.enum(["active", "resolved"]),
-    surface_ids: z.array(stableIdSchema).max(1_000),
-    claim_ids: z.array(stableIdSchema).max(1_000),
-    evidence_ids: z.array(evidenceIdSchema).min(2).max(1_000),
+    surface_ids: z.array(stableIdSchema),
+    claim_ids: z.array(stableIdSchema),
+    evidence_ids: z.array(evidenceIdSchema).min(2),
 });
 const packageProofSchema = z.strictObject({
     proof_id: stableIdSchema,
@@ -119,40 +119,37 @@ const packageProofSchema = z.strictObject({
         "authority-independence",
     ]),
     status: z.enum(["pass", "fail", "unknown", "unsupported", "skipped"]),
-    artifact_sha256s: z.array(digestSchema).min(1).max(1_000),
-    evidence_ids: z.array(evidenceIdSchema).min(1).max(1_000),
+    artifact_sha256s: z.array(digestSchema).min(1),
+    evidence_ids: z.array(evidenceIdSchema).min(1),
 });
 const boundarySchema = z.strictObject({
     boundary_id: stableIdSchema,
-    title: z.string().trim().min(1).max(500),
-    required_surface_ids: z.array(stableIdSchema).min(1).max(10_000),
-    required_claim_ids: z.array(stableIdSchema).min(1).max(10_000),
-    required_package_proof_kinds: z
-        .array(packageProofSchema.shape.kind)
-        .min(1)
-        .max(5),
-    allowed_dispositions: z.array(z.enum(["external", "non-goal"])).max(2),
-    allowed_unknown_ids: z.array(stableIdSchema).max(1_000),
+    title: z.string().trim().min(1),
+    required_surface_ids: z.array(stableIdSchema).min(1),
+    required_claim_ids: z.array(stableIdSchema).min(1),
+    required_package_proof_kinds: z.array(packageProofSchema.shape.kind).min(1),
+    allowed_dispositions: z.array(z.enum(["external", "non-goal"])),
+    allowed_unknown_ids: z.array(stableIdSchema),
 });
-const workspaceSemanticSchema = z.strictObject({
-    schema_version: z.literal(1),
-    workspace_id: z.string().regex(/^rcw_[a-f0-9]{64}$/u),
-    name: z.string().trim().min(1).max(200),
-    revision: z.number().int().min(1),
-    previous_revision_sha256: digestSchema.nullable(),
+export const reconstructionCoverageDataSchema = z.strictObject({
     evidence_bundle: evidenceBundleSchema,
-    artifacts: z.array(artifactSchema).max(1_000),
-    surfaces: z.array(surfaceSchema).max(10_000),
-    owners: z.array(ownerSchema).max(10_000),
-    claims: z.array(claimSchema).max(10_000),
-    verifier_contracts: z.array(verifierContractSchema).max(10_000),
-    verifier_results: z.array(verifierResultSchema).max(100_000),
-    residual_unknown_ids: z.array(stableIdSchema).max(10_000),
-    contradictions: z.array(contradictionSchema).max(10_000),
-    package_proofs: z.array(packageProofSchema).max(10_000),
-    boundaries: z.array(boundarySchema).max(1_000),
+    artifacts: z.array(artifactSchema),
+    surfaces: z.array(surfaceSchema),
+    owners: z.array(ownerSchema),
+    claims: z.array(claimSchema),
+    verifier_contracts: z.array(verifierContractSchema),
+    verifier_results: z.array(verifierResultSchema),
+    residual_unknown_ids: z.array(stableIdSchema),
+    contradictions: z.array(contradictionSchema),
+    package_proofs: z.array(packageProofSchema),
+    boundaries: z.array(boundarySchema),
 });
-export const reconstructionCoverageWorkspaceSchema = workspaceSemanticSchema.extend({ revision_sha256: digestSchema });
+/** Parse inline coverage data and validate every evidence and authority link. */
+export const createReconstructionCoverageData = (input) => {
+    const coverage = reconstructionCoverageDataSchema.parse(input);
+    validateCoverageReferences(coverage);
+    return coverage;
+};
 const closureReasonSchema = z.strictObject({
     code: z.enum([
         "surface-missing",
@@ -186,21 +183,18 @@ const closureReasonSchema = z.strictObject({
 export const reconstructionClosureResultSchema = z.strictObject({
     boundary_id: stableIdSchema,
     status: z.enum(["partial", "failed", "unknown", "ready"]),
-    workspace_revision_sha256: digestSchema,
     summary: z.strictObject({
         required_surfaces: z.number().int().min(0),
         required_claims: z.number().int().min(0),
         reasons: z.number().int().min(0),
     }),
-    reasons: z.array(closureReasonSchema).max(100_000),
-    recommended_probes: z
-        .array(z.strictObject({
+    reasons: z.array(closureReasonSchema),
+    recommended_probes: z.array(z.strictObject({
         operation: stableIdSchema,
         subject_id: stableIdSchema,
         rationale: boundedTextSchema,
-    }))
-        .max(100_000),
-    evidence_ids: z.array(evidenceIdSchema).max(100_000),
+    })),
+    evidence_ids: z.array(evidenceIdSchema),
 });
 /** Build a verifier contract whose digest prevents retrospective coverage edits. */
 export const createReconstructionVerifierContract = (input) => {
@@ -210,60 +204,14 @@ export const createReconstructionVerifierContract = (input) => {
         contract_sha256: digest(parsed),
     });
 };
-/** Build one canonical immutable coverage-workspace revision. */
-export const createReconstructionCoverageWorkspace = (input) => {
-    const semanticInput = {
-        schema_version: 1,
-        workspace_id: `rcw_${digest({ schema: "rea.reconstruction-coverage-workspace/v1", name: input.name })}`,
-        ...input,
-    };
-    const semantic = canonicalWorkspace(workspaceSemanticSchema.parse(semanticInput));
-    validateWorkspaceReferences(semantic);
-    return reconstructionCoverageWorkspaceSchema.parse({
-        ...semantic,
-        revision_sha256: digest(semantic),
-    });
-};
-/** Parse persisted coverage state and verify canonical order, references, and digests. */
-export const parseReconstructionCoverageWorkspace = (input) => {
-    const parsed = reconstructionCoverageWorkspaceSchema.parse(input);
-    const rebuilt = createReconstructionCoverageWorkspace({
-        name: parsed.name,
-        revision: parsed.revision,
-        previous_revision_sha256: parsed.previous_revision_sha256,
-        evidence_bundle: parsed.evidence_bundle,
-        artifacts: parsed.artifacts,
-        surfaces: parsed.surfaces,
-        owners: parsed.owners,
-        claims: parsed.claims,
-        verifier_contracts: parsed.verifier_contracts,
-        verifier_results: parsed.verifier_results,
-        residual_unknown_ids: parsed.residual_unknown_ids,
-        contradictions: parsed.contradictions,
-        package_proofs: parsed.package_proofs,
-        boundaries: parsed.boundaries,
-    });
-    if (parsed.workspace_id !== rebuilt.workspace_id ||
-        parsed.revision_sha256 !== rebuilt.revision_sha256 ||
-        JSON.stringify(parsed) !== JSON.stringify(rebuilt))
-        throw new TypeError("Reconstruction coverage workspace is not canonical");
-    return rebuilt;
-};
-/** Serialize one validated coverage revision as byte-stable canonical JSON. */
-export const serializeReconstructionCoverageWorkspace = (workspace) => {
-    const encoded = canonicalize(parseReconstructionCoverageWorkspace(workspace));
-    if (encoded === undefined)
-        throw new TypeError("Reconstruction coverage workspace is not canonical JSON");
-    return encoded;
-};
-/** Evaluate one named completion boundary without inferring undiscovered coverage. */
-export const evaluateReconstructionClosure = (workspaceInput, boundaryId, nowEpochMs) => {
-    const workspace = parseReconstructionCoverageWorkspace(workspaceInput);
-    const boundary = workspace.boundaries.find(({ boundary_id: id }) => id === boundaryId);
+/** Evaluate inline coverage data against one named fail-closed boundary. */
+export const evaluateReconstructionClosure = (coverageInput, boundaryId, nowEpochMs) => {
+    const coverage = createReconstructionCoverageData(coverageInput);
+    const boundary = coverage.boundaries.find(({ boundary_id: id }) => id === boundaryId);
     if (boundary === undefined)
         throw new TypeError(`Unknown reconstruction boundary: ${boundaryId}`);
     const context = {
-        workspace,
+        coverage,
         boundary,
         nowEpochMs,
         reasons: [],
@@ -271,13 +219,12 @@ export const evaluateReconstructionClosure = (workspaceInput, boundaryId, nowEpo
     };
     evaluateReconstructionSurfaces(context);
     evaluateReconstructionClaims(context);
-    evaluateReconstructionWorkspaceRisks(context);
+    evaluateReconstructionCoverageRisks(context);
     evaluateReconstructionPackageProofs(context);
     const reasons = [...context.reasons].sort(reasonOrder);
     return reconstructionClosureResultSchema.parse({
         boundary_id: boundary.boundary_id,
         status: closureStatus(reasons),
-        workspace_revision_sha256: workspace.revision_sha256,
         summary: {
             required_surfaces: boundary.required_surface_ids.length,
             required_claims: boundary.required_claim_ids.length,
@@ -288,7 +235,7 @@ export const evaluateReconstructionClosure = (workspaceInput, boundaryId, nowEpo
         evidence_ids: [...context.evidenceIds].sort(),
     });
 };
-const validateWorkspaceReferences = (workspace) => {
+const validateCoverageReferences = (workspace) => {
     const evidenceBundle = parseEvidenceBundle(workspace.evidence_bundle);
     const evidenceIds = new Set(evidenceBundle.records.map(({ evidence_id: id }) => id));
     const unknownIds = new Set(evidenceBundle.unknowns.map(({ unknown_id: id }) => id));
@@ -333,20 +280,6 @@ const validateWorkspaceReferences = (workspace) => {
     if (danglingUnknown !== undefined)
         throw new TypeError(`Coverage workspace residual unknown is missing: ${danglingUnknown}`);
 };
-const canonicalWorkspace = (workspace) => ({
-    ...workspace,
-    artifacts: sorted(workspace.artifacts, "artifact_id"),
-    surfaces: sorted(workspace.surfaces, "surface_id"),
-    owners: [...workspace.owners].sort((left, right) => left.surface_id.localeCompare(right.surface_id)),
-    claims: sorted(workspace.claims, "claim_id"),
-    verifier_contracts: sorted(workspace.verifier_contracts, "verifier_id"),
-    verifier_results: [...workspace.verifier_results].sort((left, right) => `${left.verifier_id}:${left.observed_at}`.localeCompare(`${right.verifier_id}:${right.observed_at}`)),
-    residual_unknown_ids: [...new Set(workspace.residual_unknown_ids)].sort(),
-    contradictions: sorted(workspace.contradictions, "contradiction_id"),
-    package_proofs: sorted(workspace.package_proofs, "proof_id"),
-    boundaries: sorted(workspace.boundaries, "boundary_id"),
-});
-const sorted = (items, key) => [...items].sort((left, right) => left[key].localeCompare(right[key]));
 const assertUnique = (items, key) => {
     const values = items.map((item) => item[key]);
     if (new Set(values).size !== values.length)

package/dist/domain/reconstructionCoverageEvaluation.js

@@ -1,4 +1,4 @@
-export const recommendedReconstructionProbes = (reasons) => reasons.slice(0, 100).map((reason) => ({
+export const recommendedReconstructionProbes = (reasons) => reasons.map((reason) => ({
     operation: probeOperation(reason.code),
     subject_id: reason.subject_id,
     rationale: reason.detail,
@@ -17,7 +17,7 @@ const probeOperation = (code) => {
     return "update_authoritative_inventory";
 };
 export const evaluateReconstructionSurfaces = (context) => {
-    const surfaces = indexUnique(context.workspace.surfaces, "surface_id");
+    const surfaces = indexUnique(context.coverage.surfaces, "surface_id");
     for (const surfaceId of context.boundary.required_surface_ids) {
         const surface = surfaces.get(surfaceId);
         if (surface === undefined) {
@@ -32,7 +32,7 @@ export const evaluateReconstructionSurfaces = (context) => {
     }
 };
 const evaluateOwner = (context, surfaceId) => {
-    const owners = context.workspace.owners.filter(({ surface_id: id }) => id === surfaceId);
+    const owners = context.coverage.owners.filter(({ surface_id: id }) => id === surfaceId);
     if (owners.length === 0) {
         addReason(context, "owner-missing", surfaceId, "Required surface has no reconstructed owner or explicit disposition.");
         return;
@@ -86,14 +86,14 @@ const evaluateOwner = (context, surfaceId) => {
             addReason(context, code, surfaceId, detail);
 };
 export const evaluateReconstructionClaims = (context) => {
-    const claims = indexUnique(context.workspace.claims, "claim_id");
+    const claims = indexUnique(context.coverage.claims, "claim_id");
     for (const claimId of context.boundary.required_claim_ids) {
         const claim = claims.get(claimId);
         if (claim === undefined) {
             addReason(context, "claim-missing", claimId, "Required finite claim is absent.");
             continue;
         }
-        const contracts = context.workspace.verifier_contracts.filter(({ claim_ids: ids }) => ids.includes(claimId));
+        const contracts = context.coverage.verifier_contracts.filter(({ claim_ids: ids }) => ids.includes(claimId));
         if (contracts.length === 0) {
             addReason(context, "verifier-missing", claimId, "No verifier contract covers this claim.");
             continue;
@@ -108,7 +108,7 @@ export const evaluateReconstructionClaims = (context) => {
     }
 };
 const evaluateVerifierResult = (context, claim, contract) => {
-    const results = context.workspace.verifier_results
+    const results = context.coverage.verifier_results
         .filter(({ verifier_id: id }) => id === contract.verifier_id)
         .sort((left, right) => Date.parse(right.observed_at) - Date.parse(left.observed_at));
     const result = results[0];
@@ -133,10 +133,10 @@ const evaluateVerifierResult = (context, claim, contract) => {
         addReason(context, "verifier-unknown", claim.claim_id, `Latest compatible verifier result is ${result.status}.`);
 };
 const verifierResultIsCompatible = (context, claim, contract, result) => {
-    const artifactDigests = new Set(context.workspace.artifacts.map(({ artifact_sha256: value }) => value));
-    const ownerDigests = new Set(context.workspace.owners.flatMap(({ ownership }) => ownership.disposition === "implemented" ? [ownership.owner_sha256] : []));
-    const surfaces = new Map(context.workspace.surfaces.map((surface) => [surface.surface_id, surface]));
-    const artifacts = new Map(context.workspace.artifacts.map((artifact) => [
+    const artifactDigests = new Set(context.coverage.artifacts.map(({ artifact_sha256: value }) => value));
+    const ownerDigests = new Set(context.coverage.owners.flatMap(({ ownership }) => ownership.disposition === "implemented" ? [ownership.owner_sha256] : []));
+    const surfaces = new Map(context.coverage.surfaces.map((surface) => [surface.surface_id, surface]));
+    const artifacts = new Map(context.coverage.artifacts.map((artifact) => [
         artifact.artifact_id,
         artifact,
     ]));
@@ -145,7 +145,7 @@ const verifierResultIsCompatible = (context, claim, contract, result) => {
         const artifact = surface === undefined ? undefined : artifacts.get(surface.artifact_id);
         return artifact === undefined ? [] : [artifact.artifact_sha256];
     });
-    const expectedOwnerDigests = context.workspace.owners.flatMap(({ surface_id: surfaceId, ownership }) => claim.surface_ids.includes(surfaceId) &&
+    const expectedOwnerDigests = context.coverage.owners.flatMap(({ surface_id: surfaceId, ownership }) => claim.surface_ids.includes(surfaceId) &&
         ownership.disposition === "implemented"
         ? [ownership.owner_sha256]
         : []);
@@ -163,11 +163,11 @@ const verifierResultIsCompatible = (context, claim, contract, result) => {
         result.repeats >= contract.minimum_repeats &&
         claim.required_authority === contract.authority);
 };
-export const evaluateReconstructionWorkspaceRisks = (context) => {
-    for (const unknownId of context.workspace.residual_unknown_ids)
+export const evaluateReconstructionCoverageRisks = (context) => {
+    for (const unknownId of context.coverage.residual_unknown_ids)
         if (!context.boundary.allowed_unknown_ids.includes(unknownId))
             addReason(context, "active-unknown", unknownId, "Active residual unknown is not permitted by the completion boundary.");
-    for (const contradiction of context.workspace.contradictions)
+    for (const contradiction of context.coverage.contradictions)
         if (contradiction.status === "active" &&
             (contradiction.surface_ids.some((id) => context.boundary.required_surface_ids.includes(id)) ||
                 contradiction.claim_ids.some((id) => context.boundary.required_claim_ids.includes(id)))) {
@@ -176,8 +176,8 @@ export const evaluateReconstructionWorkspaceRisks = (context) => {
         }
 };
 export const evaluateReconstructionPackageProofs = (context) => {
-    const surfaces = new Map(context.workspace.surfaces.map((surface) => [surface.surface_id, surface]));
-    const artifacts = new Map(context.workspace.artifacts.map((artifact) => [
+    const surfaces = new Map(context.coverage.surfaces.map((surface) => [surface.surface_id, surface]));
+    const artifacts = new Map(context.coverage.artifacts.map((artifact) => [
         artifact.artifact_id,
         artifact,
     ]));
@@ -187,7 +187,7 @@ export const evaluateReconstructionPackageProofs = (context) => {
         return artifact === undefined ? [] : [artifact.artifact_sha256];
     });
     for (const kind of context.boundary.required_package_proof_kinds) {
-        const proofs = context.workspace.package_proofs.filter((proof) => proof.kind === kind);
+        const proofs = context.coverage.package_proofs.filter((proof) => proof.kind === kind);
         const passing = proofs.find(({ artifact_sha256s: digests, status }) => status === "pass" &&
             requiredArtifactDigests.every((digest) => digests.includes(digest)));
         if (passing !== undefined) {

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) => {