onto-mcp 0.3.2 → 0.4.0

package/dist/core-runtime/reconstruct/pipeline-execution-ledger.js

@@ -1,4 +1,6 @@
+import fs from "node:fs/promises";
 import path from "node:path";
+import { parse as parseYaml } from "yaml";
 import { PIPELINE_EXECUTION_LEDGER_SCHEMA_VERSION, buildLedgerTrust, buildOutputHashes, isTrustedLedgerUnit, normalizeLedgerRefs, } from "../pipeline-execution-ledger.js";
 const RECONSTRUCT_LEDGER_STAGE_SPECS = [
     {
@@ -8,12 +10,19 @@ const RECONSTRUCT_LEDGER_STAGE_SPECS = [
         artifactKey: "target_material_profile",
         upstreamUnitIds: [],
     },
+    {
+        unitId: "target_material_profile_validation",
+        unitKind: "runtime_validation",
+        owner: "runtime",
+        artifactKey: "target_material_profile_validation",
+        upstreamUnitIds: ["target_material_profile"],
+    },
     {
         unitId: "source_inventory",
         unitKind: "source_inventory",
         owner: "runtime",
         artifactKey: "source_inventory",
-        upstreamUnitIds: ["target_material_profile"],
+        upstreamUnitIds: ["target_material_profile_validation"],
     },
     {
         unitId: "initial_source_frontier",
@@ -43,20 +52,6 @@ const RECONSTRUCT_LEDGER_STAGE_SPECS = [
         artifactKey: "source_observation_directive_validation",
         upstreamUnitIds: ["observation_directive"],
     },
-    {
-        unitId: "domain_context_selection",
-        unitKind: "semantic_context_selection",
-        owner: "host_llm",
-        artifactKey: "domain_context_selection",
-        upstreamUnitIds: ["observation_directive_validation"],
-    },
-    {
-        unitId: "domain_context_selection_validation",
-        unitKind: "runtime_validation",
-        owner: "runtime",
-        artifactKey: "domain_context_selection_validation",
-        upstreamUnitIds: ["domain_context_selection"],
-    },
     {
         unitId: "lens_judgment",
         unitKind: "semantic_lens_judgment",
@@ -83,28 +78,58 @@ const RECONSTRUCT_LEDGER_STAGE_SPECS = [
         unitKind: "runtime_validation",
         owner: "runtime",
         artifactKey: "source_frontier_validation",
-        upstreamUnitIds: ["source_frontier"],
+        upstreamUnitIds: [
+            "source_frontier",
+            "source_inventory",
+            "target_material_profile_validation",
+            "source_observation",
+        ],
     },
     {
-        unitId: "seed_candidate",
-        unitKind: "semantic_seed",
+        unitId: "candidate_inventory",
+        unitKind: "semantic_candidate_inventory",
         owner: "host_llm",
-        artifactKey: "seed_candidate",
+        artifactKey: "candidate_inventory",
         upstreamUnitIds: ["source_frontier_validation"],
     },
     {
-        unitId: "seed_candidate_validation",
+        unitId: "candidate_disposition",
+        unitKind: "semantic_candidate_disposition",
+        owner: "host_llm",
+        artifactKey: "candidate_disposition",
+        upstreamUnitIds: ["candidate_inventory"],
+    },
+    {
+        unitId: "candidate_disposition_validation",
+        unitKind: "runtime_validation",
+        owner: "runtime",
+        artifactKey: "candidate_disposition_validation",
+        upstreamUnitIds: [
+            "candidate_inventory",
+            "candidate_disposition",
+            "source_observation",
+        ],
+    },
+    {
+        unitId: "ontology_seed",
+        unitKind: "semantic_ontology_seed",
+        owner: "host_llm",
+        artifactKey: "ontology_seed",
+        upstreamUnitIds: ["candidate_disposition_validation"],
+    },
+    {
+        unitId: "ontology_seed_validation",
         unitKind: "runtime_validation",
         owner: "runtime",
-        artifactKey: "seed_candidate_validation",
-        upstreamUnitIds: ["seed_candidate"],
+        artifactKey: "ontology_seed_validation",
+        upstreamUnitIds: ["ontology_seed"],
     },
     {
         unitId: "claim_realization",
         unitKind: "semantic_map",
         owner: "host_llm",
         artifactKey: "claim_realization_map",
-        upstreamUnitIds: ["seed_candidate_validation"],
+        upstreamUnitIds: ["ontology_seed_validation"],
     },
     {
         unitId: "claim_realization_validation",
@@ -118,7 +143,7 @@ const RECONSTRUCT_LEDGER_STAGE_SPECS = [
         unitKind: "confirmation",
         owner: "user_or_host_mediated",
         artifactKey: "seed_confirmation",
-        upstreamUnitIds: ["seed_candidate_validation", "claim_realization_validation"],
+        upstreamUnitIds: ["ontology_seed_validation", "claim_realization_validation"],
     },
     {
         unitId: "seed_confirmation_validation",
@@ -146,28 +171,41 @@ const RECONSTRUCT_LEDGER_STAGE_SPECS = [
         unitKind: "semantic_assessment",
         owner: "host_llm",
         artifactKey: "competency_question_assessment",
-        upstreamUnitIds: ["competency_questions_validation"],
+        upstreamUnitIds: [
+            "competency_questions_validation",
+            "claim_realization_validation",
+        ],
     },
     {
         unitId: "competency_question_assessment_validation",
         unitKind: "runtime_validation",
         owner: "runtime",
         artifactKey: "competency_question_assessment_validation",
-        upstreamUnitIds: ["competency_question_assessment"],
+        upstreamUnitIds: [
+            "competency_question_assessment",
+            "claim_realization_validation",
+        ],
     },
     {
         unitId: "failure_classification",
         unitKind: "semantic_failure_classification",
         owner: "host_llm",
         artifactKey: "failure_classification",
-        upstreamUnitIds: ["competency_question_assessment_validation"],
+        upstreamUnitIds: [
+            "seed_confirmation_validation",
+            "competency_question_assessment_validation",
+        ],
     },
     {
         unitId: "failure_classification_validation",
         unitKind: "runtime_validation",
         owner: "runtime",
         artifactKey: "failure_classification_validation",
-        upstreamUnitIds: ["failure_classification"],
+        upstreamUnitIds: [
+            "failure_classification",
+            "competency_question_assessment_validation",
+            "seed_confirmation_validation",
+        ],
     },
     {
         unitId: "revision_proposal",
@@ -197,32 +235,142 @@ const RECONSTRUCT_LEDGER_STAGE_SPECS = [
         artifactKey: "stop_decision",
         upstreamUnitIds: ["metrics"],
     },
+    {
+        unitId: "pre_handoff_run_manifest_validation",
+        unitKind: "runtime_validation",
+        owner: "runtime",
+        artifactKey: "pre_handoff_run_manifest_validation",
+        upstreamUnitIds: [
+            "target_material_profile_validation",
+            "observation_directive_validation",
+            "source_frontier_validation",
+            "candidate_disposition_validation",
+            "ontology_seed_validation",
+            "claim_realization_validation",
+            "seed_confirmation_validation",
+            "competency_questions_validation",
+            "competency_question_assessment_validation",
+            "failure_classification_validation",
+            "revision_proposal_validation",
+            "metrics",
+            "stop_decision",
+        ],
+    },
+    {
+        unitId: "handoff_decision_validation",
+        unitKind: "runtime_validation",
+        owner: "runtime",
+        artifactKey: "handoff_decision_validation",
+        upstreamUnitIds: [
+            "target_material_profile_validation",
+            "observation_directive_validation",
+            "source_frontier_validation",
+            "candidate_disposition_validation",
+            "ontology_seed_validation",
+            "claim_realization_validation",
+            "seed_confirmation_validation",
+            "competency_questions_validation",
+            "competency_question_assessment_validation",
+            "failure_classification_validation",
+            "revision_proposal_validation",
+            "metrics",
+            "stop_decision",
+            "pre_handoff_run_manifest_validation",
+        ],
+    },
     {
         unitId: "final_output",
         unitKind: "final_output",
         owner: "host_llm",
         artifactKey: "final_output",
-        upstreamUnitIds: ["stop_decision"],
+        upstreamUnitIds: ["handoff_decision_validation"],
+    },
+    {
+        unitId: "final_output_provenance_validation",
+        unitKind: "runtime_validation",
+        owner: "runtime",
+        artifactKey: "final_output_provenance_validation",
+        upstreamUnitIds: ["final_output"],
     },
     {
         unitId: "record_assembly",
         unitKind: "record_assembly",
         owner: "runtime",
         artifactKey: "reconstruct_record",
-        upstreamUnitIds: ["final_output"],
+        upstreamUnitIds: ["final_output_provenance_validation"],
+    },
+    {
+        unitId: "post_publication_run_manifest_validation",
+        unitKind: "runtime_validation",
+        owner: "runtime",
+        artifactKey: "post_publication_run_manifest_validation",
+        upstreamUnitIds: ["record_assembly"],
     },
 ];
 const VALIDATION_GATE_BY_AUTHORED_UNIT = new Map([
     ["observation_directive", "observation_directive_validation"],
     ["source_frontier", "source_frontier_validation"],
-    ["seed_candidate", "seed_candidate_validation"],
+    ["candidate_inventory", "candidate_disposition_validation"],
+    ["candidate_disposition", "candidate_disposition_validation"],
+    ["ontology_seed", "ontology_seed_validation"],
     ["claim_realization", "claim_realization_validation"],
     ["seed_confirmation", "seed_confirmation_validation"],
     ["competency_questions", "competency_questions_validation"],
     ["competency_question_assessment", "competency_question_assessment_validation"],
     ["failure_classification", "failure_classification_validation"],
     ["revision_proposal", "revision_proposal_validation"],
+    ["stop_decision", "handoff_decision_validation"],
+    ["final_output", "final_output_provenance_validation"],
+]);
+const PRESENCE_INPUTS_BY_RUNTIME_VALIDATION = new Map([
+    ["target_material_profile_validation", ["target_material_profile"]],
+    ["observation_directive_validation", ["observation_directive"]],
+    ["source_frontier_validation", ["source_frontier", "source_inventory"]],
+    [
+        "candidate_disposition_validation",
+        ["candidate_inventory", "candidate_disposition", "source_observation"],
+    ],
+    ["ontology_seed_validation", ["ontology_seed"]],
+    ["claim_realization_validation", ["claim_realization"]],
+    ["seed_confirmation_validation", ["seed_confirmation"]],
+    ["competency_questions_validation", ["competency_questions"]],
+    ["competency_question_assessment_validation", ["competency_question_assessment"]],
+    ["failure_classification_validation", ["failure_classification"]],
+    ["revision_proposal_validation", ["revision_proposal"]],
+    ["handoff_decision_validation", ["stop_decision"]],
+    ["final_output_provenance_validation", ["final_output"]],
 ]);
+function isPresenceInput(args) {
+    return (PRESENCE_INPUTS_BY_RUNTIME_VALIDATION.get(args.validationUnitId) ?? [])
+        .includes(args.upstreamUnitId);
+}
+async function runtimeValidationOutputStatus(outputRefs) {
+    if (outputRefs.length === 0)
+        return "not_available";
+    let sawValidationArtifact = false;
+    for (const outputRef of outputRefs) {
+        let parsed;
+        try {
+            parsed = parseYaml(await fs.readFile(outputRef, "utf8"));
+        }
+        catch (error) {
+            const code = error.code;
+            if (code === "ENOENT" || code === "ENOTDIR")
+                return "not_available";
+            throw error;
+        }
+        const validationStatus = parsed
+            ?.validation_status;
+        if (validationStatus === "invalid")
+            return "invalid";
+        if (validationStatus === "valid") {
+            sawValidationArtifact = true;
+            continue;
+        }
+        return "not_validation_artifact";
+    }
+    return sawValidationArtifact ? "valid" : "not_validation_artifact";
+}
 function artifactRefForKey(args) {
     if (args.key === "reconstruct_record")
         return args.reconstructRecordRef ?? null;
@@ -247,15 +395,32 @@ function manifestStatus(manifest, unitId) {
     return null;
 }
 function trustForReconstructUnit(args) {
+    if (args.spec.unitKind === "runtime_validation" && args.status === "completed") {
+        const validationStatus = args.validationStatusesByUnitId.get(args.spec.unitId);
+        if (validationStatus !== "valid") {
+            return {
+                trustStatus: "untrusted",
+                trustReason: validationStatus === "invalid"
+                    ? "Runtime validation artifact exists but reports validation_status: invalid."
+                    : "Runtime validation unit did not produce a valid validation artifact.",
+            };
+        }
+    }
     const validationGateUnitId = VALIDATION_GATE_BY_AUTHORED_UNIT.get(args.spec.unitId);
     if (validationGateUnitId) {
-        const validationOutputPresent = args.artifactRefsByUnitId.get(validationGateUnitId)?.some((ref) => ref.length > 0) ?? false;
-        if (!validationOutputPresent) {
+        const validationStatus = args.validationStatusesByUnitId.get(validationGateUnitId);
+        if (!validationStatus || validationStatus === "not_available") {
             return {
                 trustStatus: "untrusted",
                 trustReason: "LLM or user-authored artifact exists only as a candidate until its runtime validation gate completes.",
             };
         }
+        if (!args.trustedUnitIds.has(validationGateUnitId)) {
+            return {
+                trustStatus: "blocked_by_upstream",
+                trustReason: "LLM or user-authored artifact exists only as a candidate until its runtime validation gate is trusted.",
+            };
+        }
     }
     return buildLedgerTrust({
         status: args.status,
@@ -277,55 +442,80 @@ export async function buildReconstructPipelineExecutionLedger(params) {
             }),
         ]),
     ]));
-    const trustedUnitIds = new Set();
-    const units = [];
+    const outputHashesByUnitId = new Map();
+    const validationStatusesByUnitId = new Map();
     for (const spec of RECONSTRUCT_LEDGER_STAGE_SPECS) {
         const outputRefs = artifactRefsByUnitId.get(spec.unitId) ?? [];
         const outputHashes = await buildOutputHashes(outputRefs);
-        const outputPresent = outputRefs.length > 0 &&
-            outputRefs.every((outputRef) => outputHashes[outputRef] !== null);
-        const upstreamTrusted = spec.upstreamUnitIds.every((unitId) => {
-            if (spec.unitKind === "runtime_validation") {
-                return (artifactRefsByUnitId.get(unitId) ?? []).length > 0;
-            }
-            return trustedUnitIds.has(unitId);
-        });
-        const status = manifestStatus(params.reconstructRunManifest, spec.unitId) ??
-            (outputPresent
-                ? "completed"
-                : upstreamTrusted
-                    ? "missing"
-                    : "not_reached");
-        const trust = trustForReconstructUnit({
-            spec,
-            status,
-            outputRefs,
-            outputHashes,
-            upstreamTrusted,
-            artifactRefsByUnitId,
-        });
-        const manifestStep = manifestStepByUnitId.get(spec.unitId);
-        const entry = {
-            unitId: spec.unitId,
-            unitKind: spec.unitKind,
-            owner: spec.owner,
-            producedArtifactRefs: outputRefs,
-            consumedArtifactRefs: normalizeLedgerRefs([
-                ...spec.upstreamUnitIds.flatMap((unitId) => artifactRefsByUnitId.get(unitId) ?? []),
-            ]),
-            outputRefs,
-            outputHashes,
-            status,
-            trustStatus: trust.trustStatus,
-            trustReason: trust.trustReason,
-            attemptCount: manifestStep ? 1 : 0,
-            lastFailureMessage: null,
-            upstreamUnitIds: spec.upstreamUnitIds,
-            downstreamUnitIds: downstreamUnitIds.get(spec.unitId) ?? [],
-        };
-        units.push(entry);
-        if (isTrustedLedgerUnit(entry))
-            trustedUnitIds.add(entry.unitId);
+        outputHashesByUnitId.set(spec.unitId, outputHashes);
+        if (spec.unitKind === "runtime_validation") {
+            validationStatusesByUnitId.set(spec.unitId, await runtimeValidationOutputStatus(outputRefs));
+        }
+    }
+    let trustedUnitIds = new Set();
+    let units = [];
+    for (let pass = 0; pass < RECONSTRUCT_LEDGER_STAGE_SPECS.length; pass += 1) {
+        const nextTrustedUnitIds = new Set();
+        const nextUnits = [];
+        for (const spec of RECONSTRUCT_LEDGER_STAGE_SPECS) {
+            const outputRefs = artifactRefsByUnitId.get(spec.unitId) ?? [];
+            const outputHashes = outputHashesByUnitId.get(spec.unitId) ?? {};
+            const outputPresent = outputRefs.length > 0 &&
+                outputRefs.every((outputRef) => outputHashes[outputRef] !== null);
+            const upstreamTrusted = spec.upstreamUnitIds.every((unitId) => {
+                if (spec.unitKind === "runtime_validation" &&
+                    isPresenceInput({
+                        validationUnitId: spec.unitId,
+                        upstreamUnitId: unitId,
+                    })) {
+                    return (artifactRefsByUnitId.get(unitId) ?? []).length > 0;
+                }
+                return trustedUnitIds.has(unitId);
+            });
+            const status = manifestStatus(params.reconstructRunManifest, spec.unitId) ??
+                (outputPresent
+                    ? "completed"
+                    : upstreamTrusted
+                        ? "missing"
+                        : "not_reached");
+            const trust = trustForReconstructUnit({
+                spec,
+                status,
+                outputRefs,
+                outputHashes,
+                upstreamTrusted,
+                trustedUnitIds,
+                validationStatusesByUnitId,
+            });
+            const manifestStep = manifestStepByUnitId.get(spec.unitId);
+            const entry = {
+                unitId: spec.unitId,
+                unitKind: spec.unitKind,
+                owner: spec.owner,
+                producedArtifactRefs: outputRefs,
+                consumedArtifactRefs: normalizeLedgerRefs([
+                    ...spec.upstreamUnitIds.flatMap((unitId) => artifactRefsByUnitId.get(unitId) ?? []),
+                ]),
+                outputRefs,
+                outputHashes,
+                status,
+                trustStatus: trust.trustStatus,
+                trustReason: trust.trustReason,
+                attemptCount: manifestStep ? 1 : 0,
+                lastFailureMessage: null,
+                upstreamUnitIds: spec.upstreamUnitIds,
+                downstreamUnitIds: downstreamUnitIds.get(spec.unitId) ?? [],
+            };
+            nextUnits.push(entry);
+            if (isTrustedLedgerUnit(entry))
+                nextTrustedUnitIds.add(spec.unitId);
+        }
+        const stable = nextTrustedUnitIds.size === trustedUnitIds.size &&
+            [...nextTrustedUnitIds].every((unitId) => trustedUnitIds.has(unitId));
+        trustedUnitIds = nextTrustedUnitIds;
+        units = nextUnits;
+        if (stable)
+            break;
     }
     return {
         schemaVersion: PIPELINE_EXECUTION_LEDGER_SCHEMA_VERSION,