rea-agents 2.4.0 → 3.0.0

package/dist/domain/protocolCapture.js

@@ -0,0 +1,243 @@
+import { z } from "zod";
+import { jsonValueSchema } from "./jsonValue.js";
+/** Supported protocol families for structured protocol capture. */
+export const protocolFamilySchema = z.enum([
+    "grpc",
+    "protobuf",
+    "json-rpc",
+    "messagepack",
+]);
+/** A decoded field from a protocol message. */
+export const decodedFieldSchema = z.strictObject({
+    /** Field name or path within the message structure. */
+    path: z.string().min(1),
+    /** Wire type or encoding hint. */
+    wire_type: z.string().nullable(),
+    /** Decoded field value. */
+    value: jsonValueSchema.nullable(),
+    /** Whether this field value was inferred rather than decoded. */
+    inferred: z.boolean().default(false),
+});
+/** Schema inference hypothesis for a repeated message pattern. */
+export const schemaHypothesisSchema = z.strictObject({
+    /** Hypothesized field name. */
+    field_name: z.string().min(1),
+    /** Inferred type. */
+    inferred_type: z.string().min(1),
+    /** Confidence: 0-1 */
+    confidence: z.number().min(0).max(1),
+    /** Supporting evidence count. */
+    evidence_count: z.number().int().nonnegative(),
+});
+/** Result of decoding a single protocol message. */
+export const protocolMessageSchema = z.strictObject({
+    /** Monotonic sequence number. */
+    sequence: z.number().int().nonnegative(),
+    /** Timestamp in milliseconds. */
+    at_ms: z.number().int().nonnegative(),
+    /** Protocol family. */
+    family: protocolFamilySchema,
+    /** Direction of the message. */
+    direction: z.enum(["request", "response"]),
+    /** Transport endpoint or path (e.g. gRPC method path). */
+    endpoint: z.string().nullable(),
+    /** Content type of the raw payload. */
+    content_type: z.string().nullable(),
+    /** Raw payload bytes as base64. */
+    raw_payload: z.string().nullable(),
+    /** Decoded fields from the payload. */
+    decoded_fields: z.array(decodedFieldSchema).default([]),
+    /** Inferred schema hypotheses. */
+    schema_hypotheses: z.array(schemaHypothesisSchema).default([]),
+    /** Whether decoding was truncated. */
+    truncated: z.boolean().default(false),
+    /** Whether credentials were detected and redacted. */
+    credentials_redacted: z.boolean().default(false),
+});
+/** A captured protocol session with messages and inferred schemas. */
+export const protocolCaptureSchema = z.strictObject({
+    /** Protocol family for this capture. */
+    family: protocolFamilySchema,
+    /** Captured messages in order. */
+    messages: z.array(protocolMessageSchema).min(0).max(10_000),
+    /** Aggregated schema hypotheses across all messages. */
+    inferred_schema: z.array(schemaHypothesisSchema).default([]),
+    /** Whether any message was truncated. */
+    has_truncated: z.boolean().default(false),
+    /** Whether credentials were detected and redacted. */
+    credentials_detected: z.boolean().default(false),
+});
+/** Classification of a byte sequence as a known protocol family. */
+export function classifyProtocolFamily(contentType, path) {
+    if (contentType) {
+        if (contentType.includes("application/grpc"))
+            return "grpc";
+        if (contentType.includes("application/x-protobuf"))
+            return "protobuf";
+        if (contentType.includes("application/json-rpc"))
+            return "json-rpc";
+        if (contentType.includes("application/msgpack") ||
+            contentType.includes("application/x-msgpack"))
+            return "messagepack";
+    }
+    if (path) {
+        if (path.startsWith("/grpc.") || path.includes("/grpc/"))
+            return "grpc";
+        if (path.includes("/json-rpc") || path.includes("/jsonrpc"))
+            return "json-rpc";
+    }
+    return null;
+}
+/** Credential-like field names that should be redacted. */
+const CREDENTIAL_PATTERNS = [
+    "password",
+    "passwd",
+    "secret",
+    "token",
+    "api_key",
+    "apikey",
+    "authorization",
+    "auth",
+    "credential",
+    "private_key",
+];
+/** Check if a field path looks like it may contain credentials. */
+export function looksLikeCredential(path) {
+    const lower = path.toLowerCase();
+    return CREDENTIAL_PATTERNS.some((p) => lower.includes(p));
+}
+/** Decode a JSON-RPC message from raw payload bytes. */
+export function decodeJsonRpc(rawPayload) {
+    const text = new TextDecoder().decode(rawPayload);
+    const parsed = JSON.parse(text);
+    const fields = [];
+    if (typeof parsed === "object" && parsed !== null) {
+        for (const [key, value] of Object.entries(parsed)) {
+            if (looksLikeCredential(key)) {
+                fields.push({
+                    path: key,
+                    wire_type: "json",
+                    value: "[REDACTED]",
+                    inferred: false,
+                });
+            }
+            else {
+                fields.push({
+                    path: key,
+                    wire_type: "json",
+                    value: value,
+                    inferred: false,
+                });
+            }
+        }
+    }
+    return { decoded_fields: fields, truncated: false };
+}
+/** Decode a MessagePack message (simplified: only checks basic structure). */
+export function decodeMessagePack(rawPayload) {
+    const fields = [];
+    // MessagePack uses a single-byte type tag
+    if (rawPayload.length === 0) {
+        return { decoded_fields: [], truncated: false };
+    }
+    const tag = rawPayload[0];
+    // Map type: 0x80-0x8f (fixmap), 0xde (map16), 0xdf (map32)
+    if ((tag >= 0x80 && tag <= 0x8f) || tag === 0xde || tag === 0xdf) {
+        fields.push({
+            path: "type",
+            wire_type: "msgpack",
+            value: "map",
+            inferred: false,
+        });
+    }
+    // Array type: 0x90-0x9f (fixarray), 0xdc (array16), 0xdd (array32)
+    else if ((tag >= 0x90 && tag <= 0x9f) || tag === 0xdc || tag === 0xdd) {
+        fields.push({
+            path: "type",
+            wire_type: "msgpack",
+            value: "array",
+            inferred: false,
+        });
+    }
+    else {
+        fields.push({
+            path: "type",
+            wire_type: "msgpack",
+            value: "unknown",
+            inferred: true,
+        });
+    }
+    return {
+        decoded_fields: fields,
+        truncated: rawPayload.length > 10_000,
+    };
+}
+/** Decode a gRPC frame (5-byte header + protobuf payload). */
+export function decodeGrpcFrame(rawPayload) {
+    // gRPC uses a 5-byte prefix: 1 byte compressed flag + 4 byte length
+    if (rawPayload.length < 5) {
+        return {
+            decoded_fields: [
+                {
+                    path: "error",
+                    wire_type: "grpc",
+                    value: "frame too short",
+                    inferred: false,
+                },
+            ],
+            truncated: false,
+        };
+    }
+    const compressed = rawPayload[0] !== 0;
+    const length = (rawPayload[1] << 24) |
+        (rawPayload[2] << 16) |
+        (rawPayload[3] << 8) |
+        rawPayload[4];
+    return {
+        decoded_fields: [
+            {
+                path: "compressed",
+                wire_type: "grpc",
+                value: compressed,
+                inferred: false,
+            },
+            {
+                path: "message_length",
+                wire_type: "grpc",
+                value: length,
+                inferred: false,
+            },
+        ],
+        truncated: length > 10_000,
+    };
+}
+/** Infer schema hypotheses from a set of decoded messages. */
+export function inferMessageSchema(messages) {
+    const fieldCounts = new Map();
+    for (const msg of messages) {
+        for (const field of msg.decoded_fields) {
+            const existing = fieldCounts.get(field.path);
+            if (existing) {
+                existing.count++;
+                if (field.wire_type)
+                    existing.types.add(field.wire_type);
+            }
+            else {
+                fieldCounts.set(field.path, {
+                    count: 1,
+                    types: new Set(field.wire_type ?? "unknown"),
+                });
+            }
+        }
+    }
+    const hypotheses = [];
+    for (const [field_name, data] of fieldCounts) {
+        hypotheses.push({
+            field_name,
+            inferred_type: [...data.types].join("|"),
+            confidence: Math.min(1, data.count / messages.length || 0),
+            evidence_count: data.count,
+        });
+    }
+    return hypotheses;
+}

package/dist/domain/providerCleanupError.js

@@ -0,0 +1,11 @@
+import { ProviderAdapterError } from "./errors.js";
+/** Provider resources could not be proven closed after bounded cleanup. */
+export class ProviderCleanupError extends ProviderAdapterError {
+    cleanupIncomplete = true;
+    cleanupResources;
+    userMessage = "Provider cleanup could not be fully confirmed. Review the reported local resources before opening another target.";
+    constructor(providerId, resources, diagnostics, options) {
+        super(providerId, "close_binary", { ...options, diagnostics });
+        this.cleanupResources = [...resources];
+    }
+}

package/dist/domain/reconstructionObligationLedgerSchemas.js

@@ -0,0 +1,278 @@
+import canonicalize from "canonicalize";
+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);
+export const obligationStatusSchema = z.enum([
+    "unowned",
+    "characterized",
+    "implemented",
+    "verified",
+    "contradicted",
+    "blocked",
+    "out-of-scope",
+    "unknown",
+]);
+export const obligationLayerSchema = z.enum([
+    "cli",
+    "protocol",
+    "electron",
+    "persistence",
+    "process",
+    "runtime",
+    "packaging",
+    "native-abi",
+    "application",
+    "other",
+]);
+export const obligationCaseKindSchema = z.enum([
+    "positive",
+    "negative",
+    "malformed",
+    "cancellation",
+    "teardown",
+]);
+export const obligationProofAuthoritySchema = z.enum([
+    "unit",
+    "integration",
+    "protocol",
+    "renderer",
+    "packaged-process",
+    "native-abi",
+    "live-observation",
+    "external",
+]);
+export const obligationOriginalAuthoritySchema = z.enum([
+    "static",
+    "runtime",
+    "process",
+    "external",
+]);
+const obligationTargetSchema = z.strictObject({
+    artifact_sha256: digestSchema.nullable(),
+    application_node_id: z
+        .string()
+        .regex(/^jag_node_[a-f0-9]{64}$/u)
+        .nullable(),
+    semantic_node_id: z
+        .string()
+        .regex(/^jsrg_node_[a-f0-9]{64}$/u)
+        .nullable(),
+    location: boundedTextSchema,
+});
+const authorityReferenceSchema = z.strictObject({
+    evidence_id: evidenceIdSchema,
+    authority: z.enum([
+        "shipped-artifact",
+        "controlled-replay",
+        "historical-reference",
+        "external-service",
+        "analyst-inference",
+    ]),
+    state: z.enum(["candidate", "observed", "reviewed", "unknown"]),
+    location: boundedTextSchema,
+});
+const observedCaseSchema = z.strictObject({
+    kind: obligationCaseKindSchema,
+    evidence_id: evidenceIdSchema,
+    location: boundedTextSchema,
+});
+const ownerBindingSchema = z.strictObject({
+    module_path: boundedTextSchema,
+    symbol: z.string().trim().min(1).max(1_024),
+    owner_sha256: digestSchema,
+});
+const parserTypeBindingSchema = z.strictObject({
+    parser: boundedTextSchema,
+    schema: boundedTextSchema,
+    domain_type: boundedTextSchema,
+});
+const fixtureBindingSchema = z.strictObject({
+    fixture_id: stableIdSchema,
+    case_kind: obligationCaseKindSchema,
+    authority: obligationProofAuthoritySchema,
+    evidence_ids: z.array(evidenceIdSchema).min(1).max(100),
+});
+const nondeterminismSchema = z.strictObject({
+    mode: z.enum(["total-order", "partial-order", "finite-traces"]),
+    specification: boundedTextSchema,
+});
+const verifierBindingSchema = z.strictObject({
+    verifier_id: stableIdSchema,
+    claim_id: stableIdSchema,
+    command: boundedTextSchema,
+    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),
+    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),
+    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({
+        obligation_id: stableIdSchema,
+        evidence_ids: z.array(evidenceIdSchema).min(2).max(100),
+    }))
+        .max(10_000),
+});
+export const reviewedReconstructionObligationSchema = z.strictObject({
+    obligation_id: stableIdSchema,
+    obligation_version: z.number().int().min(1),
+    title: z.string().trim().min(1).max(500),
+    application_layer: obligationLayerSchema,
+    family: z.string().trim().min(1).max(100),
+    target: obligationTargetSchema,
+    required: z.boolean(),
+    required_case_kinds: z.array(obligationCaseKindSchema).min(1).max(5),
+    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),
+    disposition: z.enum(["active", "blocked", "out-of-scope"]),
+    review_evidence_ids: z.array(evidenceIdSchema).min(1).max(100),
+});
+const diagnosticSchema = z.strictObject({
+    code: z.enum([
+        "duplicate-definition",
+        "missing-owner",
+        "ambiguous-owner",
+        "missing-parser-type",
+        "missing-original-case",
+        "weak-original-case-authority",
+        "missing-case",
+        "weak-fixture-authority",
+        "missing-verifier",
+        "verifier-does-not-enumerate",
+        "missing-verifier-result",
+        "weak-verifier-authority",
+        "verifier-failed",
+        "static-only",
+        "contradiction",
+        "contradiction-evidence-missing",
+        "residual-unknown",
+        "dependency-missing",
+        "dependency-open",
+        "unavailable-authority",
+        "blocked",
+        "out-of-scope",
+    ]),
+    detail: boundedTextSchema,
+});
+export const reconstructionObligationSchema = z.strictObject({
+    obligation_id: stableIdSchema,
+    obligation_version: z.number().int().min(1),
+    title: z.string().trim().min(1).max(500),
+    origin: z.enum(["generated", "reviewed"]),
+    application_layer: obligationLayerSchema,
+    family: z.string().trim().min(1).max(100),
+    target: obligationTargetSchema,
+    authority_references: z.array(authorityReferenceSchema).min(1).max(1_000),
+    source_state: z.enum(["candidate", "observed", "reviewed", "unknown"]),
+    observed_cases: z.array(observedCaseSchema).max(100),
+    required: z.boolean(),
+    required_case_kinds: z.array(obligationCaseKindSchema).min(1).max(5),
+    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),
+    binding: reconstructionObligationManifestBindingSchema.nullable(),
+    status: obligationStatusSchema,
+    diagnostics: z.array(diagnosticSchema).max(1_000),
+});
+const countBySchema = (key) => z.array(z.strictObject({
+    key,
+    count: z.number().int().min(0),
+}));
+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),
+        required: z.number().int().min(0),
+        verified: z.number().int().min(0),
+        required_open: z.number().int().min(0),
+        by_status: countBySchema(obligationStatusSchema),
+        by_application_layer: countBySchema(obligationLayerSchema),
+        by_evidence_authority: countBySchema(z.enum(["candidate", "observed", "reviewed", "unknown"])),
+    }),
+    reports: z.strictObject({
+        missing_owner_obligation_ids: z.array(stableIdSchema),
+        missing_verifier_obligation_ids: z.array(stableIdSchema),
+        contradicted_obligation_ids: z.array(stableIdSchema),
+        residual_unknown_ids: z.array(stableIdSchema),
+    }),
+    ownership_graph: z.array(z.strictObject({
+        obligation_id: stableIdSchema,
+        module_path: boundedTextSchema,
+        symbol: z.string().trim().min(1).max(1_024),
+    })),
+    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),
+});
+export const reconstructionObligationLedgerInputSchema = z.strictObject({
+    evidence_bundle: evidenceBundleSchema,
+    reviewed_obligations: z
+        .array(reviewedReconstructionObligationSchema)
+        .max(10_000),
+    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) => {
+    const ledger = reconstructionObligationLedgerSchema.parse(input);
+    const encoded = canonicalize(ledger);
+    if (encoded === undefined)
+        throw new TypeError("Reconstruction obligation ledger is not canonical JSON");
+    return encoded;
+};

package/dist/domain/reconstructionReadiness.js

@@ -0,0 +1,121 @@
+import { createHash } from "node:crypto";
+import canonicalize from "canonicalize";
+import { parseEvidenceBundle } from "./evidenceBundle.js";
+import { readinessFindingOrder } from "./reconstructionReadinessFindingHelpers.js";
+import { READINESS_STAGE_IDS, readinessJourneyFindings, } from "./reconstructionReadinessJourneyFindings.js";
+import { readinessIntegrityFindings } from "./reconstructionReadinessIntegrityFindings.js";
+import { reconstructionReadinessInputSchema, reconstructionReadinessReportSchema, } from "./reconstructionReadinessSchemas.js";
+/** Evaluate one public-contract journey into a deterministic fail-closed report. */
+export const createReconstructionReadinessReport = (inputValue) => {
+    const input = reconstructionReadinessInputSchema.parse(inputValue);
+    const sourceDigest = digest(sourceValue(input));
+    const evidenceIds = new Set(parseEvidenceBundle(input.evidence_bundle).records.map(({ evidence_id: evidenceId }) => evidenceId));
+    const findings = [
+        ...readinessJourneyFindings(input, evidenceIds),
+        ...readinessIntegrityFindings(input, evidenceIds, sourceDigest),
+    ].sort(readinessFindingOrder);
+    const stages = effectiveStages(input, findings);
+    const status = aggregateStatus(stages);
+    const semantic = {
+        source_digest: sourceDigest,
+        status,
+        summary: {
+            stages: stages.length,
+            required_stages: stages.filter(({ required }) => required).length,
+            passed_required_stages: stages.filter(({ required, status: stageStatus }) => required && stageStatus === "pass").length,
+            findings: findings.length,
+            failed_findings: findings.filter(({ status: findingStatus }) => findingStatus === "fail").length,
+            unknown_findings: findings.filter(({ status: findingStatus }) => findingStatus === "unknown").length,
+        },
+        metrics: readinessMetrics(input),
+        stages,
+        findings,
+        evidence_links: [...evidenceIds].sort(),
+        snapshot: input,
+    };
+    const reportDigest = digest({
+        schema: "rea.reconstruction-readiness-report/v1",
+        ...semantic,
+    });
+    return reconstructionReadinessReportSchema.parse({
+        schema: "ReconstructionReadinessReport",
+        schema_version: 1,
+        report_id: `rr_${reportDigest}`,
+        report_digest: reportDigest,
+        ...semantic,
+    });
+};
+const effectiveStages = (input, findings) => READINESS_STAGE_IDS.map((stageId) => {
+    const stage = input.stages.find(({ stage_id: id }) => id === stageId);
+    const stageFindings = findings.filter(({ stage_id: id }) => id === stageId);
+    const status = stageFindings.some(({ status: findingStatus }) => findingStatus === "fail")
+        ? "fail"
+        : stage !== undefined && stage.status !== "pass"
+            ? stage.status
+            : stageFindings.length > 0
+                ? "unknown"
+                : (stage?.status ?? "fail");
+    return stage === undefined
+        ? {
+            stage_id: stageId,
+            required: true,
+            status,
+            capability_issue: null,
+            next_action: "Supply the missing conformance stage.",
+            evidence_ids: [],
+            checks: [],
+        }
+        : { ...stage, required: true, status };
+});
+const aggregateStatus = (stages) => {
+    const required = stages.filter(({ required }) => required);
+    if (required.some(({ status }) => status === "fail"))
+        return "fail";
+    if (required.every(({ status }) => status === "pass"))
+        return "pass";
+    for (const status of [
+        "unknown",
+        "truncated",
+        "unsupported",
+        "skipped",
+    ])
+        if (required.some(({ status: stageStatus }) => stageStatus === status))
+            return status;
+    return "unknown";
+};
+const readinessMetrics = (input) => {
+    const selectedFixtures = input.fixtures.filter((fixture) => input.workflow_candidates.some(({ fixture_id: fixtureId, selected, compatibility }) => fixtureId === fixture.fixture_id &&
+        selected &&
+        compatibility === "compatible")).length;
+    const prerequisiteFailures = input.operation_outcomes.filter(({ call_kind: kind, expected_success: success }) => !success && ["setup", "permission"].includes(kind));
+    const localized = input.comparisons.filter(({ deliberate_divergence_ref: expected, divergence_refs: observed }) => expected !== null && observed.includes(expected)).length;
+    const deliberate = input.comparisons.filter(({ deliberate_divergence_ref: expected }) => expected !== null).length;
+    const falseEquivalence = input.comparisons.filter((comparison) => comparison.verdict === "equivalent" &&
+        (comparison.truncated ||
+            comparison.unavailable_authority ||
+            comparison.unstable ||
+            comparison.contradiction_ids.length > 0)).length;
+    return {
+        first_valid_workflow_selection_rate: ratio(selectedFixtures, input.fixtures.length),
+        malformed_or_over_limit_call_rate: ratio(input.operation_outcomes.filter(({ call_kind: kind }) => ["malformed", "over-limit"].includes(kind)).length, input.operation_outcomes.length),
+        incompatible_provider_invocations: input.workflow_candidates.filter(({ invoked, compatibility }) => invoked && compatibility !== "compatible").length,
+        failed_calls_before_prerequisites: prerequisiteFailures.length,
+        recovery_rate: ratio(prerequisiteFailures.filter(({ recovered }) => recovered).length, prerequisiteFailures.length),
+        divergence_localization_precision: ratio(localized, deliberate),
+        false_equivalence_count: falseEquivalence,
+        unowned_obligation_count: input.obligation_ledger.reports.missing_owner_obligation_ids.length,
+        cleanup_leak_count: input.cleanup.filter(({ owned_resources_remaining: remaining }) => remaining > 0).length,
+        nondeterministic_replay_count: input.replay.deterministic ? 0 : 1,
+    };
+};
+const sourceValue = (input) => ({
+    ...input,
+    replay: { ...input.replay, expected_source_digest: null },
+});
+const ratio = (numerator, denominator) => denominator === 0 ? 1 : numerator / denominator;
+const digest = (value) => {
+    const encoded = canonicalize(value);
+    if (encoded === undefined)
+        throw new TypeError("Reconstruction readiness value is not canonical JSON");
+    return createHash("sha256").update(encoded).digest("hex");
+};

package/dist/domain/reconstructionReadinessFindingHelpers.js

@@ -0,0 +1,17 @@
+export const addMissingEvidenceFindings = (findings, stageId, referencedIds, availableIds) => {
+    for (const evidenceId of new Set(referencedIds))
+        if (!availableIds.has(evidenceId))
+            findings.push(readinessFinding("referenced-evidence-missing", stageId, "unknown", `Referenced Evidence is absent from the bundle: ${evidenceId}.`));
+};
+export const readinessFinding = (...[code, stageId, status, detail, evidenceIds = []]) => ({
+    code,
+    stage_id: stageId,
+    status,
+    detail,
+    evidence_ids: [...new Set(evidenceIds)].sort(),
+});
+export const readinessFindingOrder = (left, right) => {
+    const leftKey = `${left.stage_id}:${left.code}:${left.detail}`;
+    const rightKey = `${right.stage_id}:${right.code}:${right.detail}`;
+    return leftKey < rightKey ? -1 : leftKey > rightKey ? 1 : 0;
+};