rea-agents 2.4.0 → 2.5.0

package/dist/application/ReconstructionObligationLedgerEvaluation.js

@@ -0,0 +1,263 @@
+import { parseEvidenceBundle, } from "../domain/evidenceBundle.js";
+import { reconstructionObligationLedgerSchema, } from "../domain/reconstructionObligationLedgerSchemas.js";
+import { evidenceAuthoritySupportsProof, evidenceSupportsOriginalAuthority, proofAuthoritySatisfies, } from "./ReconstructionObligationAuthority.js";
+import { addObligationDiagnostic as addDiagnostic, contradictionDiagnostics, groupManifestBindings, groupManifestContradictions, hasObligationDiagnostic as hasDiagnostic, uniqueObligationDiagnostics as uniqueDiagnostics, } from "./ReconstructionObligationLedgerDiagnostics.js";
+import { originalCaseDiagnostics, originalCasesFor, } from "./ReconstructionObligationOriginalCases.js";
+import { digestObligationLedgerValue, obligationLedgerCoverage, obligationEdgeOrder, obligationLedgerEvidenceLinks, obligationLedgerStatus, obligationReports, summarizeObligations, } from "./ReconstructionObligationLedgerProjection.js";
+export const evaluateReconstructionObligationLedger = ({ candidates: candidatesInput, bundle: bundleInput, manifest, maxObligations, generationLimitations, }) => {
+    const bundle = parseEvidenceBundle(bundleInput);
+    const allCandidates = [...candidatesInput].sort((left, right) => left.obligation_id.localeCompare(right.obligation_id));
+    const orphanManifestIds = findOrphanManifestIds(allCandidates, manifest);
+    const candidates = allCandidates.slice(0, maxObligations);
+    const omittedCount = allCandidates.length - candidates.length;
+    const context = createEvaluationContext(candidates, bundle, manifest);
+    const obligations = applyDependencyDiagnostics(candidates.map((candidate) => evaluateObligation(candidate, context)), context);
+    const ownershipGraph = obligations
+        .flatMap((obligation) => obligation.binding === null
+        ? []
+        : [
+            {
+                obligation_id: obligation.obligation_id,
+                module_path: obligation.binding.owner.module_path,
+                symbol: obligation.binding.owner.symbol,
+            },
+        ])
+        .sort(obligationEdgeOrder);
+    const dependencyGraph = obligations
+        .flatMap((obligation) => obligation.dependency_obligation_ids.map((dependencyId) => ({
+        obligation_id: obligation.obligation_id,
+        depends_on_obligation_id: dependencyId,
+    })))
+        .sort(obligationEdgeOrder);
+    const evidenceLinks = obligationLedgerEvidenceLinks(obligations, manifest);
+    const limitations = ledgerLimitations(generationLimitations, allCandidates.length, omittedCount, orphanManifestIds);
+    const coverage = obligationLedgerCoverage(omittedCount, maxObligations, limitations.length > 0);
+    const semantic = {
+        coverage,
+        summary: summarizeObligations(obligations),
+        reports: obligationReports(obligations),
+        ownership_graph: ownershipGraph,
+        dependency_graph: dependencyGraph,
+        obligations,
+        evidence_links: evidenceLinks,
+        limitations,
+    };
+    const evaluatedStatus = obligationLedgerStatus(obligations, omittedCount);
+    const status = evaluatedStatus === "failed"
+        ? evaluatedStatus
+        : limitations.length > 0
+            ? "unknown"
+            : evaluatedStatus;
+    const closureDigest = digestObligationLedgerValue({
+        schema: "rea.reconstruction-obligation-closure/v1",
+        status,
+        ...semantic,
+    });
+    return reconstructionObligationLedgerSchema.parse({
+        schema: "ReconstructionObligationLedger",
+        schema_version: 1,
+        ledger_id: `rol_${digestObligationLedgerValue({
+            schema: "rea.reconstruction-obligation-ledger/v1",
+            evidence_ids: bundle.records.map(({ evidence_id: id }) => id),
+            obligation_ids: obligations.map(({ obligation_id: id }) => id),
+            closure_digest: closureDigest,
+        })}`,
+        closure_digest: closureDigest,
+        status,
+        ...semantic,
+    });
+};
+const createEvaluationContext = (candidates, bundle, manifest) => ({
+    candidates: new Map(candidates.map((candidate) => [candidate.obligation_id, candidate])),
+    evidence: new Map(bundle.records.map((evidence) => [evidence.evidence_id, evidence])),
+    bindings: groupManifestBindings(manifest),
+    contradictions: groupManifestContradictions(manifest),
+});
+const findOrphanManifestIds = (candidates, manifest) => {
+    const candidateIds = new Set(candidates.map(({ obligation_id: obligationId }) => obligationId));
+    return [
+        ...new Set([
+            ...manifest.bindings.map(({ obligation_id: obligationId }) => obligationId),
+            ...manifest.contradictions.map(({ obligation_id: obligationId }) => obligationId),
+        ].filter((obligationId) => !candidateIds.has(obligationId))),
+    ].sort();
+};
+const ledgerLimitations = (generationLimitations, candidateCount, omittedCount, orphanManifestIds) => [
+    ...new Set([
+        ...generationLimitations,
+        ...(candidateCount === 0
+            ? [
+                "No reconstruction obligations were derived; closure cannot be claimed.",
+            ]
+            : []),
+        ...(omittedCount > 0
+            ? [
+                `${String(omittedCount)} obligation candidates were omitted by max_obligations; closure is unknown.`,
+            ]
+            : []),
+        ...(orphanManifestIds.length > 0
+            ? [
+                `Manifest entries reference unknown obligations: ${orphanManifestIds.join(", ")}.`,
+            ]
+            : []),
+    ]),
+].sort();
+const evaluateObligation = (candidate, context) => {
+    const bindings = context.bindings.get(candidate.obligation_id) ?? [];
+    const binding = bindings.length === 1 ? (bindings[0] ?? null) : null;
+    const diagnostics = [];
+    if (candidate.definitionCount > 1)
+        addDiagnostic(diagnostics, "duplicate-definition", "Multiple candidate definitions share this obligation ID.");
+    if (bindings.length === 0)
+        addDiagnostic(diagnostics, "missing-owner", "No reconstruction manifest binding owns this obligation.");
+    if (bindings.length > 1)
+        addDiagnostic(diagnostics, "ambiguous-owner", "Multiple reconstruction manifest bindings claim this obligation.");
+    if (binding !== null)
+        evaluateBinding(candidate, binding, context, diagnostics);
+    diagnostics.push(...originalCaseDiagnostics(candidate, binding, context.evidence));
+    evaluateAuthority(candidate, binding, context, diagnostics);
+    evaluateDisposition(candidate, diagnostics);
+    diagnostics.push(...contradictionDiagnostics(candidate.obligation_id, context.contradictions, context.evidence));
+    for (const unknownId of candidate.residual_unknown_ids)
+        addDiagnostic(diagnostics, "residual-unknown", `Residual unknown remains visible: ${unknownId}.`);
+    for (const unavailable of candidate.unavailable_authority)
+        addDiagnostic(diagnostics, "unavailable-authority", unavailable);
+    return {
+        obligation_id: candidate.obligation_id,
+        obligation_version: candidate.obligation_version,
+        title: candidate.title,
+        origin: candidate.origin,
+        application_layer: candidate.application_layer,
+        family: candidate.family,
+        target: candidate.target,
+        authority_references: candidate.authority_references,
+        source_state: candidate.source_state,
+        observed_cases: originalCasesFor(candidate, binding),
+        required: candidate.required,
+        required_case_kinds: candidate.required_case_kinds,
+        required_original_authority: candidate.required_original_authority,
+        required_fixture_authority: candidate.required_fixture_authority,
+        required_verifier_authority: candidate.required_verifier_authority,
+        requires_parser_type: candidate.requires_parser_type,
+        dependency_obligation_ids: candidate.dependency_obligation_ids,
+        residual_unknown_ids: candidate.residual_unknown_ids,
+        unavailable_authority: candidate.unavailable_authority,
+        required_next_evidence: candidate.required_next_evidence,
+        binding,
+        status: obligationStatus(candidate, binding, diagnostics),
+        diagnostics: uniqueDiagnostics(diagnostics),
+    };
+};
+const evaluateBinding = (candidate, binding, context, diagnostics) => {
+    if (candidate.requires_parser_type && binding.parser_type === null)
+        addDiagnostic(diagnostics, "missing-parser-type", "This boundary requires an explicit parser, schema, and domain type.");
+    for (const caseKind of candidate.required_case_kinds) {
+        const fixtures = binding.fixtures.filter(({ case_kind: fixtureCase }) => fixtureCase === caseKind);
+        if (fixtures.length === 0) {
+            addDiagnostic(diagnostics, "missing-case", `Required ${caseKind} fixture is missing.`);
+            continue;
+        }
+        if (!fixtures.some((fixture) => proofAuthoritySatisfies(fixture.authority, candidate.required_fixture_authority) &&
+            fixture.evidence_ids.every((id) => {
+                const evidence = context.evidence.get(id);
+                return (evidence !== undefined &&
+                    evidenceAuthoritySupportsProof(evidence, fixture.authority, {
+                        obligationId: candidate.obligation_id,
+                        fixtureId: fixture.fixture_id,
+                        caseKind: fixture.case_kind,
+                    }));
+            })))
+            addDiagnostic(diagnostics, "weak-fixture-authority", `${caseKind} fixture lacks ${candidate.required_fixture_authority} authority or authenticated Evidence.`);
+    }
+    evaluateVerifier(candidate, binding, context, diagnostics);
+};
+const evaluateVerifier = (candidate, binding, context, diagnostics) => {
+    const verifier = binding.verifier;
+    if (verifier === null) {
+        addDiagnostic(diagnostics, "missing-verifier", "No verifier claim is bound to this obligation.");
+        return;
+    }
+    if (!verifier.enumerated_obligation_ids.includes(candidate.obligation_id))
+        addDiagnostic(diagnostics, "verifier-does-not-enumerate", "The verifier claim does not enumerate this obligation ID.");
+    const resultEvidence = context.evidence.get(verifier.result_evidence_id);
+    if (resultEvidence === undefined)
+        addDiagnostic(diagnostics, "missing-verifier-result", "The latest verifier result Evidence is absent from the bundle.");
+    if (!proofAuthoritySatisfies(verifier.authority, candidate.required_verifier_authority) ||
+        (resultEvidence !== undefined &&
+            !evidenceAuthoritySupportsProof(resultEvidence, verifier.authority, {
+                obligationId: candidate.obligation_id,
+                verifierId: verifier.verifier_id,
+                claimId: verifier.claim_id,
+            })))
+        addDiagnostic(diagnostics, "weak-verifier-authority", `Verifier authority does not satisfy ${candidate.required_verifier_authority}.`);
+    if (verifier.status !== "pass")
+        addDiagnostic(diagnostics, "verifier-failed", `Latest verifier status is ${verifier.status}.`);
+};
+const evaluateAuthority = (candidate, binding, context, diagnostics) => {
+    const referenceSatisfied = candidate.authority_references.some((reference) => {
+        const evidence = context.evidence.get(reference.evidence_id);
+        return (evidence !== undefined &&
+            (candidate.required_original_authority === "static"
+                ? ["candidate", "observed"].includes(reference.state)
+                : reference.state === "observed") &&
+            evidenceSupportsOriginalAuthority(evidence, candidate.required_original_authority));
+    });
+    const caseSatisfied = originalCasesFor(candidate, binding).some(({ evidence_id: evidenceId }) => {
+        const evidence = context.evidence.get(evidenceId);
+        return (evidence !== undefined &&
+            evidenceSupportsOriginalAuthority(evidence, candidate.required_original_authority));
+    });
+    const satisfied = referenceSatisfied || caseSatisfied;
+    if (!satisfied)
+        addDiagnostic(diagnostics, "static-only", `No ${candidate.required_original_authority} authority characterizes the original finite behavior.`);
+};
+const evaluateDisposition = (candidate, diagnostics) => {
+    if (candidate.disposition === "blocked")
+        addDiagnostic(diagnostics, "blocked", "Reviewed disposition marks this obligation blocked.");
+    if (candidate.disposition === "out-of-scope")
+        addDiagnostic(diagnostics, "out-of-scope", "Reviewed disposition marks this obligation out of scope; it remains visible.");
+};
+const applyDependencyDiagnostics = (obligations, context) => {
+    let evaluated = [...obligations];
+    for (let pass = 0; pass < obligations.length; pass += 1) {
+        const statuses = new Map(evaluated.map(({ obligation_id: id, status }) => [id, status]));
+        let changed = false;
+        evaluated = evaluated.map((obligation) => {
+            const diagnostics = [...obligation.diagnostics];
+            for (const dependencyId of obligation.dependency_obligation_ids) {
+                const missing = !context.candidates.has(dependencyId);
+                if (missing || statuses.get(dependencyId) !== "verified")
+                    addDiagnostic(diagnostics, missing ? "dependency-missing" : "dependency-open", `Dependency obligation is ${missing ? "missing" : "not verified"}: ${dependencyId}.`);
+            }
+            const normalized = uniqueDiagnostics(diagnostics);
+            const status = dependencyStatus(obligation.status, normalized);
+            changed ||= status !== obligation.status;
+            return { ...obligation, status, diagnostics: normalized };
+        });
+        if (!changed)
+            break;
+    }
+    return evaluated;
+};
+const obligationStatus = (candidate, binding, diagnostics) => {
+    if (hasDiagnostic(diagnostics, "out-of-scope"))
+        return "out-of-scope";
+    if (hasDiagnostic(diagnostics, "blocked"))
+        return "blocked";
+    if (hasDiagnostic(diagnostics, "contradiction"))
+        return "contradicted";
+    if (hasDiagnostic(diagnostics, "duplicate-definition") ||
+        hasDiagnostic(diagnostics, "residual-unknown") ||
+        hasDiagnostic(diagnostics, "unavailable-authority"))
+        return "unknown";
+    if (binding === null)
+        return "unowned";
+    if (diagnostics.length === 0)
+        return "verified";
+    return "implemented";
+};
+const dependencyStatus = (status, diagnostics) => (hasDiagnostic(diagnostics, "dependency-missing") ||
+    hasDiagnostic(diagnostics, "dependency-open")) &&
+    !["contradicted", "out-of-scope"].includes(status)
+    ? "blocked"
+    : status;

package/dist/application/ReconstructionObligationLedgerProjection.js

@@ -0,0 +1,86 @@
+import { createHash } from "node:crypto";
+import canonicalize from "canonicalize";
+export const obligationLedgerCoverage = (omittedCount, maxObligations, incomplete) => ({
+    status: incomplete ? "partial" : "complete",
+    truncated: omittedCount > 0,
+    omitted_count: omittedCount,
+    max_obligations: maxObligations,
+});
+export const summarizeObligations = (obligations) => ({
+    total: obligations.length,
+    required: obligations.filter(({ required }) => required).length,
+    verified: obligations.filter(({ status }) => status === "verified").length,
+    required_open: obligations.filter(({ required, status }) => required && status !== "verified").length,
+    by_status: countBy(obligations, [
+        "unowned",
+        "characterized",
+        "implemented",
+        "verified",
+        "contradicted",
+        "blocked",
+        "out-of-scope",
+        "unknown",
+    ], ({ status }) => status),
+    by_application_layer: countBy(obligations, [
+        "cli",
+        "protocol",
+        "electron",
+        "persistence",
+        "process",
+        "runtime",
+        "packaging",
+        "native-abi",
+        "application",
+        "other",
+    ], ({ application_layer: layer }) => layer),
+    by_evidence_authority: countBy(obligations, ["candidate", "observed", "reviewed", "unknown"], ({ source_state: state }) => state),
+});
+export const obligationReports = (obligations) => ({
+    missing_owner_obligation_ids: obligationIdsWith(obligations, "missing-owner"),
+    missing_verifier_obligation_ids: obligationIdsWith(obligations, "missing-verifier"),
+    contradicted_obligation_ids: obligationIdsWith(obligations, "contradiction"),
+    residual_unknown_ids: [
+        ...new Set(obligations.flatMap(({ residual_unknown_ids: ids }) => ids)),
+    ].sort(),
+});
+export const obligationLedgerEvidenceLinks = (obligations, manifest) => [
+    ...new Set([
+        ...obligations.flatMap(({ authority_references: references }) => references.map(({ evidence_id: id }) => id)),
+        ...manifest.bindings.flatMap((binding) => [
+            ...binding.original_cases.map(({ evidence_id: id }) => id),
+            ...binding.fixtures.flatMap(({ evidence_ids: ids }) => ids),
+            ...(binding.verifier === null
+                ? []
+                : [binding.verifier.result_evidence_id]),
+        ]),
+        ...manifest.contradictions.flatMap(({ evidence_ids: ids }) => ids),
+    ]),
+].sort();
+export const obligationLedgerStatus = (obligations, omittedCount) => {
+    if (obligations.length === 0)
+        return "unknown";
+    const requiredOpen = obligations.filter(({ required, status }) => required && status !== "verified");
+    if (requiredOpen.some(({ status, diagnostics }) => status === "contradicted" ||
+        hasDiagnostic(diagnostics, "verifier-failed")))
+        return "failed";
+    if (omittedCount > 0 ||
+        requiredOpen.some(({ status }) => status === "unknown"))
+        return "unknown";
+    return requiredOpen.length === 0 ? "ready" : "open";
+};
+export const obligationEdgeOrder = (left, right) => JSON.stringify(left).localeCompare(JSON.stringify(right));
+export const digestObligationLedgerValue = (value) => {
+    const encoded = canonicalize(value);
+    if (encoded === undefined)
+        throw new TypeError("Reconstruction obligation ledger is not canonical JSON");
+    return createHash("sha256").update(encoded).digest("hex");
+};
+const countBy = (items, values, valueFor) => values.map((value) => ({
+    key: value,
+    count: items.filter((item) => valueFor(item) === value).length,
+}));
+const obligationIdsWith = (obligations, code) => obligations
+    .filter(({ diagnostics }) => hasDiagnostic(diagnostics, code))
+    .map(({ obligation_id: id }) => id)
+    .sort();
+const hasDiagnostic = (diagnostics, code) => diagnostics.some((diagnostic) => diagnostic.code === code);

package/dist/application/ReconstructionObligationLedgerService.js

@@ -0,0 +1,72 @@
+import { z } from "zod";
+import { AnalysisInputError, AnalysisProtocolError, } from "../domain/errors.js";
+import { createEvidence } from "../domain/evidence.js";
+import { jsonObjectSchema, jsonValueSchema } from "../domain/jsonValue.js";
+import { reconstructionObligationLedgerInputSchema, reconstructionObligationLedgerPageSchema, } from "../domain/reconstructionObligationLedgerSchemas.js";
+import { err, ok } from "../domain/result.js";
+import { JAVASCRIPT_APPLICATION_WORKFLOW_PROVIDER } from "./InvestigationProviders.js";
+import { deriveReconstructionObligationCandidates } from "./ReconstructionObligationCandidates.js";
+import { evaluateReconstructionObligationLedger } from "./ReconstructionObligationLedgerEvaluation.js";
+const OPERATION = "build_reconstruction_obligation_ledger";
+/** Parse one portable ledger request for both CLI and MCP adapters. */
+export const resolveReconstructionObligationLedgerRequest = (input) => {
+    const parsed = reconstructionObligationLedgerInputSchema.safeParse(input);
+    return parsed.success
+        ? ok(parsed.data)
+        : err(new AnalysisInputError(OPERATION, { cause: parsed.error }));
+};
+/** Build one deterministic ledger page and wrap it in portable Evidence v2. */
+export const buildReconstructionObligationLedgerEvidenceValidated = (input) => {
+    try {
+        const generated = deriveReconstructionObligationCandidates(input.evidence_bundle, input.reviewed_obligations);
+        const ledger = evaluateReconstructionObligationLedger({
+            candidates: generated.candidates,
+            bundle: input.evidence_bundle,
+            manifest: input.manifest,
+            maxObligations: input.limits.max_obligations,
+            generationLimitations: generated.limitations,
+        });
+        const page = pageLedger(ledger, input.page.offset, input.page.limit);
+        return ok(createLedgerEvidence(input, page));
+    }
+    catch (cause) {
+        if (cause instanceof z.ZodError)
+            return err(new AnalysisInputError(OPERATION, { cause }));
+        return err(new AnalysisProtocolError("Reconstruction obligation ledger generation failed", { cause }));
+    }
+};
+const pageLedger = (ledger, offset, limit) => {
+    const obligations = ledger.obligations.slice(offset, offset + limit);
+    const nextOffset = offset + obligations.length < ledger.obligations.length
+        ? offset + obligations.length
+        : null;
+    const { obligations: _allObligations, ...summary } = ledger;
+    return reconstructionObligationLedgerPageSchema.parse({
+        ...summary,
+        page: {
+            offset,
+            limit,
+            total: ledger.obligations.length,
+            returned: obligations.length,
+            next_offset: nextOffset,
+        },
+        obligations,
+    });
+};
+const createLedgerEvidence = (input, page) => createEvidence(undefined, JAVASCRIPT_APPLICATION_WORKFLOW_PROVIDER, {
+    predicateType: "rea.reconstruction-obligation-ledger/v1",
+    operation: OPERATION,
+    parameters: jsonObjectSchema.parse({
+        ledger_id: page.ledger_id,
+        closure_digest: page.closure_digest,
+        limits: input.limits,
+        page: input.page,
+    }),
+    result: jsonValueSchema.parse(page),
+    rawResult: null,
+    confidence: "inferred",
+    authority: "analyst-inference",
+    environment: null,
+    limitations: page.limitations,
+    evidenceLinks: page.evidence_links,
+});

package/dist/application/ReconstructionObligationOriginalCases.js

@@ -0,0 +1,33 @@
+import { evidenceSupportsOriginalAuthority } from "./ReconstructionObligationAuthority.js";
+/** Merge generated and manifest-supplied original observations canonically. */
+export const originalCasesFor = (candidate, binding) => [
+    ...new Map([...candidate.observed_cases, ...(binding?.original_cases ?? [])].map((observed) => [
+        `${observed.kind}:${observed.evidence_id}:${observed.location}`,
+        observed,
+    ])).values(),
+].sort((left, right) => `${left.kind}:${left.evidence_id}:${left.location}`.localeCompare(`${right.kind}:${right.evidence_id}:${right.location}`));
+/** Report original cases that are absent or lack comparable Evidence authority. */
+export const originalCaseDiagnostics = (candidate, binding, evidenceById) => {
+    const diagnostics = [];
+    const originalCases = originalCasesFor(candidate, binding);
+    for (const caseKind of candidate.required_case_kinds) {
+        const cases = originalCases.filter(({ kind }) => kind === caseKind);
+        if (cases.length === 0) {
+            diagnostics.push({
+                code: "missing-original-case",
+                detail: `Original ${caseKind} behavior has not been observed.`,
+            });
+            continue;
+        }
+        if (!cases.some(({ evidence_id: evidenceId }) => {
+            const evidence = evidenceById.get(evidenceId);
+            return (evidence !== undefined &&
+                evidenceSupportsOriginalAuthority(evidence, candidate.required_original_authority));
+        }))
+            diagnostics.push({
+                code: "weak-original-case-authority",
+                detail: `Original ${caseKind} behavior lacks ${candidate.required_original_authority} Evidence.`,
+            });
+    }
+    return diagnostics;
+};

package/dist/application/ReconstructionObligationPolicies.js

@@ -0,0 +1,132 @@
+const APPLICATION_NODE_POLICIES = {
+    package: policy("packaging", "package-lifecycle", "packaged-process", [
+        "positive",
+        "negative",
+        "teardown",
+    ]),
+    installer: policy("packaging", "installer", "packaged-process", [
+        "positive",
+        "negative",
+        "teardown",
+    ]),
+    "context-bridge-api": policy("electron", "context-bridge", "renderer", [
+        "positive",
+        "negative",
+        "malformed",
+    ]),
+    "ipc-channel": policy("electron", "ipc", "renderer", [
+        "positive",
+        "negative",
+        "malformed",
+    ]),
+    "ipc-handler": policy("electron", "ipc", "renderer", [
+        "positive",
+        "negative",
+        "malformed",
+    ]),
+    endpoint: policy("protocol", "endpoint", "protocol", [
+        "positive",
+        "negative",
+        "malformed",
+    ]),
+    storage: policy("persistence", "persistence", "integration", [
+        "positive",
+        "negative",
+        "malformed",
+    ]),
+    worker: policy("process", "worker-lifecycle", "packaged-process", [
+        "positive",
+        "cancellation",
+        "teardown",
+    ]),
+    "service-worker": policy("process", "worker-lifecycle", "packaged-process", [
+        "positive",
+        "cancellation",
+        "teardown",
+    ]),
+    "native-addon": nativePolicy("native-addon"),
+    "native-export": nativePolicy("native-export"),
+    "managed-pinvoke-import": nativePolicy("managed-pinvoke"),
+    "managed-native-implementation": nativePolicy("managed-native"),
+};
+const SEMANTIC_NODE_POLICIES = {
+    "child-process": policy("process", "child-process", "packaged-process", [
+        "positive",
+        "negative",
+        "cancellation",
+        "teardown",
+    ]),
+    stdio: policy("process", "stdio", "packaged-process", [
+        "positive",
+        "negative",
+        "teardown",
+    ]),
+    signal: policy("process", "signal", "packaged-process", [
+        "positive",
+        "cancellation",
+        "teardown",
+    ]),
+    "config-source": parserPolicy("cli", "configuration", "integration"),
+    request: parserPolicy("protocol", "request", "protocol"),
+    response: parserPolicy("protocol", "response", "protocol"),
+    boundary: parserPolicy("application", "parser-boundary", "integration"),
+    resource: policy("persistence", "resource-lifecycle", "integration", [
+        "positive",
+        "negative",
+        "teardown",
+    ]),
+    event: policy("runtime", "event", "packaged-process", [
+        "positive",
+        "negative",
+        "cancellation",
+    ]),
+    timer: policy("runtime", "timer", "packaged-process", [
+        "positive",
+        "cancellation",
+        "teardown",
+    ]),
+    promise: policy("runtime", "promise-ownership", "packaged-process", [
+        "positive",
+        "negative",
+        "cancellation",
+    ]),
+    task: policy("runtime", "task-lifecycle", "packaged-process", [
+        "positive",
+        "cancellation",
+        "teardown",
+    ]),
+};
+export const applicationObligationPolicy = (nodeKind) => APPLICATION_NODE_POLICIES[nodeKind];
+export const semanticObligationPolicy = (nodeKind) => SEMANTIC_NODE_POLICIES[nodeKind];
+function policy(applicationLayer, family, authority, cases) {
+    return {
+        applicationLayer,
+        family,
+        fixtureAuthority: authority,
+        verifierAuthority: authority,
+        originalAuthority: "runtime",
+        cases,
+        requiresParserType: false,
+    };
+}
+function parserPolicy(applicationLayer, family, authority) {
+    return {
+        ...policy(applicationLayer, family, authority, [
+            "positive",
+            "negative",
+            "malformed",
+        ]),
+        requiresParserType: true,
+    };
+}
+function nativePolicy(family) {
+    return {
+        applicationLayer: "native-abi",
+        family,
+        fixtureAuthority: "native-abi",
+        verifierAuthority: "native-abi",
+        originalAuthority: "static",
+        cases: ["positive", "negative"],
+        requiresParserType: false,
+    };
+}

package/dist/application/ReconstructionReadinessService.js

@@ -0,0 +1,48 @@
+import { z } from "zod";
+import { AnalysisInputError, AnalysisProtocolError, } from "../domain/errors.js";
+import { createEvidence } from "../domain/evidence.js";
+import { jsonObjectSchema, jsonValueSchema } from "../domain/jsonValue.js";
+import { createReconstructionReadinessReport } from "../domain/reconstructionReadiness.js";
+import { reconstructionReadinessInputSchema, } from "../domain/reconstructionReadinessSchemas.js";
+import { err, ok } from "../domain/result.js";
+import { JAVASCRIPT_APPLICATION_WORKFLOW_PROVIDER } from "./InvestigationProviders.js";
+const OPERATION = "evaluate_reconstruction_readiness";
+/** Parse one portable readiness request for both CLI and MCP adapters. */
+export const resolveReconstructionReadinessRequest = (input) => {
+    const parsed = reconstructionReadinessInputSchema.safeParse(input);
+    return parsed.success
+        ? ok(parsed.data)
+        : err(new AnalysisInputError(OPERATION, { cause: parsed.error }));
+};
+/** Evaluate and wrap one deterministic readiness report in Evidence v2. */
+export const evaluateReconstructionReadinessValidated = (input) => {
+    try {
+        const report = createReconstructionReadinessReport(input);
+        return ok(createEvidence(undefined, JAVASCRIPT_APPLICATION_WORKFLOW_PROVIDER, {
+            predicateType: "rea.reconstruction-readiness-report/v1",
+            operation: OPERATION,
+            parameters: jsonObjectSchema.parse({
+                source_digest: report.source_digest,
+                expected_source_digest: input.replay.expected_source_digest,
+            }),
+            result: jsonValueSchema.parse(report),
+            rawResult: null,
+            confidence: "inferred",
+            authority: "analyst-inference",
+            environment: null,
+            limitations: report.status === "pass"
+                ? []
+                : [
+                    "Aggregate pass is withheld until every required conformance stage passes.",
+                ],
+            evidenceLinks: report.evidence_links,
+        }));
+    }
+    catch (cause) {
+        if (cause instanceof z.ZodError)
+            return err(new AnalysisInputError(OPERATION, { cause }));
+        return err(new AnalysisProtocolError("Reconstruction readiness evaluation failed", {
+            cause,
+        }));
+    }
+};