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

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

@@ -22,7 +22,11 @@ export function resolveSemanticHistoryRecordLineage(record = {}, eventsOrMap = [
     semanticAnchorKeys: resolveIndexKeys(sourceIndex.semanticAnchorKeys, byAnchorKey, options),
     sourcePaths: uniqueStrings([
       ...array(sourceIndex.sourcePaths),
-      ...resolutions.flatMap((resolution) => resolution.currentAnchors.map((anchor) => anchor.sourcePath))
+      ...resolutions.flatMap((resolution) => resolutionSourcePaths(resolution))
+    ]),
+    lineageResolutionIds: uniqueStrings([
+      ...array(sourceIndex.lineageResolutionIds),
+      ...resolutions.map((resolution) => resolution.id)
     ]),
     lineageEventIds: uniqueStrings([
       ...array(sourceIndex.lineageEventIds),
@@ -105,6 +109,13 @@ function createResolvedHistoryRecord(record, index, resolution) {
           inactiveAnchorKeys: resolution.summary.inactiveAnchorKeys,
           blockedAnchorKeys: resolution.summary.blockedAnchorKeys
         },
+        lineageResolutionIds: resolution.summary.lineageResolutionIds,
+        lineageEventIds: resolution.summary.traversedEventIds,
+        terminalEventIds: resolution.summary.terminalEventIds,
+        sourcePaths: resolution.summary.sourcePaths,
+        evidenceIds: resolution.summary.evidenceIds,
+        proofIds: resolution.summary.proofIds,
+        reasonCodes: resolution.summary.reasonCodes,
         autoMergeClaim: false,
         semanticEquivalenceClaim: false
       }
@@ -159,8 +170,11 @@ function summarizeSemanticHistoryLineageResolutions(resolutions, index, anchorIn
     deletedAnchorKeys: uniqueStrings(anchorInventory.deleted.map((anchor) => anchor.key)),
     unresolvedAnchorKeys: uniqueStrings(anchorInventory.unresolved.map((anchor) => anchor.key)),
     blockedAnchorKeys: uniqueStrings(anchorInventory.blocked.map((anchor) => anchor.key)),
+    lineageResolutionIds: uniqueStrings(resolutions.map((resolution) => resolution.id)),
     traversedEventIds: uniqueStrings(resolutions.flatMap((resolution) => resolution.traversedEventIds)),
     terminalEventIds: uniqueStrings(resolutions.flatMap((resolution) => resolution.terminalEventIds)),
+    evidenceIds: uniqueStrings(resolutions.flatMap((resolution) => resolution.evidenceIds)),
+    proofIds: uniqueStrings(resolutions.flatMap((resolution) => resolution.proofIds)),
     reasonCodes: uniqueStrings(resolutions.flatMap((resolution) => resolution.reasonCodes))
   };
 }
@@ -225,8 +239,17 @@ function anchorEntry(anchor, resolution) {
     sourcePath: anchor.sourcePath,
     symbolId: anchor.symbolId,
     symbolName: anchor.symbolName,
+    sourcePaths: resolutionSourcePaths(resolution, anchor),
+    lineageEventIds: uniqueStrings(resolution.traversedEventIds),
+    terminalEventIds: uniqueStrings(resolution.terminalEventIds),
+    evidenceIds: uniqueStrings(resolution.evidenceIds),
+    proofIds: uniqueStrings(resolution.proofIds),
+    crdtOperationIds: uniqueStrings(resolution.crdtOperationIds),
+    crdtHeads: uniqueStrings(resolution.crdtHeads),
+    lineageEventKinds: uniqueStrings(resolution.lineageEventKinds),
     status: resolution.status,
     resolutionId: resolution.id,
+    confidence: resolution.confidence,
     reasonCodes: uniqueStrings(resolution.reasonCodes)
   });
 }
@@ -250,6 +273,17 @@ function uniqueAnchorEntries(entries) {
   });
 }
 
+function resolutionSourcePaths(resolution, anchor) {
+  return uniqueStrings([
+    anchor?.sourcePath,
+    ...array(anchor?.lineageSourcePaths),
+    resolution.query?.sourcePath,
+    resolution.startAnchor?.sourcePath,
+    ...array(resolution.sourcePaths),
+    ...resolution.currentAnchors.flatMap((entry) => [entry.sourcePath, ...array(entry.lineageSourcePaths)])
+  ]);
+}
+
 function array(value) { return value === undefined || value === null ? [] : Array.isArray(value) ? value : [value]; }
 function uniqueStrings(values) { return uniqueRawStrings(array(values).map((value) => String(value ?? '')).filter(Boolean)); }
 function firstString(...values) { return values.map((value) => value === undefined || value === null ? '' : String(value)).find(Boolean); }

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

@@ -1,4 +1,4 @@
-import{idFragment}from'../../native-import-utils.js';import{semanticOwnershipRegionForDeclaration}from'../../semantic-import-regions.js';import{createSemanticIndexRecord,hashSemanticValue}from'@shapeshift-labs/frontier-lang-kernel';
+import{idFragment,caseSensitiveIdFragment}from'../../native-import-utils.js';import{semanticOwnershipRegionForDeclaration}from'../../semantic-import-regions.js';import{createSemanticIndexRecord,hashSemanticValue}from'@shapeshift-labs/frontier-lang-kernel';
 import{relationPredicateForDeclaration}from'./relationPredicateForDeclaration.js';
 export function semanticIndexFromNativeDeclarations(declarations, input, options) {
   const documentId = `doc_${idFragment(input.sourcePath ?? input.language)}_${idFragment(input.sourceHash)}`;
@@ -9,7 +9,7 @@ export function semanticIndexFromNativeDeclarations(declarations, input, options
   const facts = [];
   const mappings = [];
   for (const declaration of declarations) {
-    const symbolId = declaration.symbolId ?? `symbol:${input.language}:${declaration.role === 'import' ? 'import:' : ''}${idFragment(declaration.name)}`;
+    const symbolId = declaration.symbolId ?? `symbol:${input.language}:${declaration.role === 'import' ? 'import:' : ''}${caseSensitiveIdFragment(declaration.name)}`;
     const occurrenceId = `occ_${idFragment(declaration.nativeNode.id)}_${declaration.role ?? 'definition'}`;
     const ownershipRegion = semanticOwnershipRegionForDeclaration(input, {
       ...declaration,

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

@@ -8,8 +8,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 +31,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 +71,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,
@@ -71,7 +95,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 +103,7 @@ function ambiguousMatch(before, ranked) {
       confidence: candidate.score.confidence,
       reasons: candidate.score.reasons
     })),
-    reasonCodes: ['ambiguous-lineage-candidates']
+    reasonCodes: uniqueStrings(reasonCodes)
   };
 }
 
@@ -94,7 +118,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,
@@ -121,6 +146,53 @@ function inferredEvent(before, after, score, input) {
       reasonCodes: 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,
+      split: true,
+      targetCount: targets.length,
+      candidateConfidences: candidates.map((candidate) => candidate.score.confidence),
       autoMergeClaim: false,
       semanticEquivalenceClaim: false
     }
@@ -134,6 +206,7 @@ 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');
@@ -145,7 +218,67 @@ function scoreLineagePair(before, after) {
   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 +295,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

@@ -49,6 +49,7 @@ function createResolutionState(start) {
     current: start ? [start] : [],
     traversed: [],
     terminal: [],
+    sourcePaths: strings(start?.sourcePath),
     conflictKeys: [],
     evidenceIds: [],
     proofIds: [],
@@ -64,14 +65,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 +105,7 @@ function applyLineageEvent(state, event, visitedEvents) {
   state.operationIds.push(event.crdt?.operationId);
   state.heads.push(...(event.crdt?.heads ?? []));
   state.eventKinds.push(event.eventKind);
+  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));
@@ -178,6 +182,29 @@ 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 positiveInteger(value, fallback) {
   const number = Number(value);
   return Number.isFinite(number) && number > 0 ? Math.floor(number) : fallback;

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

@@ -3,32 +3,42 @@ import { normalizeSemanticMergeReadiness, uniqueStrings } from '../../native-imp
 export function createSemanticPatchBundleAdmission(input = {}, context = {}) {
   const transformAdmission = semanticTransformAdmission(context);
   const semanticEditAdmission = context.semanticEditAdmission ?? { status: 'none', action: 'none', readiness: 'needs-review', reasonCodes: [] };
-  const fallbackReadiness = fallbackAdmissionReadiness(transformAdmission, semanticEditAdmission, context.readiness);
-  const readiness = normalizeSemanticMergeReadiness(input.readiness ?? fallbackReadiness) ?? input.readiness ?? fallbackReadiness;
-  const status = input.status ?? admissionStatusForReadiness(readiness, transformAdmission, semanticEditAdmission);
-  const autoApplyCandidate = input.autoApplyCandidate ?? (status === 'admitted' && [
-    transformAdmission.action,
-    semanticEditAdmission.action
-  ].includes('admit'));
+  const evidenceAdmission = autoMergeEvidenceAdmission(context, { transformAdmission, semanticEditAdmission });
+  const fallbackReadiness = fallbackAdmissionReadiness(transformAdmission, semanticEditAdmission, evidenceAdmission, context.readiness);
+  const inputReadiness = normalizeSemanticMergeReadiness(input.readiness ?? fallbackReadiness) ?? input.readiness ?? fallbackReadiness;
+  const readiness = hasPositiveApplyAction(transformAdmission, semanticEditAdmission) && evidenceAdmission.action !== 'admit'
+    ? evidenceAdmission.readiness
+    : inputReadiness;
+  const computedStatus = admissionStatusForReadiness(readiness, transformAdmission, semanticEditAdmission, evidenceAdmission);
+  const status = input.status === 'admitted' && computedStatus !== 'admitted' ? computedStatus : input.status ?? computedStatus;
+  const computedAutoApplyCandidate = status === 'admitted' &&
+    hasPositiveApplyAction(transformAdmission, semanticEditAdmission) &&
+    evidenceAdmission.action === 'admit';
+  const autoApplyCandidate = input.autoApplyCandidate === true ? computedAutoApplyCandidate : input.autoApplyCandidate ?? computedAutoApplyCandidate;
+  const admittedWithoutPositiveProof = status === 'admitted' &&
+    hasPositiveApplyAction(transformAdmission, semanticEditAdmission) &&
+    evidenceAdmission.action !== 'admit';
   return compactRecord({
     status,
     readiness,
-    reviewRequired: input.reviewRequired ?? status !== 'admitted',
+    reviewRequired: input.reviewRequired ?? (status !== 'admitted' || admittedWithoutPositiveProof),
     autoMergeClaim: false,
     autoApplyCandidate,
     transformAdmission,
     semanticEditAdmission,
+    evidenceAdmission,
     reasonCodes: uniqueStrings([
       ...strings(input.reasonCodes),
       ...strings(context.source?.reasons),
       ...strings(context.mergeCandidate?.reasons),
       ...transformAdmission.reasonCodes,
-      ...strings(semanticEditAdmission.reasonCodes)
-    ]),
+      ...strings(semanticEditAdmission.reasonCodes),
+      ...strings(evidenceAdmission.reasonCodes)
+    ].filter(Boolean)),
     conflictKeys: uniqueStrings([...strings(input.conflictKeys), ...context.conflictKeys]),
     admittedAt: input.admittedAt,
     reviewerId: input.reviewerId,
-    evidenceIds: uniqueStrings([...strings(input.evidenceIds), ...strings(transformAdmission.evidenceIds)]),
+    evidenceIds: uniqueStrings([...strings(input.evidenceIds), ...strings(transformAdmission.evidenceIds), ...strings(evidenceAdmission.evidenceIds)]),
     metadata: input.metadata
   });
 }
@@ -74,7 +84,7 @@ function transformReasonCodes(input) {
     !input.complete ? 'transform-evidence-incomplete' : undefined,
     input.ready ? 'transform-auto-apply-candidate' : undefined,
     ...input.readinesses.map((readiness) => `transform-readiness:${readiness}`)
-  ]);
+  ].filter(Boolean));
 }
 
 function transformReadiness(value) {
@@ -87,21 +97,90 @@ function transformReadiness(value) {
   return undefined;
 }
 
-function fallbackAdmissionReadiness(transformAdmission, semanticEditAdmission, fallback) {
-  if ([transformAdmission.readiness, semanticEditAdmission.readiness].includes('blocked')) return 'blocked';
-  if (hasAdmissibleReadyAction(transformAdmission, semanticEditAdmission)) return 'ready';
+function autoMergeEvidenceAdmission(context, admissions) {
+  const evidence = uniqueEvidenceRecords([
+    ...array(context.evidenceRecords),
+    ...array(context.evidence),
+    ...array(context.source?.evidence),
+    ...array(context.source?.patch?.evidence),
+    ...array(context.source?.semanticPatch?.evidence),
+    ...array(context.mergeCandidate?.evidence)
+  ]);
+  const positiveApply = hasPositiveApplyAttempt(admissions.transformAdmission, admissions.semanticEditAdmission);
+  if (!positiveApply) return { status: 'none', action: 'none', readiness: 'needs-review', reasonCodes: [], evidenceIds: evidenceIds(evidence) };
+  const summary = summarizeAutoMergeEvidence(evidence);
+  const blocked = summary.failed > 0 || summary.conflict > 0;
+  const ready = !blocked && summary.stale === 0 && summary.passed > 0;
+  const status = blocked ? 'blocked' : summary.stale > 0 ? 'stale' : ready ? 'ready' : 'needs-review';
+  return compactRecord({
+    status,
+    action: blocked ? 'block' : status === 'stale' ? 'rerun-semantic-import' : ready ? 'admit' : 'review',
+    readiness: blocked ? 'blocked' : ready ? 'ready' : 'needs-review',
+    reasonCodes: autoMergeEvidenceReasonCodes(summary, status),
+    evidenceIds: summary.evidenceIds,
+    passed: summary.passed,
+    failed: summary.failed,
+    conflict: summary.conflict,
+    stale: summary.stale
+  });
+}
+
+function summarizeAutoMergeEvidence(evidence) {
+  const testLike = evidence.filter(isAutoMergeTestEvidence);
+  const failed = testLike.filter((record) => evidenceStatus(record, ['failed', 'failure', 'error', 'blocked', 'rejected']));
+  const passed = testLike.filter((record) => evidenceStatus(record, ['passed', 'ok', 'success', 'succeeded', 'accepted', 'verified']));
+  const conflict = evidence.filter((record) => evidenceStatus(record, ['conflict', 'conflicted']) || record?.metadata?.conflict === true || strings(record?.reasonCodes ?? record?.reasons).some((reason) => reason.toLowerCase().includes('conflict')));
+  const stale = evidence.filter((record) => evidenceStatus(record, ['stale']) || record?.metadata?.stale === true || strings(record?.reasonCodes ?? record?.reasons).some((reason) => reason.toLowerCase().includes('stale')));
+  return {
+    evidenceIds: evidenceIds(evidence),
+    passed: passed.length,
+    failed: failed.length,
+    conflict: conflict.length,
+    stale: stale.length
+  };
+}
+
+function autoMergeEvidenceReasonCodes(summary, status) {
+  return uniqueStrings([
+    summary.passed ? 'auto-merge-tests-passed' : undefined,
+    summary.passed === 0 ? 'auto-merge-tests-passed-evidence-missing' : undefined,
+    summary.failed ? 'auto-merge-tests-failed' : undefined,
+    summary.conflict ? 'auto-merge-conflict-evidence' : undefined,
+    summary.stale ? 'auto-merge-stale-evidence' : undefined,
+    status === 'ready' ? 'auto-merge-positive-proof' : undefined
+  ].filter(Boolean));
+}
+
+function fallbackAdmissionReadiness(transformAdmission, semanticEditAdmission, evidenceAdmission, fallback) {
+  if ([transformAdmission.readiness, semanticEditAdmission.readiness, evidenceAdmission.readiness].includes('blocked')) return 'blocked';
+  if (hasSkipReadyAction(semanticEditAdmission)) return 'ready';
+  if (hasPositiveApplyAction(transformAdmission, semanticEditAdmission)) return evidenceAdmission.action === 'admit' ? 'ready' : evidenceAdmission.readiness;
   return fallback;
 }
 
-function admissionStatusForReadiness(readiness, transformAdmission, semanticEditAdmission) {
+function admissionStatusForReadiness(readiness, transformAdmission, semanticEditAdmission, evidenceAdmission) {
   if (readiness === 'blocked') return 'blocked';
-  if (hasAdmissibleReadyAction(transformAdmission, semanticEditAdmission) && readiness === 'ready') return 'admitted';
+  if (hasAdmissibleReadyAction(transformAdmission, semanticEditAdmission, evidenceAdmission) && readiness === 'ready') return 'admitted';
   return readiness === 'needs-review' ? 'needs-review' : 'proposed';
 }
 
-function hasAdmissibleReadyAction(transformAdmission, semanticEditAdmission) {
-  return [transformAdmission.action, semanticEditAdmission.action].includes('admit') ||
-    (semanticEditAdmission.action === 'skip' && semanticEditAdmission.readiness === 'ready' && semanticEditAdmission.reviewRequired === false);
+function hasAdmissibleReadyAction(transformAdmission, semanticEditAdmission, evidenceAdmission) {
+  return hasSkipReadyAction(semanticEditAdmission) ||
+    (hasPositiveApplyAction(transformAdmission, semanticEditAdmission) && evidenceAdmission.action === 'admit');
+}
+
+function hasPositiveApplyAction(transformAdmission, semanticEditAdmission) {
+  return [transformAdmission.action, semanticEditAdmission.action].includes('admit');
+}
+
+function hasPositiveApplyAttempt(transformAdmission, semanticEditAdmission) {
+  return hasPositiveApplyAction(transformAdmission, semanticEditAdmission) ||
+    Number(semanticEditAdmission.summary?.acceptedClean ?? 0) > 0 ||
+    strings(transformAdmission.reasonCodes).includes('transform-readiness:auto-merge-candidate');
+}
+
+function hasSkipReadyAction(semanticEditAdmission) {
+  return semanticEditAdmission.action === 'skip' && semanticEditAdmission.readiness === 'ready' && semanticEditAdmission.reviewRequired === false;
 }
 
 function hasCrossLanguageTransform(index) {
@@ -109,6 +188,29 @@ function hasCrossLanguageTransform(index) {
   return strings(index.transformTargetLanguages).some((target) => !source.has(target));
 }
 
+function isAutoMergeTestEvidence(record) {
+  const kind = String(record?.kind ?? record?.type ?? '').toLowerCase();
+  return ['test', 'tests', 'proof', 'gate', 'verification', 'check'].includes(kind);
+}
+
+function evidenceStatus(record, statuses) {
+  const status = String(record?.status ?? record?.outcome ?? '').toLowerCase();
+  return statuses.includes(status);
+}
+
+function uniqueEvidenceRecords(records) {
+  const seen = new Set();
+  const result = [];
+  for (const record of records.filter(Boolean)) {
+    const key = record.id ?? JSON.stringify(record);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    result.push(record);
+  }
+  return result;
+}
+
+function evidenceIds(evidence) { return uniqueStrings(evidence.map((record) => record.id)); }
 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))); }