@shapeshift-labs/frontier-lang-compiler 0.2.99 → 0.2.101

package/dist/internal/index-impl/semanticLineageInferenceMatching.js

@@ -1,4 +1,5 @@
 import { idFragment, uniqueStrings } from '../../native-import-utils.js';
+import { addIdentityHashEvidence, addSourceHashEvidence, hashEvidenceSummary } from './semanticLineageHashEvidence.js';
 import { createSemanticLineageEvent } from './semanticLineageRecords.js';
 
 export function matchExactAnchors(beforeSymbols, afterSymbols) {
@@ -8,8 +9,12 @@ export function matchExactAnchors(beforeSymbols, afterSymbols) {
   const matchedAfterKeys = new Set();
   for (const before of beforeSymbols) {
     const after = afterByKey.get(before.anchor.key);
-    if (after && anchorsSameLocation(before.anchor, after.anchor)) {
-      matched.push({ before: symbolSummary(before), after: symbolSummary(after) });
+    if (after) {
+      matched.push({
+        before: symbolSummary(before),
+        after: symbolSummary(after),
+        sourceSpanMoved: !anchorsSameLocation(before.anchor, after.anchor)
+      });
       matchedAfterKeys.add(after.anchor.key);
     } else {
       unmatchedBefore.push(before);
@@ -27,21 +32,33 @@ export function matchLineageCandidates(beforeSymbols, afterSymbols, input, optio
   const events = [];
   const ambiguous = [];
   const unmatchedBefore = [];
-  for (const before of beforeSymbols) {
-    const ranked = afterSymbols
-      .filter((after) => !claimedAfter.has(after.anchor.key))
-      .map((after) => ({ after, score: scoreLineagePair(before, after) }))
-      .filter((candidate) => candidate.score.confidence >= options.minConfidence)
-      .sort(compareCandidateScores);
+  const rankedByBefore = beforeSymbols.map((before) => ({
+    before,
+    ranked: rankLineageCandidates(before, afterSymbols, options)
+  }));
+  const contendersByAfter = afterContenderIndex(rankedByBefore);
+  for (const entry of rankedByBefore) {
+    const before = entry.before;
+    const ranked = entry.ranked.filter((candidate) => !claimedAfter.has(candidate.after.anchor.key));
     const best = ranked[0];
     const runnerUp = ranked[1];
     if (!best) {
       unmatchedBefore.push(before);
       continue;
     }
+    const splitTargets = splitLineageCandidates(before, ranked, contendersByAfter, options);
+    if (splitTargets.length > 1) {
+      for (const candidate of splitTargets) claimedAfter.add(candidate.after.anchor.key);
+      events.push(inferredSplitEvent(before, splitTargets, input));
+      continue;
+    }
+    const targetContention = ambiguousTargetContention(before, best, contendersByAfter, options);
+    if (targetContention.length > 0) {
+      ambiguous.push(ambiguousMatch(before, ranked, ['ambiguous-lineage-candidates', 'ambiguous-target-lineage-candidates']));
+      continue;
+    }
     if (runnerUp && best.score.confidence - runnerUp.score.confidence < options.ambiguityMargin) {
       ambiguous.push(ambiguousMatch(before, ranked));
-      unmatchedBefore.push(before);
       continue;
     }
     claimedAfter.add(best.after.anchor.key);
@@ -55,6 +72,14 @@ export function matchLineageCandidates(beforeSymbols, afterSymbols, input, optio
   };
 }
 
+function rankLineageCandidates(before, afterSymbols, options) {
+  return afterSymbols
+    .filter((after) => before.anchor.key !== after.anchor.key)
+    .map((after) => ({ before, after, score: scoreLineagePair(before, after) }))
+    .filter((candidate) => candidate.score.confidence >= options.minConfidence)
+    .sort(compareCandidateScores);
+}
+
 export function symbolSummary(symbol) {
   return {
     key: symbol.anchor.key,
@@ -64,6 +89,9 @@ export function symbolSummary(symbol) {
     language: symbol.language,
     sourcePath: symbol.anchor.sourcePath,
     sourceHash: symbol.anchor.sourceHash,
+    identityHash: firstString(symbol.identityHash, symbol.anchor.metadata?.identityHash),
+    semanticIdentityHash: firstString(symbol.semanticIdentityHash, symbol.anchor.metadata?.semanticIdentityHash),
+    sourceIdentityHash: firstString(symbol.sourceIdentityHash, symbol.anchor.metadata?.sourceIdentityHash),
     sourceSpan: symbol.anchor.sourceSpan,
     signatureHash: symbol.signatureHash,
     bodyHash: symbol.spanHash,
@@ -71,7 +99,7 @@ export function symbolSummary(symbol) {
   };
 }
 
-function ambiguousMatch(before, ranked) {
+function ambiguousMatch(before, ranked, reasonCodes = ['ambiguous-lineage-candidates']) {
   return {
     before: symbolSummary(before),
     candidates: ranked.slice(0, 4).map((candidate) => ({
@@ -79,7 +107,7 @@ function ambiguousMatch(before, ranked) {
       confidence: candidate.score.confidence,
       reasons: candidate.score.reasons
     })),
-    reasonCodes: ['ambiguous-lineage-candidates']
+    reasonCodes: uniqueStrings(reasonCodes)
   };
 }
 
@@ -94,7 +122,8 @@ function inferredEvent(before, after, score, input) {
     && before.anchor.symbolName !== after.anchor.symbolName;
   const pathChanged = before.anchor.sourcePath !== after.anchor.sourcePath;
   const spanMoved = JSON.stringify(before.anchor.sourceSpan ?? null) !== JSON.stringify(after.anchor.sourceSpan ?? null);
-  const eventKind = nameChanged ? 'renamed' : 'moved';
+  const recreated = !nameChanged && score.reasons.includes('delete-recreate-candidate');
+  const eventKind = nameChanged ? 'renamed' : recreated ? 'recreated' : 'moved';
   return createSemanticLineageEvent({
     id: `lineage_inferred_${idFragment(firstString(input.id, before.anchor.key))}_${idFragment(after.anchor.key)}`,
     createdAt: input.generatedAt,
@@ -119,8 +148,57 @@ function inferredEvent(before, after, score, input) {
       inferred: true,
       algorithm: 'frontier.semantic-lineage-inference.v1',
       reasonCodes: score.reasons,
+      hashEvidence: hashEvidenceSummary(score.reasons),
       moved: pathChanged || spanMoved,
       renamed: nameChanged,
+      recreated,
+      anchorKeyChanged: before.anchor.key !== after.anchor.key,
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false
+    }
+  });
+}
+
+function inferredSplitEvent(before, candidates, input) {
+  const targets = candidates.map((candidate) => candidate.after);
+  const reasons = uniqueStrings([
+    ...candidates.flatMap((candidate) => candidate.score.reasons),
+    'split-lineage-candidate'
+  ]);
+  const confidence = Math.min(...candidates.map((candidate) => candidate.score.confidence));
+  const pathMatch = targets.every((target) => before.anchor.sourcePath === target.anchor.sourcePath);
+  const spanMoved = targets.some((target) => (
+    before.anchor.sourcePath !== target.anchor.sourcePath
+    || JSON.stringify(before.anchor.sourceSpan ?? null) !== JSON.stringify(target.anchor.sourceSpan ?? null)
+  ));
+  return createSemanticLineageEvent({
+    id: `lineage_split_${idFragment(firstString(input.id, before.anchor.key))}_${idFragment(targets.map((target) => target.anchor.key).join('_'))}`,
+    createdAt: input.generatedAt,
+    eventKind: 'split',
+    from: before.anchor,
+    to: targets.map((target) => target.anchor),
+    confidence,
+    actor: input.actor,
+    actorId: input.actorId,
+    actorRole: input.actorRole ?? 'semantic-lineage-inference',
+    operationId: input.operationId,
+    deps: input.deps,
+    heads: input.heads,
+    stateVector: input.stateVector,
+    evidenceIds: [input.evidenceId ?? `evidence_${idFragment(input.id ?? before.anchor.key)}_lineage_inference`],
+    signatureHashMatch: candidates.every((candidate) => candidate.score.reasons.includes('signature-hash-match')),
+    bodyHashMatch: candidates.every((candidate) => candidate.score.reasons.includes('body-hash-match')),
+    pathMatch,
+    sourceSpanMoved: spanMoved,
+    conflictKeys: uniqueStrings([before.anchor.key, ...targets.map((target) => target.anchor.key)]),
+    metadata: {
+      inferred: true,
+      algorithm: 'frontier.semantic-lineage-inference.v1',
+      reasonCodes: reasons,
+      hashEvidence: hashEvidenceSummary(reasons),
+      split: true,
+      targetCount: targets.length,
+      candidateConfidences: candidates.map((candidate) => candidate.score.confidence),
       autoMergeClaim: false,
       semanticEquivalenceClaim: false
     }
@@ -134,18 +212,81 @@ function scoreLineagePair(before, after) {
     score += value;
     reasons.push(reason);
   };
+  const note = (reason) => reasons.push(reason);
   if (before.anchor.key && before.anchor.key === after.anchor.key) add(0.4, 'anchor-key-match');
   if (before.name && before.name === after.name) add(0.28, 'symbol-name-match');
   if (before.kind && before.kind === after.kind) add(0.12, 'symbol-kind-match');
+  addIdentityHashEvidence(before, after, add, note);
   if (before.signatureHash && before.signatureHash === after.signatureHash) add(0.52, 'signature-hash-match');
   if (before.spanHash && before.spanHash === after.spanHash) add(0.22, 'body-hash-match');
   if (before.anchor.kind && before.anchor.kind === after.anchor.kind) add(0.06, 'anchor-kind-match');
   if (before.anchor.sourcePath && before.anchor.sourcePath === after.anchor.sourcePath) add(0.04, 'source-path-match');
+  addSourceHashEvidence(before, after, add, note, reasons, sameSymbolSurface);
   if (sourceSpanRangeSame(before.anchor.sourceSpan, after.anchor.sourceSpan)) add(0.18, 'source-span-range-match');
   if (before.ownershipRegionKind && before.ownershipRegionKind === after.ownershipRegionKind) add(0.04, 'ownership-kind-match');
   if (before.nativeAstNodeId && before.nativeAstNodeId === after.nativeAstNodeId) add(0.06, 'native-node-id-match');
   if (before.anchor.sourcePath !== after.anchor.sourcePath && (before.name === after.name || before.signatureHash === after.signatureHash)) add(0.04, 'source-path-moved');
-  return { confidence: Math.max(0, Math.min(1, Number(score.toFixed(3)))), reasons };
+  if (before.anchor.key && after.anchor.key && before.anchor.key !== after.anchor.key) note('anchor-key-changed');
+  if (sameSymbolSurface(before, after)) note('same-symbol-surface');
+  if (deleteRecreateCandidate(before, after, reasons)) note('delete-recreate-candidate');
+  return { confidence: Math.max(0, Math.min(1, Number(score.toFixed(3)))), reasons: uniqueStrings(reasons) };
+}
+
+function afterContenderIndex(rankedByBefore) {
+  const contenders = new Map();
+  for (const entry of rankedByBefore) {
+    for (const candidate of entry.ranked) {
+      const key = candidate.after.anchor.key;
+      if (!key) continue;
+      contenders.set(key, [...(contenders.get(key) ?? []), candidate]);
+    }
+  }
+  return contenders;
+}
+
+function ambiguousTargetContention(before, candidate, contendersByAfter, options) {
+  return (contendersByAfter.get(candidate.after.anchor.key) ?? []).filter((contender) => (
+    contender.before.anchor.key !== before.anchor.key
+    && candidate.score.confidence - contender.score.confidence < options.ambiguityMargin
+  ));
+}
+
+function splitLineageCandidates(before, ranked, contendersByAfter, options) {
+  const best = ranked[0];
+  if (!best) return [];
+  const close = ranked.filter((candidate) => best.score.confidence - candidate.score.confidence < options.ambiguityMargin);
+  if (close.length < 2 || close.length > 4) return [];
+  if (!close.every((candidate) => hasStrongLineageEvidence(candidate.score))) return [];
+  if (!close.every((candidate) => splitNameEvidence(before, candidate.after))) return [];
+  if (close.some((candidate) => ambiguousTargetContention(before, candidate, contendersByAfter, options).length > 0)) return [];
+  return close;
+}
+
+function hasStrongLineageEvidence(score) {
+  return score.reasons.includes('signature-hash-match') || score.reasons.includes('body-hash-match');
+}
+
+function splitNameEvidence(before, after) {
+  const beforeName = normalizedName(before.name);
+  const afterName = normalizedName(after.name);
+  return Boolean(beforeName && afterName && beforeName !== afterName && afterName.includes(beforeName));
+}
+
+function deleteRecreateCandidate(before, after, reasons) {
+  return before.anchor.key !== after.anchor.key
+    && sameSymbolSurface(before, after)
+    && (reasons.includes('signature-hash-match') || reasons.includes('body-hash-match'));
+}
+
+function sameSymbolSurface(before, after) {
+  return Boolean(
+    before.name
+    && before.name === after.name
+    && before.kind
+    && before.kind === after.kind
+    && before.anchor.sourcePath
+    && before.anchor.sourcePath === after.anchor.sourcePath
+  );
 }
 
 function anchorsSameLocation(before, after) {
@@ -162,6 +303,10 @@ function sourceSpanRangeSame(before, after) {
     && before.endColumn === after.endColumn;
 }
 
+function normalizedName(value) {
+  return String(value ?? '').replace(/[^A-Za-z0-9_$]+/g, '').toLowerCase();
+}
+
 function firstString(...values) {
   return values.map((value) => value === undefined || value === null ? '' : String(value)).find(Boolean);
 }

package/dist/internal/index-impl/semanticLineageResolutionRecords.js

@@ -36,7 +36,12 @@ export function resolveSemanticLineage(eventsOrMap = [], query = {}, options = {
     state.status = 'max-depth';
     state.reasonCodes.push('max-depth');
   }
-  if (!state.cycle && !state.maxDepthHit) state.status = classifyResolutionStatus(state);
+  if (!state.cycle && !state.maxDepthHit) {
+    state.status = classifyResolutionStatus(state);
+    if (state.status === 'ambiguous' && state.terminal.length > 0 && state.current.length > 0) {
+      state.reasonCodes.push('inactive-anchor-has-active-candidates');
+    }
+  }
   return buildResolutionRecord(state, start, maxDepth, resolutionQuery, options);
 }
 
@@ -49,6 +54,7 @@ function createResolutionState(start) {
     current: start ? [start] : [],
     traversed: [],
     terminal: [],
+    sourcePaths: strings(start?.sourcePath),
     conflictKeys: [],
     evidenceIds: [],
     proofIds: [],
@@ -64,14 +70,16 @@ function createResolutionState(start) {
 }
 
 function buildResolutionRecord(state, start, maxDepth, query, options) {
+  const currentAnchors = uniqueAnchors(state.current).map((anchor) => anchorWithLineageLinks(anchor, state, start, query));
   const core = {
     kind: 'frontier.lang.semanticLineageResolution',
     version: 1,
     query: compactRecord({ anchorKey: start?.key, anchorId: start?.id, sourcePath: start?.sourcePath, symbolName: start?.symbolName, maxDepth }),
     startAnchor: start,
-    currentAnchors: uniqueAnchors(state.current),
+    currentAnchors,
     traversedEventIds: uniqueStrings(state.traversed),
     terminalEventIds: uniqueStrings(state.terminal),
+    sourcePaths: lineageSourcePaths(state, start, query, currentAnchors),
     status: state.status,
     confidence: clampConfidence(state.confidence),
     conflictKeys: uniqueStrings(state.conflictKeys),
@@ -102,6 +110,8 @@ function applyLineageEvent(state, event, visitedEvents) {
   state.operationIds.push(event.crdt?.operationId);
   state.heads.push(...(event.crdt?.heads ?? []));
   state.eventKinds.push(event.eventKind);
+  state.reasonCodes.push(...lineageEventReasonCodes(event));
+  state.sourcePaths.push(event.from?.sourcePath, ...event.to.map((anchor) => anchor.sourcePath));
   if (event.confidence !== undefined) state.confidence = state.confidence === undefined ? event.confidence : Math.min(state.confidence, event.confidence);
   const matched = state.current.filter((anchor) => anchorsMatch(anchor, event.from));
   const unmatched = state.current.filter((anchor) => !anchorsMatch(anchor, event.from));
@@ -138,6 +148,7 @@ function nextLineageEvents(anchors, byFromKey, byFromId) {
 
 function classifyResolutionStatus(state) {
   if (state.current.length === 0 && state.traversed.length > 0) return 'deleted';
+  if (state.terminal.length > 0 && state.current.length > 0) return 'ambiguous';
   if (state.eventKinds.includes('recreated')) return 'recreated';
   if (state.current.length > 1 || state.eventKinds.includes('split') || state.eventKinds.includes('merged')) return 'ambiguous';
   if (state.traversed.length > 0) return 'resolved';
@@ -178,6 +189,39 @@ function uniqueEvents(events) {
     return true;
   });
 }
+function anchorWithLineageLinks(anchor, state, start, query) {
+  return compactRecord({
+    ...anchor,
+    lineageEventIds: uniqueStrings(state.traversed),
+    terminalLineageEventIds: uniqueStrings(state.terminal),
+    lineageSourcePaths: lineageSourcePaths(state, start, query, [anchor]),
+    evidenceIds: uniqueStrings(state.evidenceIds),
+    proofIds: uniqueStrings(state.proofIds),
+    crdtOperationIds: uniqueStrings(state.operationIds),
+    crdtHeads: uniqueStrings(state.heads),
+    lineageEventKinds: uniqueStrings(state.eventKinds),
+    lineageReasonCodes: uniqueStrings(state.reasonCodes)
+  });
+}
+function lineageSourcePaths(state, start, query, anchors = []) {
+  return uniqueStrings([
+    query?.sourcePath,
+    start?.sourcePath,
+    ...state.sourcePaths,
+    ...array(anchors).map((anchor) => anchor?.sourcePath),
+    ...array(anchors).flatMap((anchor) => anchor?.lineageSourcePaths ?? [])
+  ]);
+}
+function lineageEventReasonCodes(event) {
+  return uniqueStrings([
+    ...array(event.reasonCodes),
+    ...array(event.metadata?.reasonCodes),
+    event.evidence?.signatureHashMatch ? 'signature-hash-match' : undefined,
+    event.evidence?.bodyHashMatch ? 'body-hash-match' : undefined,
+    event.evidence?.pathMatch ? 'source-path-match' : undefined,
+    event.evidence?.sourceSpanMoved ? 'source-span-moved' : undefined
+  ]);
+}
 function positiveInteger(value, fallback) {
   const number = Number(value);
   return Number.isFinite(number) && number > 0 ? Math.floor(number) : fallback;

package/dist/internal/index-impl/semanticMergeCandidateRecords.js

@@ -1,6 +1,7 @@
 import{idFragment,normalizeSemanticMergeReadiness,uniqueStrings}from'../../native-import-utils.js';
 import{semanticMergeConflictRiskScore}from'./semanticMergeConflicts.js';
 import{inferProjectionRisk,internalOverlaps,normalizeChangedSemanticRegions,normalizeProjectionRisk,projectionRiskRank,queryAdmissionOverlaps,summarizeOverlaps}from'./semanticMergeCandidateRecordInternals.js';
+import{semanticMergeCandidateScoreFacets}from'./semanticMergeCandidateScoreFacets.js';
 
 export const SemanticMergeCandidateProjectionRisks=Object.freeze(['low','medium','high','unknown']);
 
@@ -74,6 +75,21 @@ export function createSemanticMergeCandidateAdmissionRecord(input={},options={})
   const projectionRisk=normalizeProjectionRisk(options.projectionRisk??candidate.projectionRisk??candidate.risk)
     ??inferProjectionRisk({readiness,candidate,patch,changedSemanticRegions,conflictKeys});
   const overlaps=internalOverlaps(changedSemanticRegions);
+  const conflictRiskScore=semanticMergeConflictRiskScore(candidate);
+  const scoreFacets=semanticMergeCandidateScoreFacets({
+    source,
+    candidate,
+    patch,
+    readiness,
+    projectionRisk,
+    evidenceRecords,
+    evidenceIds,
+    proofIds,
+    changedSemanticRegions,
+    conflictKeys,
+    overlaps,
+    conflictRiskScore
+  });
   const readinessSortKey=semanticMergeCandidateReadinessSortKey({
     readiness,
     projectionRisk,
@@ -106,11 +122,13 @@ export function createSemanticMergeCandidateAdmissionRecord(input={},options={})
     evidenceIds,
     proofIds,
     overlapSummary:summarizeOverlaps(overlaps),
+    scoreFacets,
     admission:{
       readiness,
       reviewRequired:readiness!=='ready'||projectionRisk!=='low'||overlaps.length>0,
       action:admissionAction({readiness,projectionRisk,overlaps}),
       sortKey:readinessSortKey,
+      scoreFacets,
       reasonCodes:uniqueStrings([
         ...strings(options.reasonCodes),
         ...strings(source.reasons),
@@ -145,11 +163,12 @@ export function createSemanticMergeCandidateAdmissionRecord(input={},options={})
       overlaps:overlaps.length,
       readiness,
       projectionRisk,
-      reviewRequired:readiness!=='ready'||projectionRisk!=='low'||overlaps.length>0
+      reviewRequired:readiness!=='ready'||projectionRisk!=='low'||overlaps.length>0,
+      scoreFacets:scoreFacets.summary
     },
     metadata:compactRecord({
       sourceChangeSetId:source.kind==='frontier.lang.nativeSourceChangeSet'?source.id:undefined,
-      conflictRiskScore:semanticMergeConflictRiskScore(candidate),
+      conflictRiskScore,
       conflictSummary:candidate.conflictSummary??candidate.metadata?.conflictSummary??source.metadata?.semanticMergeConflictSummary,
       changedRegionProjectionSummary:source.metadata?.changedRegionProjectionSummary??candidate.metadata?.changedRegionProjectionSummary,
       compact:true,
@@ -170,6 +189,7 @@ export function decorateSemanticMergeCandidateForAdmission(input={},options={}){
     proofIds:admissionRecord.proofIds,
     projectionRisk:admissionRecord.projectionRisk,
     readinessSortKey:admissionRecord.readinessSortKey,
+    scoreFacets:admissionRecord.scoreFacets,
     mergeAdmission:admissionRecord
   };
 }

package/dist/internal/index-impl/semanticMergeCandidateScoreFacets.js

@@ -0,0 +1,221 @@
+import { uniqueStrings } from '../../native-import-utils.js';
+
+const scoreFacetWeights = Object.freeze({ ownership: 18, staleStatus: 20, testEvidence: 18, overlap: 18, size: 10, semanticSidecarQuality: 16 });
+
+export function semanticMergeCandidateScoreFacets(input) {
+  const components = {
+    ownership: ownershipFacet(input),
+    staleStatus: staleStatusFacet(input),
+    testEvidence: testEvidenceFacet(input),
+    overlap: overlapFacet(input),
+    size: sizeFacet(input),
+    semanticSidecarQuality: semanticSidecarQualityFacet(input)
+  };
+  const weightedTotal = Object.values(components).reduce((sum, component) => sum + component.weightedScore, 0);
+  const weightTotal = Object.values(components).reduce((sum, component) => sum + component.weight, 0);
+  const value = roundScore(weightTotal ? weightedTotal * 100 / weightTotal : 0);
+  const weakFacets = Object.values(components).filter((component) => component.status === 'weak').map((component) => component.key);
+  const blockedFacets = Object.values(components).filter((component) => component.status === 'blocked').map((component) => component.key);
+  const lowestScore = Math.min(...Object.values(components).map((component) => component.score));
+  return {
+    schema: 'frontier.lang.semanticMergeCandidateScoreFacets.v1',
+    version: 1,
+    higherIsBetter: true,
+    value,
+    risk: value < 50 || blockedFacets.length ? 'high' : value < 80 || weakFacets.length ? 'medium' : 'low',
+    components,
+    summary: {
+      value,
+      risk: value < 50 || blockedFacets.length ? 'high' : value < 80 || weakFacets.length ? 'medium' : 'low',
+      lowestScore,
+      weakFacets,
+      blockedFacets,
+      availableFacets: Object.values(components).filter((component) => component.signals.available !== false).map((component) => component.key)
+    }
+  };
+}
+
+function ownershipFacet(input) {
+  const regions = input.changedSemanticRegions;
+  const keyedRegions = regions.filter((region) => region.key || region.conflictKey);
+  const kindedRegions = regions.filter((region) => region.regionKind);
+  const spannedRegions = regions.filter((region) => region.sourceSpan);
+  const score = regions.length
+    ? roundScore(keyedRegions.length * 70 / regions.length + kindedRegions.length * 15 / regions.length + spannedRegions.length * 15 / regions.length)
+    : input.conflictKeys.length ? 45 : 70;
+  return scoreFacet('ownership', score, [
+    ...(regions.length === 0 ? ['missing-changed-semantic-regions'] : []),
+    ...(regions.length && keyedRegions.length < regions.length ? ['missing-ownership-keys'] : [])
+  ], {
+    changedSemanticRegions: regions.length,
+    keyedRegions: keyedRegions.length,
+    regionKinds: uniqueStrings(regions.map((region) => region.regionKind)),
+    conflictKeys: input.conflictKeys,
+    ownershipKeys: uniqueStrings(regions.map((region) => region.key))
+  });
+}
+
+function staleStatusFacet(input) {
+  const staleEvidence = input.evidenceRecords.filter((record) => evidenceStatus(record) === 'stale' || record?.metadata?.stale === true);
+  const sourceHashVerified = [
+    input.source?.metadata?.sourceHashVerified,
+    input.source?.before?.metadata?.sourceHashVerified,
+    input.source?.after?.metadata?.sourceHashVerified,
+    input.candidate?.metadata?.sourceHashVerified,
+    input.patch?.metadata?.sourceHashVerified
+  ].filter((value) => value !== undefined);
+  const staleProofs = semanticSidecarQuality(input)?.proofSummary?.stale ?? 0;
+  const sourceHashStale = sourceHashVerified.includes(false);
+  const score = sourceHashStale ? 0 : staleEvidence.length ? 35 : staleProofs > 0 ? 55 : 100;
+  return scoreFacet('staleStatus', score, [
+    ...(sourceHashStale ? ['stale-source-hash'] : []),
+    ...(staleEvidence.length ? ['stale-evidence'] : []),
+    ...(staleProofs > 0 ? ['stale-sidecar-proof-obligations'] : [])
+  ], {
+    staleEvidenceIds: staleEvidence.map((record) => record.id).filter(Boolean),
+    staleProofObligations: staleProofs,
+    sourceHashVerified
+  });
+}
+
+function testEvidenceFacet(input) {
+  const failed = input.evidenceRecords.filter((record) => evidenceStatus(record) === 'failed');
+  const stale = input.evidenceRecords.filter((record) => evidenceStatus(record) === 'stale');
+  const pending = input.evidenceRecords.filter((record) => ['pending', 'assumed', 'unknown'].includes(evidenceStatus(record)));
+  const passed = input.evidenceRecords.filter((record) => ['passed', 'ok', 'success'].includes(evidenceStatus(record)));
+  const score = failed.length ? 0 : stale.length ? 45 : pending.length ? 65 : input.proofIds.length ? 100 : input.evidenceIds.length ? 82 : 35;
+  return scoreFacet('testEvidence', score, [
+    ...(failed.length ? ['failed-evidence'] : []),
+    ...(stale.length ? ['stale-evidence'] : []),
+    ...(pending.length ? ['pending-evidence'] : []),
+    ...(!input.evidenceIds.length && !input.proofIds.length ? ['missing-evidence'] : [])
+  ], {
+    evidenceIds: input.evidenceIds,
+    proofIds: input.proofIds,
+    evidenceRecords: input.evidenceRecords.length,
+    passedEvidenceIds: passed.map((record) => record.id).filter(Boolean),
+    failedEvidenceIds: failed.map((record) => record.id).filter(Boolean),
+    staleEvidenceIds: stale.map((record) => record.id).filter(Boolean),
+    pendingEvidenceIds: pending.map((record) => record.id).filter(Boolean)
+  });
+}
+
+function overlapFacet(input) {
+  const high = input.overlaps.filter((overlap) => overlap.risk === 'high').length;
+  const medium = input.overlaps.filter((overlap) => overlap.risk === 'medium').length;
+  const score = clampScore(100 - high * 45 - medium * 25 - Math.max(0, input.overlaps.length - high - medium) * 15);
+  return scoreFacet('overlap', score, [
+    ...(input.overlaps.length ? ['overlapping-semantic-regions'] : [])
+  ], {
+    overlaps: input.overlaps.length,
+    highRiskOverlaps: high,
+    mediumRiskOverlaps: medium,
+    conflictKeys: uniqueStrings(input.overlaps.flatMap((overlap) => overlap.conflictKeys ?? [])),
+    byKind: countBy(input.overlaps.map((overlap) => overlap.overlapKind))
+  });
+}
+
+function sizeFacet(input) {
+  const operationCount = array(input.candidate?.operations ?? input.patch?.operations).length;
+  const changedSemanticRegions = input.changedSemanticRegions.length;
+  const conflictKeys = input.conflictKeys.length;
+  const score = clampScore(100 - Math.max(0, changedSemanticRegions - 3) * 8 - Math.max(0, operationCount - 3) * 4 - Math.max(0, conflictKeys - 4) * 3);
+  return scoreFacet('size', score, [
+    ...(changedSemanticRegions > 3 ? ['large-changed-region-set'] : []),
+    ...(operationCount > 3 ? ['large-operation-set'] : []),
+    ...(conflictKeys > 4 ? ['many-conflict-keys'] : [])
+  ], { changedSemanticRegions, operationCount, conflictKeys });
+}
+
+function semanticSidecarQualityFacet(input) {
+  const quality = semanticSidecarQuality(input);
+  if (!quality) return scoreFacet('semanticSidecarQuality', 100, [], { available: false });
+  const proofSummary = quality.proofSummary ?? {};
+  const warningCodes = uniqueStrings([...(quality.warnings ?? []).map((warning) => warning.code), ...strings(quality.expectedMissingReasonCodes)]);
+  const reviewProofs = (proofSummary.open ?? 0) + (proofSummary.stale ?? 0) + (proofSummary.assumed ?? 0) + (proofSummary.externalToolRequired ?? 0) + (proofSummary.unknown ?? 0);
+  const score = clampScore(
+    (quality.imported === false || quality.selected === false ? 25 : 100)
+    - (quality.eligible === false ? 35 : 0)
+    - Math.min(35, (quality.warningCount ?? warningCodes.length ?? 0) * 7)
+    - Math.min(40, (proofSummary.failed ?? 0) * 20)
+    - Math.min(25, reviewProofs * 5)
+  );
+  return scoreFacet('semanticSidecarQuality', score, [
+    ...(quality.imported === false || quality.selected === false ? ['semantic-sidecar-not-imported'] : []),
+    ...(quality.eligible === false ? ['semantic-sidecar-not-eligible'] : []),
+    ...warningCodes
+  ], {
+    available: true,
+    expected: quality.expected,
+    expectedSatisfied: quality.expectedSatisfied,
+    selected: quality.selected,
+    imported: quality.imported,
+    eligible: quality.eligible,
+    importCount: quality.importCount,
+    symbolCount: quality.symbolCount,
+    ownershipRegionCount: quality.ownershipRegionCount,
+    patchHintCount: quality.patchHintCount,
+    evidenceCount: quality.evidenceCount,
+    warningCount: quality.warningCount ?? warningCodes.length,
+    warningCodes,
+    proofSummary
+  });
+}
+
+function semanticSidecarQuality(input) {
+  return [
+    input.candidate?.semanticSidecarQuality,
+    input.candidate?.sidecarQuality,
+    input.candidate?.semanticSidecar?.quality,
+    input.candidate?.sidecar?.quality,
+    input.candidate?.metadata?.semanticSidecarQuality,
+    input.candidate?.metadata?.sidecarQuality,
+    input.source?.semanticSidecarQuality,
+    input.source?.sidecarQuality,
+    input.source?.semanticSidecar?.quality,
+    input.source?.sidecar?.quality,
+    input.source?.metadata?.semanticSidecarQuality,
+    input.source?.metadata?.sidecarQuality,
+    input.patch?.semanticSidecarQuality,
+    input.patch?.metadata?.semanticSidecarQuality
+  ].find(looksLikeSemanticSidecarQuality);
+}
+
+function looksLikeSemanticSidecarQuality(value) {
+  return value && typeof value === 'object' && (
+    value.schema === 'frontier.lang.semanticSidecarQuality.v1'
+    || value.eligible !== undefined
+    || value.imported !== undefined
+    || value.proofSummary !== undefined
+    || value.warningCount !== undefined
+  );
+}
+
+function scoreFacet(key, score, reasonCodes, signals) {
+  const normalizedScore = clampScore(score);
+  const weight = scoreFacetWeights[key] ?? 1;
+  return {
+    key,
+    score: normalizedScore,
+    weight,
+    weightedScore: roundScore(normalizedScore * weight / 100),
+    status: facetStatus(normalizedScore),
+    reasonCodes: uniqueStrings(reasonCodes),
+    signals: compactRecord(signals)
+  };
+}
+
+function facetStatus(score) {
+  if (score <= 0) return 'blocked';
+  if (score < 50) return 'weak';
+  if (score < 80) return 'partial';
+  return 'strong';
+}
+
+function evidenceStatus(record) { return String(record?.status ?? record?.metadata?.status ?? '').toLowerCase(); }
+function countBy(values) { const counts = {}; for (const value of values ?? []) { const key = String(value ?? 'unknown'); counts[key] = (counts[key] ?? 0) + 1; } return counts; }
+function clampScore(value) { return Math.max(0, Math.min(100, roundScore(value))); }
+function roundScore(value) { return Math.round((Number.isFinite(value) ? value : 0) * 100) / 100; }
+function array(value) { if (value === undefined || value === null) return []; return Array.isArray(value) ? value : [value]; }
+function strings(value) { return array(value).map((entry) => String(entry ?? '')).filter(Boolean); }
+function compactRecord(value) { return Object.fromEntries(Object.entries(value ?? {}).filter(([, entry]) => entry !== undefined && (!Array.isArray(entry) || entry.length > 0))); }