rea-agents 1.7.0 → 2.1.0

package/dist/domain/reconstructionCoverageEvaluation.js

@@ -0,0 +1,212 @@
+export const recommendedReconstructionProbes = (reasons) => reasons.slice(0, 100).map((reason) => ({
+    operation: probeOperation(reason.code),
+    subject_id: reason.subject_id,
+    rationale: reason.detail,
+}));
+const probeOperation = (code) => {
+    if (code.startsWith("owner-") || code.startsWith("authority-routing"))
+        return "reconcile_reconstruction_owner";
+    if (code.startsWith("verifier-"))
+        return "run_reconstruction_verifier";
+    if (code.startsWith("package-proof"))
+        return "verify_reconstruction_package";
+    if (code === "active-contradiction")
+        return "resolve_contradiction";
+    if (code === "active-unknown")
+        return "probe_residual_unknown";
+    return "update_authoritative_inventory";
+};
+export const evaluateReconstructionSurfaces = (context) => {
+    const surfaces = indexUnique(context.workspace.surfaces, "surface_id");
+    for (const surfaceId of context.boundary.required_surface_ids) {
+        const surface = surfaces.get(surfaceId);
+        if (surface === undefined) {
+            addReason(context, "surface-missing", surfaceId, "Required surface is absent from the authoritative inventory.");
+            continue;
+        }
+        addEvidence(context, surface.evidence_ids);
+        for (const dependencyId of surface.dependency_surface_ids)
+            if (!surfaces.has(dependencyId))
+                addReason(context, "dependency-surface-missing", surfaceId, `Declared dependency surface is absent: ${dependencyId}`);
+        evaluateOwner(context, surfaceId);
+    }
+};
+const evaluateOwner = (context, surfaceId) => {
+    const owners = context.workspace.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;
+    }
+    if (owners.length > 1) {
+        addReason(context, "owner-duplicate", surfaceId, "Required surface has conflicting ownership declarations.");
+        return;
+    }
+    const owner = owners[0]?.ownership;
+    if (owner === undefined)
+        return;
+    if (owner.disposition !== "implemented") {
+        if (!context.boundary.allowed_dispositions.includes(owner.disposition))
+            addReason(context, "disposition-not-allowed", surfaceId, `${owner.disposition} is not allowed by this completion boundary.`);
+        return;
+    }
+    const ownerChecks = [
+        [
+            owner.path_state === "missing",
+            "owner-path-missing",
+            "Declared owner path is missing.",
+        ],
+        [
+            owner.path_state === "unknown",
+            "owner-path-unknown",
+            "Declared owner path has not been checked.",
+        ],
+        [
+            owner.package_state === "missing",
+            "owner-undistributed",
+            "Declared owner is absent from the distributable.",
+        ],
+        [
+            owner.package_state === "unknown",
+            "owner-distribution-unknown",
+            "Owner distribution state is unknown.",
+        ],
+        [
+            owner.authority_route === "detected",
+            "authority-routing-detected",
+            "Reconstructed owner routes into the authority.",
+        ],
+        [
+            owner.authority_route === "unknown",
+            "authority-routing-unknown",
+            "Authority independence has not been established.",
+        ],
+    ];
+    for (const [matches, code, detail] of ownerChecks)
+        if (matches)
+            addReason(context, code, surfaceId, detail);
+};
+export const evaluateReconstructionClaims = (context) => {
+    const claims = indexUnique(context.workspace.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));
+        if (contracts.length === 0) {
+            addReason(context, "verifier-missing", claimId, "No verifier contract covers this claim.");
+            continue;
+        }
+        if (contracts.length > 1) {
+            addReason(context, "verifier-duplicate", claimId, "Multiple verifier contracts claim primary coverage.");
+            continue;
+        }
+        const contract = contracts[0];
+        if (contract !== undefined)
+            evaluateVerifierResult(context, claim, contract);
+    }
+};
+const evaluateVerifierResult = (context, claim, contract) => {
+    const results = context.workspace.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];
+    if (result === undefined) {
+        addReason(context, "verifier-result-missing", claim.claim_id, "Verifier has no recorded result.");
+        return;
+    }
+    addEvidence(context, result.evidence_ids);
+    if (!verifierResultIsCompatible(context, claim, contract, result)) {
+        addReason(context, "verifier-result-incompatible", claim.claim_id, "Latest verifier result does not match current artifacts, owners, dimensions, authority, normalization, repeats, or contract.");
+        return;
+    }
+    const observedAt = Date.parse(result.observed_at);
+    if (observedAt > context.nowEpochMs ||
+        context.nowEpochMs - observedAt > contract.max_age_ms) {
+        addReason(context, "verifier-result-stale", claim.claim_id, "Latest compatible verifier result is stale.");
+        return;
+    }
+    if (result.status === "fail")
+        addReason(context, "verifier-failed", claim.claim_id, "Latest compatible verifier result failed.");
+    else if (result.status !== "pass")
+        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) => [
+        artifact.artifact_id,
+        artifact,
+    ]));
+    const expectedArtifactDigests = claim.surface_ids.flatMap((surfaceId) => {
+        const surface = surfaces.get(surfaceId);
+        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) &&
+        ownership.disposition === "implemented"
+        ? [ownership.owner_sha256]
+        : []);
+    return (result.contract_sha256 === contract.contract_sha256 &&
+        result.normalization_sha256 === contract.normalization_sha256 &&
+        result.covered_claim_ids.includes(claim.claim_id) &&
+        result.covered_claim_ids.every((item) => contract.claim_ids.includes(item)) &&
+        claim.required_dimensions.every((item) => contract.dimensions.includes(item)) &&
+        claim.required_dimensions.every((item) => result.covered_dimensions.includes(item)) &&
+        result.covered_dimensions.every((item) => contract.dimensions.includes(item)) &&
+        result.artifact_sha256s.every((item) => artifactDigests.has(item)) &&
+        expectedArtifactDigests.every((item) => result.artifact_sha256s.includes(item)) &&
+        result.owner_sha256s.every((item) => ownerDigests.has(item)) &&
+        expectedOwnerDigests.every((item) => result.owner_sha256s.includes(item)) &&
+        result.repeats >= contract.minimum_repeats &&
+        claim.required_authority === contract.authority);
+};
+export const evaluateReconstructionWorkspaceRisks = (context) => {
+    for (const unknownId of context.workspace.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)
+        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)))) {
+            addEvidence(context, contradiction.evidence_ids);
+            addReason(context, "active-contradiction", contradiction.contradiction_id, "Active contradiction affects the completion boundary.");
+        }
+};
+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) => [
+        artifact.artifact_id,
+        artifact,
+    ]));
+    const requiredArtifactDigests = context.boundary.required_surface_ids.flatMap((surfaceId) => {
+        const surface = surfaces.get(surfaceId);
+        const artifact = surface === undefined ? undefined : artifacts.get(surface.artifact_id);
+        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 passing = proofs.find(({ artifact_sha256s: digests, status }) => status === "pass" &&
+            requiredArtifactDigests.every((digest) => digests.includes(digest)));
+        if (passing !== undefined) {
+            addEvidence(context, passing.evidence_ids);
+            continue;
+        }
+        if (proofs.some(({ status }) => status === "fail"))
+            addReason(context, "package-proof-failed", kind, "Required package or integration proof failed.");
+        else if (proofs.length > 0)
+            addReason(context, "package-proof-unknown", kind, "Required package or integration proof is not passing.");
+        else
+            addReason(context, "package-proof-missing", kind, "Required package or integration proof is missing.");
+    }
+};
+const indexUnique = (items, key) => new Map(items.map((item) => [item[key], item]));
+const addReason = (context, code, subjectId, detail) => {
+    context.reasons.push({ code, subject_id: subjectId, detail });
+};
+const addEvidence = (context, evidenceIds) => {
+    for (const evidenceId of evidenceIds)
+        context.evidenceIds.add(evidenceId);
+};

package/dist/domain/reconstructionVerificationSchemas.js

@@ -1,5 +1,4 @@
 import { z } from "zod";
-import { evidenceBundleSchema } from "./evidenceBundle.js";
 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);
@@ -69,9 +68,16 @@ export const reconstructionSpecificationSchema = z
         });
 });
 /** Bounded reconstruction-verification input. */
-export const reconstructionVerificationInputSchema = z.object({
+export const reconstructionVerificationInputSchema = z.strictObject({
     specification: reconstructionSpecificationSchema,
-    evidence_bundle: evidenceBundleSchema,
+    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(),

package/dist/domain/runtimeCharacterization.js

@@ -0,0 +1,85 @@
+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 runtimeIdentitySchema = z.strictObject({
+    family: z.string().trim().min(1).max(100),
+    provider_id: stableIdSchema,
+    executable_path: z.string().min(1).max(4_096),
+    executable_sha256: digestSchema,
+    version: z.string().trim().min(1).max(500),
+    profile_sha256: digestSchema,
+});
+const artifactIdentitySchema = z.strictObject({
+    path: z.string().min(1).max(4_096),
+    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),
+    semantic_evidence_id: z
+        .string()
+        .regex(/^ev_[a-f0-9]{64}$/u)
+        .nullable(),
+    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),
+    expected_effect: z.enum(["pure", "bounded-effects", "observation-only"]),
+    allowed_boundaries: z.array(stableIdSchema).max(1_000),
+    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_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),
+    }),
+    determinism: z.strictObject({
+        clock: z.enum(["fixed", "real"]),
+        randomness: z.enum(["seeded", "system"]),
+        identifiers: z.enum(["deterministic", "runtime"]),
+        seed: z.number().int().min(0).max(0xffff_ffff),
+    }),
+    authority: z.strictObject({
+        preparation_approved: z.literal(true),
+        execution_approved: z.literal(false),
+        network: z.enum(["none", "loopback"]),
+        provider_owned_process_only: z.literal(true),
+    }),
+});
+/** Commit a provider-neutral preparation plan; execution requires a later approval. */
+export const createRuntimeCharacterizationPlan = (input) => {
+    const parsed = runtimeCharacterizationPlanSchema
+        .omit({ plan_sha256: true })
+        .parse(input);
+    return runtimeCharacterizationPlanSchema.parse({
+        ...parsed,
+        plan_sha256: digest(parsed),
+    });
+};
+/** Parse a characterization plan and reject altered commitments. */
+export const parseRuntimeCharacterizationPlan = (input) => {
+    const parsed = runtimeCharacterizationPlanSchema.parse(input);
+    const { plan_sha256: planSha256, ...semantic } = parsed;
+    if (planSha256 !== digest(semantic))
+        throw new TypeError("Runtime characterization plan digest is invalid");
+    return parsed;
+};
+const digest = (value) => {
+    const encoded = canonicalize(value);
+    if (encoded === undefined)
+        throw new TypeError("Runtime characterization plan is not canonical JSON");
+    return createHash("sha256").update(encoded).digest("hex");
+};