@shapeshift-labs/frontier-swarm-codex 0.5.35 → 0.5.37

package/dist/index.js

@@ -336,6 +336,7 @@ export async function runCodexJob(job, options, outDir, lease) {
         evidenceDir: paths.evidenceDir,
         options: options.semanticImport
     });
+    const semanticImportSummary = semanticImport?.sidecar.summary;
     const handoffArtifacts = await discoverCodexHandoffArtifacts({ root: paths.jobDir });
     const evidenceSummaryPath = path.join(paths.evidenceDir, 'evidence.json');
     const evidencePaths = uniqueStrings([
@@ -364,14 +365,14 @@ export async function runCodexJob(job, options, outDir, lease) {
         ...(patchPath ? { patchPath } : {}),
         queueItemIds: [job.taskId],
         verification,
-        ...(semanticImport ? { semanticImport: semanticImport.sidecar.summary } : {}),
+        ...(semanticImportSummary ? { semanticImport: semanticImportSummary } : {}),
         lastMessage: execution.lastMessage,
         error: execution.error,
         metadata: {
             ...(lease ? { leaseId: lease.id, leaseToken: lease.token, fencingToken: lease.fencingToken } : {}),
             resourceAllocation,
             logSummary,
-            ...(semanticImport ? { semanticImport: semanticImport.sidecar.summary } : {}),
+            ...(semanticImportSummary ? { semanticImport: semanticImportSummary } : {}),
             codexHandoffArtifacts: handoffArtifacts
         }
     };
@@ -391,9 +392,16 @@ export async function runCodexJob(job, options, outDir, lease) {
             ...handoffArtifacts.map((artifact) => artifact.path)
         ]),
         queueItemIds: [job.taskId],
-        ...(semanticImport ? { semanticImport: semanticImport.sidecar.summary } : {}),
-        ...(semanticImport ? { metadata: { semanticImport: semanticImport.sidecar.summary } } : {})
+        ...(semanticImportSummary ? { semanticImport: semanticImportSummary } : {}),
+        ...(semanticImportSummary ? { metadata: { semanticImport: semanticImportSummary } } : {})
     });
+    if (semanticImportSummary) {
+        mergeBundle.semanticImport = semanticImportSummary;
+        mergeBundle.metadata = {
+            ...(isObject(mergeBundle.metadata) ? mergeBundle.metadata : {}),
+            semanticImport: semanticImportSummary
+        };
+    }
     await fs.writeFile(paths.mergeBundlePath, JSON.stringify(mergeBundle, null, 2) + '\n');
     await writeCodexPatchIntent({
         file: paths.patchIntentPath,
@@ -650,6 +658,8 @@ async function createCodexSemanticImportSidecar(input) {
                 losses: summarizeSemanticLosses(importResult?.losses),
                 semanticIndex: summarizeSemanticIndex(importResult?.semanticIndex),
                 semanticSidecar: summarizeLangSemanticImportSidecar(semanticSidecar),
+                universalAstLayers: summarizeUniversalAstLayers(importResult?.universalAst, semanticSidecar),
+                proofSpec: summarizeProofSpec(importResult?.universalAst?.proof, semanticSidecar),
                 sourceProjection: summarizeNativeSourceProjection(sourceProjection),
                 nativeCompile: summarizeNativeSourceCompile(nativeCompile),
                 mergeCandidate: summarizeSemanticMergeCandidate(mergeCandidate)
@@ -1472,6 +1482,7 @@ async function copyOrWriteCollectedEvidenceSummary(input) {
 }
 function createCollectedEvidenceEntries(bundle, collectedEvidencePath, bucket) {
     const confidence = bucket === 'ready-to-apply' ? 0.95 : bucket === 'needs-human-port' ? 0.7 : bucket === 'failed-evidence' ? 0.25 : 0.2;
+    const universalAstLayers = semanticImportUniversalAstLayerSummary(bundle.semanticImport);
     const entries = [{
             jobId: bundle.jobId,
             queueItemId: bundle.queueItemIds[0],
@@ -1489,7 +1500,11 @@ function createCollectedEvidenceEntries(bundle, collectedEvidencePath, bucket) {
                 autoMergeable: bundle.autoMergeable,
                 staleAgainstHead: bundle.staleAgainstHead,
                 semanticSymbols: bundle.semanticImport?.semanticIndex.symbols ?? 0,
-                semanticRegions: bundle.semanticImport?.semanticSidecars.ownershipRegions ?? 0
+                semanticRegions: bundle.semanticImport?.semanticSidecars.ownershipRegions ?? 0,
+                universalAstLayers: universalAstLayers.total,
+                universalAstLayerNames: universalAstLayers.names.join(','),
+                proofSpecObligations: semanticImportProofSpecSummary(bundle.semanticImport).obligations,
+                proofSpecFailedObligations: semanticImportProofSpecSummary(bundle.semanticImport).failed
             }
         }];
     for (const file of bundle.evidencePaths) {
@@ -1551,7 +1566,11 @@ function createCodexCompactDashboard(input) {
             weakCount: semanticQualities.filter((entry) => entry.present && entry.warnings.length > 0).length,
             symbolCount: semanticQualities.reduce((sum, entry) => sum + entry.symbols, 0),
             ownershipRegionCount: semanticQualities.reduce((sum, entry) => sum + entry.ownershipRegions, 0),
-            patchHintCount: semanticQualities.reduce((sum, entry) => sum + entry.patchHints, 0)
+            patchHintCount: semanticQualities.reduce((sum, entry) => sum + entry.patchHints, 0),
+            universalAstLayerCount: semanticQualities.reduce((sum, entry) => sum + entry.universalAstLayers, 0),
+            universalAstLayerNames: uniqueStrings(semanticQualities.flatMap((entry) => entry.universalAstLayerNames)),
+            proofSpecObligations: semanticQualities.reduce((sum, entry) => sum + entry.proofSpecObligations, 0),
+            proofSpecFailedObligations: semanticQualities.reduce((sum, entry) => sum + entry.proofSpecFailedObligations, 0)
         },
         evidence: {
             readyToApply: input.dashboard.summary.readyToApplyCount,
@@ -1800,6 +1819,10 @@ function summarizePatchScoreSemanticEvidence(bundle) {
             semanticSymbols: 0,
             ownershipRegions: 0,
             patchHints: 0,
+            universalAstLayers: 0,
+            universalAstLayerNames: [],
+            proofSpecObligations: 0,
+            proofSpecFailedObligations: 0,
             readiness: {},
             lossesBySeverity: {},
             scoreAdjustment,
@@ -1817,6 +1840,10 @@ function summarizePatchScoreSemanticEvidence(bundle) {
     const semanticSymbols = nonNegativeNumber(summary.semanticIndex?.symbols);
     const ownershipRegions = nonNegativeNumber(summary.semanticSidecars?.ownershipRegions);
     const patchHints = nonNegativeNumber(summary.semanticSidecars?.patchHints);
+    const universalAstLayerSummary = semanticImportUniversalAstLayerSummary(summary);
+    const universalAstLayers = universalAstLayerSummary.total;
+    const universalAstLayerNames = universalAstLayerSummary.names;
+    const proofSpec = semanticImportProofSpecSummary(summary);
     const errorLosses = nonNegativeNumber(lossesBySeverity.error);
     const warningLosses = nonNegativeNumber(lossesBySeverity.warning);
     const blocked = nonNegativeNumber(readiness.blocked);
@@ -1856,16 +1883,39 @@ function summarizePatchScoreSemanticEvidence(bundle) {
         scoreAdjustment -= 5;
         cleanEligible = false;
     }
+    if (selected > 0 && universalAstLayers === 0) {
+        reasons.push('semantic sidecar has no universal AST layers');
+        scoreAdjustment -= 5;
+        cleanEligible = false;
+    }
     if (warningLosses > 0 || needsReview > 0) {
         reasons.push('semantic evidence needs review');
         scoreAdjustment -= Math.min(10, warningLosses + needsReview);
         cleanEligible = false;
     }
-    if (sourceMapMappings > 0 && semanticSymbols > 0 && ownershipRegions > 0) {
+    if (proofSpec.failed > 0) {
+        reasons.push(`failed proof obligations: ${proofSpec.failed}`);
+        scoreAdjustment -= 30;
+        cleanEligible = false;
+    }
+    if (proofSpec.stale > 0) {
+        reasons.push(`stale proof obligations: ${proofSpec.stale}`);
+        scoreAdjustment -= 20;
+        cleanEligible = false;
+    }
+    if (proofSpec.open > 0 || proofSpec.unknown > 0) {
+        reasons.push('proof evidence needs review');
+        scoreAdjustment -= Math.min(10, proofSpec.open + proofSpec.unknown);
+        cleanEligible = false;
+    }
+    if (sourceMapMappings > 0 && semanticSymbols > 0 && ownershipRegions > 0 && universalAstLayers > 0) {
         scoreAdjustment += 10;
     }
     if (patchHints > 0)
         scoreAdjustment += 5;
+    if (proofSpec.discharged > 0 && proofSpec.failed === 0 && proofSpec.stale === 0 && proofSpec.open === 0 && proofSpec.unknown === 0) {
+        scoreAdjustment += 5;
+    }
     return {
         present: true,
         total,
@@ -1875,6 +1925,10 @@ function summarizePatchScoreSemanticEvidence(bundle) {
         semanticSymbols,
         ownershipRegions,
         patchHints,
+        universalAstLayers,
+        universalAstLayerNames,
+        proofSpecObligations: proofSpec.obligations,
+        proofSpecFailedObligations: proofSpec.failed,
         readiness,
         lossesBySeverity,
         scoreAdjustment: Math.max(-60, Math.min(15, scoreAdjustment)),
@@ -1890,6 +1944,10 @@ function summarizeCodexSemanticImportQuality(summary, expected = false) {
     const ownershipRegions = nonNegativeNumber(summary?.semanticSidecars?.ownershipRegions);
     const patchHints = nonNegativeNumber(summary?.semanticSidecars?.patchHints);
     const sourceMapMappings = nonNegativeNumber(summary?.sourceMapMappingCount);
+    const universalAstLayerSummary = semanticImportUniversalAstLayerSummary(summary);
+    const universalAstLayers = universalAstLayerSummary.total;
+    const universalAstLayerNames = universalAstLayerSummary.names;
+    const proofSpec = semanticImportProofSpecSummary(summary);
     const present = !!summary;
     const empty = present && (nonNegativeNumber(summary?.total) === 0 || selected === 0 && eligible === 0 && imported === 0 && symbols === 0);
     const warnings = [];
@@ -1905,6 +1963,12 @@ function summarizeCodexSemanticImportQuality(summary, expected = false) {
         warnings.push('semantic import has no ownership regions');
     if (present && selected > 0 && sourceMapMappings === 0)
         warnings.push('semantic import has no source-map mappings');
+    if (present && selected > 0 && universalAstLayers === 0)
+        warnings.push('semantic import has no universal AST layers');
+    if (present && proofSpec.failed > 0)
+        warnings.push('semantic import has failed proof obligations');
+    if (present && proofSpec.stale > 0)
+        warnings.push('semantic import has stale proof obligations');
     return {
         expected,
         present,
@@ -1916,14 +1980,60 @@ function summarizeCodexSemanticImportQuality(summary, expected = false) {
         ownershipRegions,
         patchHints,
         sourceMapMappings,
+        universalAstLayers,
+        universalAstLayerNames,
+        proofSpecObligations: proofSpec.obligations,
+        proofSpecFailedObligations: proofSpec.failed,
         warnings: uniqueStrings(warnings)
     };
 }
+function semanticImportProofSpecSummary(summary) {
+    const input = isObject(summary) && isObject(summary.proofSpec) ? summary.proofSpec : undefined;
+    return input ? normalizeProofSpecSummary(input) : emptyProofSpecSummary();
+}
+function semanticImportUniversalAstLayerSummary(summary) {
+    const input = isObject(summary) && isObject(summary.universalAstLayers) ? summary.universalAstLayers : undefined;
+    const names = Array.isArray(input?.names)
+        ? uniqueStrings(input.names.map((entry) => String(entry)).filter(Boolean))
+        : [];
+    const ids = Array.isArray(input?.ids)
+        ? uniqueStrings(input.ids.map((entry) => String(entry)).filter(Boolean))
+        : [];
+    const byName = isObject(input?.byName) ? numberRecord(input.byName) : {};
+    const total = nonNegativeNumber(input?.total ?? ids.length);
+    return {
+        total,
+        names,
+        ids,
+        byName,
+        empty: input?.empty === true || total === 0
+    };
+}
 function semanticImportSummaryFromBundle(bundle) {
-    if (bundle.semanticImport)
-        return bundle.semanticImport;
     const metadata = bundle.metadata;
-    return metadata?.semanticImport;
+    return richerSemanticImportSummary(bundle.semanticImport, metadata?.semanticImport);
+}
+function richerSemanticImportSummary(first, second) {
+    if (!first)
+        return second;
+    if (!second)
+        return first;
+    return semanticImportSummaryRichness(second) > semanticImportSummaryRichness(first) ? second : first;
+}
+function semanticImportSummaryRichness(summary) {
+    if (!summary)
+        return 0;
+    return [
+        summary.total,
+        summary.selected,
+        summary.imported,
+        summary.sourceMapMappingCount,
+        summary.semanticIndex?.symbols,
+        summary.semanticSidecars?.ownershipRegions,
+        summary.semanticSidecars?.patchHints,
+        semanticImportUniversalAstLayerSummary(summary).total,
+        semanticImportProofSpecSummary(summary).total
+    ].reduce((sum, value) => sum + nonNegativeNumber(value), 0);
 }
 function semanticImportEnabled(input) {
     if (input === true)
@@ -2618,6 +2728,7 @@ function createSemanticImportSidecar(job, records, selection) {
             totals.empty += 1;
         return totals;
     }, { total: 0, symbols: 0, ownershipRegions: 0, patchHints: 0, empty: 0 });
+    const universalAstLayers = summarizeSemanticImportUniversalAstLayers(records);
     const sourceProjections = records.reduce((totals, record) => {
         const summary = record.sourceProjection;
         if (!summary)
@@ -2654,6 +2765,7 @@ function createSemanticImportSidecar(job, records, selection) {
             totals.needsReview += 1;
         return totals;
     }, { total: 0, emitted: 0, preserved: 0, targetStubs: 0, ready: 0, needsReview: 0, blocked: 0 });
+    const proofSpec = summarizeSemanticImportProofSpec(records);
     const lossesBySeverity = {};
     const readiness = {};
     for (const record of records) {
@@ -2689,6 +2801,8 @@ function createSemanticImportSidecar(job, records, selection) {
             lossesBySeverity,
             semanticIndex,
             semanticSidecars,
+            universalAstLayers,
+            proofSpec,
             sourceProjections,
             nativeCompiles,
             readiness
@@ -2716,6 +2830,13 @@ function summarizeLangSemanticImportSidecar(value) {
         symbols: value.summary?.symbols,
         ownershipRegions: value.summary?.ownershipRegions,
         sourceMapMappings: value.summary?.sourceMapMappings,
+        universalAstLayers: value.summary?.universalAstLayers ?? value.universalAstLayers?.total,
+        universalAstLayerNames: Array.isArray(value.summary?.universalAstLayerNames)
+            ? value.summary.universalAstLayerNames
+            : Array.isArray(value.universalAstLayers?.names)
+                ? value.universalAstLayers.names
+                : [],
+        proofSpec: summarizeProofSpec(undefined, value),
         readiness: value.summary?.readiness,
         emptySemanticIndex: value.summary?.emptySemanticIndex,
         patchHints: Array.isArray(value.patchHints) ? value.patchHints.length : 0,
@@ -2732,6 +2853,200 @@ function summarizeLangSemanticImportSidecar(value) {
             : []
     };
 }
+function summarizeSemanticImportProofSpec(records) {
+    const summary = emptyProofSpecSummary();
+    for (const record of records) {
+        mergeProofSpecSummary(summary, record.proofSpec);
+    }
+    summary.empty = summary.total === 0;
+    return summary;
+}
+function summarizeProofSpec(proof, semanticSidecar) {
+    const sidecarProof = semanticSidecar?.proofSpec ?? semanticSidecar?.summary?.proofSpec;
+    if (sidecarProof && typeof sidecarProof === 'object' && hasProofSpecSummaryShape(sidecarProof)) {
+        return normalizeProofSpecSummary(sidecarProof);
+    }
+    const raw = proof && typeof proof === 'object' ? proof : {};
+    const contracts = Array.isArray(raw.contracts) ? raw.contracts : [];
+    const refinements = Array.isArray(raw.refinements) ? raw.refinements : [];
+    const invariants = Array.isArray(raw.invariants) ? raw.invariants : [];
+    const termination = Array.isArray(raw.termination) ? raw.termination : [];
+    const temporal = Array.isArray(raw.temporal) ? raw.temporal : [];
+    const obligations = Array.isArray(raw.obligations) ? raw.obligations : [];
+    const artifacts = Array.isArray(raw.artifacts) ? raw.artifacts : [];
+    const assumptions = Array.isArray(raw.assumptions) ? raw.assumptions : [];
+    const evidence = Array.isArray(raw.evidence) ? raw.evidence : [];
+    const allContracts = [...contracts, ...refinements, ...invariants, ...termination, ...temporal];
+    const byStatus = {};
+    const byContractKind = {};
+    const byArtifactKind = {};
+    for (const obligation of obligations) {
+        const status = String(obligation?.status ?? 'unknown');
+        byStatus[status] = (byStatus[status] ?? 0) + 1;
+    }
+    for (const contract of allContracts) {
+        const kind = String(contract?.kind ?? 'unknown');
+        byContractKind[kind] = (byContractKind[kind] ?? 0) + 1;
+    }
+    for (const artifact of artifacts) {
+        const kind = String(artifact?.kind ?? 'unknown');
+        byArtifactKind[kind] = (byArtifactKind[kind] ?? 0) + 1;
+    }
+    const total = allContracts.length + obligations.length + artifacts.length + assumptions.length;
+    return {
+        total,
+        ids: uniqueStrings([
+            raw.id,
+            ...allContracts.map((record) => record?.id),
+            ...obligations.map((record) => record?.id),
+            ...artifacts.map((record) => record?.id),
+            ...assumptions.map((record) => record?.id),
+            ...evidence.map((record) => record?.id)
+        ].filter(Boolean).map(String)),
+        contracts: contracts.length,
+        refinements: refinements.length,
+        invariants: invariants.length,
+        termination: termination.length,
+        temporal: temporal.length,
+        obligations: obligations.length,
+        artifacts: artifacts.length,
+        assumptions: assumptions.length,
+        evidence: evidence.length,
+        discharged: byStatus.discharged ?? 0,
+        failed: byStatus.failed ?? 0,
+        open: byStatus.open ?? 0,
+        unknown: byStatus.unknown ?? 0,
+        stale: byStatus.stale ?? 0,
+        assumed: byStatus.assumed ?? 0,
+        contractKinds: uniqueStrings(Object.keys(byContractKind)),
+        artifactKinds: uniqueStrings(Object.keys(byArtifactKind)),
+        byStatus,
+        byContractKind,
+        byArtifactKind,
+        empty: total === 0
+    };
+}
+function hasProofSpecSummaryShape(value) {
+    return typeof value.total === 'number' ||
+        typeof value.obligations === 'number' ||
+        typeof value.contracts === 'number' ||
+        typeof value.failed === 'number';
+}
+function normalizeProofSpecSummary(value) {
+    const summary = emptyProofSpecSummary();
+    mergeProofSpecSummary(summary, value);
+    summary.empty = summary.total === 0;
+    return summary;
+}
+function emptyProofSpecSummary() {
+    return {
+        total: 0,
+        ids: [],
+        contracts: 0,
+        refinements: 0,
+        invariants: 0,
+        termination: 0,
+        temporal: 0,
+        obligations: 0,
+        artifacts: 0,
+        assumptions: 0,
+        evidence: 0,
+        discharged: 0,
+        failed: 0,
+        open: 0,
+        unknown: 0,
+        stale: 0,
+        assumed: 0,
+        contractKinds: [],
+        artifactKinds: [],
+        byStatus: {},
+        byContractKind: {},
+        byArtifactKind: {},
+        empty: true
+    };
+}
+function mergeProofSpecSummary(target, input) {
+    if (!input || typeof input !== 'object')
+        return;
+    for (const key of ['total', 'contracts', 'refinements', 'invariants', 'termination', 'temporal', 'obligations', 'artifacts', 'assumptions', 'evidence', 'discharged', 'failed', 'open', 'unknown', 'stale', 'assumed']) {
+        target[key] += nonNegativeNumber(input[key]);
+    }
+    target.ids = uniqueStrings([...target.ids, ...proofStringList(input.ids)]);
+    target.contractKinds = uniqueStrings([...target.contractKinds, ...proofStringList(input.contractKinds)]);
+    target.artifactKinds = uniqueStrings([...target.artifactKinds, ...proofStringList(input.artifactKinds)]);
+    for (const [status, count] of Object.entries(numberRecord(input.byStatus))) {
+        target.byStatus[status] = (target.byStatus[status] ?? 0) + count;
+    }
+    for (const [kind, count] of Object.entries(numberRecord(input.byContractKind))) {
+        target.byContractKind[kind] = (target.byContractKind[kind] ?? 0) + count;
+    }
+    for (const [kind, count] of Object.entries(numberRecord(input.byArtifactKind))) {
+        target.byArtifactKind[kind] = (target.byArtifactKind[kind] ?? 0) + count;
+    }
+}
+function proofStringList(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.map((entry) => String(entry)).filter(Boolean);
+}
+function summarizeSemanticImportUniversalAstLayers(records) {
+    const byName = {};
+    const names = [];
+    const ids = [];
+    for (const record of records) {
+        for (const name of record.universalAstLayers?.names ?? []) {
+            names.push(name);
+            byName[name] = (byName[name] ?? 0) + 1;
+        }
+        ids.push(...(record.universalAstLayers?.ids ?? []));
+    }
+    const uniqueNames = uniqueStrings(names);
+    const uniqueIds = uniqueStrings(ids);
+    return {
+        total: records.reduce((sum, record) => sum + (record.universalAstLayers?.total ?? 0), 0),
+        names: uniqueNames,
+        ids: uniqueIds,
+        byName,
+        empty: uniqueIds.length === 0
+    };
+}
+function summarizeUniversalAstLayers(universalAst, semanticSidecar) {
+    const layers = collectUniversalAstLayerRecords(universalAst?.layers);
+    const sidecarNames = Array.isArray(semanticSidecar?.summary?.universalAstLayerNames)
+        ? semanticSidecar.summary.universalAstLayerNames
+        : Array.isArray(semanticSidecar?.universalAstLayers?.names)
+            ? semanticSidecar.universalAstLayers.names
+            : [];
+    const sidecarIds = Array.isArray(semanticSidecar?.universalAstLayers?.ids) ? semanticSidecar.universalAstLayers.ids : [];
+    const byName = {};
+    for (const layer of layers) {
+        if (!layer?.layer)
+            continue;
+        byName[String(layer.layer)] = (byName[String(layer.layer)] ?? 0) + 1;
+    }
+    for (const [name, count] of Object.entries(semanticSidecar?.universalAstLayers?.byName ?? {})) {
+        byName[name] = Math.max(byName[name] ?? 0, Number(count) || 0);
+    }
+    const names = uniqueStrings([
+        ...layers.map((layer) => String(layer?.layer ?? '')).filter(Boolean),
+        ...sidecarNames.map((name) => String(name)).filter(Boolean)
+    ]);
+    const ids = uniqueStrings([
+        ...layers.map((layer) => String(layer?.id ?? '')).filter(Boolean),
+        ...sidecarIds.map((id) => String(id)).filter(Boolean)
+    ]);
+    const total = Math.max(layers.length, Number(semanticSidecar?.universalAstLayers?.total ?? 0) || 0, ids.length);
+    return { total, names, ids, byName, empty: total === 0 };
+}
+function collectUniversalAstLayerRecords(layers) {
+    if (!layers)
+        return [];
+    if (Array.isArray(layers))
+        return layers.filter(Boolean);
+    if (typeof layers !== 'object')
+        return [];
+    return Object.values(layers).flatMap((value) => Array.isArray(value) ? value : [value]).filter(Boolean);
+}
 function summarizeNativeSourceProjection(value) {
     if (!value || typeof value !== 'object')
         return undefined;