@evomap/evolver-core 2.0.0-beta.8 → 2.0.0

package/dist/schema/evolutionGraph.js

@@ -0,0 +1,187 @@
+import { z } from 'zod';
+import { extensions, sha256Hash } from './common.js';
+export const EVOLUTION_GRAPH_SCHEMA_VERSION = '1.0.0';
+export const evolutionGraphNodeKinds = [
+    'prompt',
+    'code',
+    'spec',
+    'test',
+    'feedback',
+    'run',
+    'metric',
+    'variant',
+    'selection',
+];
+export const evolutionGraphEdgeKinds = [
+    'derivation',
+    'evaluated_by',
+    'regressed',
+    'fixed',
+    'selected',
+];
+export const evolutionGraphProvenanceKinds = [
+    'root_event',
+    'asset',
+    'material',
+    'review',
+    'cycle',
+    'workflow',
+    'runtime_trace',
+    'plugin',
+    'manual',
+];
+export const evolutionGraphNodeKind = z.enum(evolutionGraphNodeKinds);
+export const evolutionGraphEdgeKind = z.enum(evolutionGraphEdgeKinds);
+export const evolutionGraphProvenanceKind = z.enum(evolutionGraphProvenanceKinds);
+export const evolutionGraphNodeRef = z.string().min(1);
+export const evolutionGraphArtifactRef = z.object({
+    kind: z.enum(['asset', 'material', 'root_event', 'file', 'runtime_trace', 'plugin_resource']),
+    ref: z.string().min(1),
+    sha256: sha256Hash.optional(),
+});
+export const evolutionGraphMetricValue = z.object({
+    metric: z.string().min(1),
+    value: z.number(),
+    unit: z.string().min(1).optional(),
+    direction: z.enum(['higher_is_better', 'lower_is_better', 'target']).default('higher_is_better'),
+    target: z.number().optional(),
+});
+export const evolutionGraphMetricDelta = z.object({
+    metric: z.string().min(1),
+    before: z.number().optional(),
+    after: z.number(),
+    delta: z.number().optional(),
+    direction: z.enum(['improved', 'regressed', 'unchanged', 'unknown']).default('unknown'),
+});
+export const evolutionGraphNode = z.object({
+    id: evolutionGraphNodeRef,
+    kind: evolutionGraphNodeKind,
+    label: z.string().min(1),
+    createdAt: z.string().datetime(),
+    artifact: evolutionGraphArtifactRef.optional(),
+    metrics: z.array(evolutionGraphMetricValue).default([]),
+    summary: z.string().optional(),
+    tags: z.array(z.string().min(1)).default([]),
+    extensions,
+});
+export const evolutionGraphProvenance = z.object({
+    kind: evolutionGraphProvenanceKind,
+    ref: z.string().min(1),
+    capturedAt: z.string().datetime(),
+    actor: z.string().min(1).optional(),
+    digest: sha256Hash.optional(),
+    summary: z.string().optional(),
+});
+export const evolutionGraphEdge = z.object({
+    id: z.string().min(1),
+    kind: evolutionGraphEdgeKind,
+    from: evolutionGraphNodeRef,
+    to: evolutionGraphNodeRef,
+    createdAt: z.string().datetime(),
+    provenance: z.array(evolutionGraphProvenance).min(1),
+    metricDelta: evolutionGraphMetricDelta.optional(),
+    reason: z.string().min(1).optional(),
+    confidence: z.number().min(0).max(1).optional(),
+    extensions,
+});
+export const evolutionGraphDashboardSummary = z.object({
+    nodeCount: z.number().int().nonnegative(),
+    edgeCount: z.number().int().nonnegative(),
+    variantCount: z.number().int().nonnegative(),
+    selectedCount: z.number().int().nonnegative(),
+    regressionCount: z.number().int().nonnegative(),
+    fixedCount: z.number().int().nonnegative(),
+    evaluatedVariantCount: z.number().int().nonnegative(),
+    unevaluatedVariantCount: z.number().int().nonnegative(),
+    orphanEdgeCount: z.number().int().nonnegative(),
+    provenanceGapCount: z.number().int().nonnegative(),
+});
+export const evolutionGraph = z.object({
+    schemaVersion: z.literal(EVOLUTION_GRAPH_SCHEMA_VERSION).default(EVOLUTION_GRAPH_SCHEMA_VERSION),
+    graphId: z.string().min(1),
+    generatedAt: z.string().datetime(),
+    nodes: z.array(evolutionGraphNode),
+    edges: z.array(evolutionGraphEdge),
+    dashboard: evolutionGraphDashboardSummary.optional(),
+    extensions,
+}).superRefine((graph, ctx) => {
+    const nodesById = new Map();
+    for (const [index, node] of graph.nodes.entries()) {
+        if (nodesById.has(node.id)) {
+            ctx.addIssue({ code: z.ZodIssueCode.custom, path: ['nodes', index, 'id'], message: 'duplicate evolution graph node id' });
+            continue;
+        }
+        nodesById.set(node.id, node.kind);
+    }
+    const edgeIds = new Set();
+    for (const [index, edge] of graph.edges.entries()) {
+        if (edgeIds.has(edge.id)) {
+            ctx.addIssue({ code: z.ZodIssueCode.custom, path: ['edges', index, 'id'], message: 'duplicate evolution graph edge id' });
+        }
+        else {
+            edgeIds.add(edge.id);
+        }
+        const fromKind = nodesById.get(edge.from);
+        const toKind = nodesById.get(edge.to);
+        if (!fromKind)
+            ctx.addIssue({ code: z.ZodIssueCode.custom, path: ['edges', index, 'from'], message: 'edge source node is missing' });
+        if (!toKind)
+            ctx.addIssue({ code: z.ZodIssueCode.custom, path: ['edges', index, 'to'], message: 'edge target node is missing' });
+        if (!fromKind || !toKind)
+            continue;
+        validateEvolutionGraphEdgeShape(edge, fromKind, toKind, ctx, index);
+    }
+});
+export function deriveEvolutionGraphDashboardSummary(input) {
+    const variantIds = new Set(input.nodes.filter((node) => node.kind === 'variant').map((node) => node.id));
+    const evaluatedVariantIds = new Set();
+    let selectedCount = 0;
+    let regressionCount = 0;
+    let fixedCount = 0;
+    let orphanEdgeCount = 0;
+    let provenanceGapCount = 0;
+    const nodeIds = new Set(input.nodes.map((node) => node.id));
+    for (const edge of input.edges) {
+        if (!nodeIds.has(edge.from) || !nodeIds.has(edge.to))
+            orphanEdgeCount += 1;
+        if (edge.provenance.length === 0)
+            provenanceGapCount += 1;
+        if (edge.kind === 'evaluated_by' && variantIds.has(edge.from))
+            evaluatedVariantIds.add(edge.from);
+        if (edge.kind === 'selected')
+            selectedCount += 1;
+        if (edge.kind === 'regressed')
+            regressionCount += 1;
+        if (edge.kind === 'fixed')
+            fixedCount += 1;
+    }
+    return {
+        nodeCount: input.nodes.length,
+        edgeCount: input.edges.length,
+        variantCount: variantIds.size,
+        selectedCount,
+        regressionCount,
+        fixedCount,
+        evaluatedVariantCount: evaluatedVariantIds.size,
+        unevaluatedVariantCount: Math.max(0, variantIds.size - evaluatedVariantIds.size),
+        orphanEdgeCount,
+        provenanceGapCount,
+    };
+}
+function validateEvolutionGraphEdgeShape(edge, fromKind, toKind, ctx, edgeIndex) {
+    if (edge.kind === 'selected' && (fromKind !== 'variant' || toKind !== 'selection')) {
+        ctx.addIssue({ code: z.ZodIssueCode.custom, path: ['edges', edgeIndex, 'kind'], message: 'selected edges must connect variant -> selection' });
+    }
+    if (edge.kind === 'evaluated_by' && !['run', 'metric', 'test'].includes(toKind)) {
+        ctx.addIssue({ code: z.ZodIssueCode.custom, path: ['edges', edgeIndex, 'to'], message: 'evaluated_by target must be run, metric, or test' });
+    }
+    if ((edge.kind === 'regressed' || edge.kind === 'fixed') && !['run', 'metric', 'test'].includes(toKind)) {
+        ctx.addIssue({ code: z.ZodIssueCode.custom, path: ['edges', edgeIndex, 'to'], message: `${edge.kind} target must be run, metric, or test` });
+    }
+    if ((edge.kind === 'regressed' || edge.kind === 'fixed') && !edge.metricDelta) {
+        ctx.addIssue({ code: z.ZodIssueCode.custom, path: ['edges', edgeIndex, 'metricDelta'], message: `${edge.kind} edges require metricDelta` });
+    }
+    if (edge.kind === 'selected' && !edge.reason) {
+        ctx.addIssue({ code: z.ZodIssueCode.custom, path: ['edges', edgeIndex, 'reason'], message: 'selected edges require a reason' });
+    }
+}

package/dist/schema/index.d.ts

@@ -2,4 +2,5 @@ export * from './common.js';
 export * from './material.js';
 export * from './signal.js';
 export * from './problem.js';
+export * from './evolutionGraph.js';
 export * from './proofOfWork.js';

package/dist/schema/index.js

@@ -2,4 +2,5 @@ export * from './common.js';
 export * from './material.js';
 export * from './signal.js';
 export * from './problem.js';
+export * from './evolutionGraph.js';
 export * from './proofOfWork.js';

package/dist/schema/signal.d.ts

@@ -7,7 +7,7 @@ export declare const problemSignature: z.ZodString;
 export declare const signal: z.ZodObject<{
     signalId: z.ZodString;
     fromMaterial: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
-    kind: z.ZodEnum<["strong_structured", "weak_corpus", "agent_marked"]>;
+    kind: z.ZodEnum<["strong_structured", "weak_corpus", "agent_marked", "verified_success"]>;
     text: z.ZodString;
     score: z.ZodDefault<z.ZodNumber>;
     eventSignature: z.ZodString;
@@ -16,7 +16,7 @@ export declare const signal: z.ZodObject<{
     discoveredAt: z.ZodString;
     extensions: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, "strip", z.ZodTypeAny, {
-    kind: "strong_structured" | "weak_corpus" | "agent_marked";
+    kind: "strong_structured" | "weak_corpus" | "agent_marked" | "verified_success";
     extensions: Record<string, unknown>;
     signalId: string;
     fromMaterial: string[];
@@ -27,7 +27,7 @@ export declare const signal: z.ZodObject<{
     signatureV: number;
     discoveredAt: string;
 }, {
-    kind: "strong_structured" | "weak_corpus" | "agent_marked";
+    kind: "strong_structured" | "weak_corpus" | "agent_marked" | "verified_success";
     signalId: string;
     text: string;
     eventSignature: string;

package/dist/schema/signal.js

@@ -8,7 +8,7 @@ export const problemSignature = z.string();
 export const signal = z.object({
     signalId: ulid,
     fromMaterial: z.array(ulid).default([]),
-    kind: z.enum(['strong_structured', 'weak_corpus', 'agent_marked']),
+    kind: z.enum(['strong_structured', 'weak_corpus', 'agent_marked', 'verified_success']),
     text: z.string(),
     score: z.number().min(0).max(1).default(0),
     eventSignature,

package/dist/signals/curriculum.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Progressive curriculum signals, adapted from V1's curriculum producer.
+ *
+ * V2 keeps the policy pure and derives its history from the append-only root event log. This avoids V1's
+ * separate mutable curriculum_state.json sidecar while preserving the behavior that matters to selection:
+ * classify recent outcomes and add at most one capability-gap target plus one frontier target.
+ */
+export interface CurriculumOutcome {
+    key: string;
+    status: 'success' | 'failed';
+}
+export interface CurriculumBucket {
+    key: string;
+    success: number;
+    failed: number;
+    total: number;
+    rate: number;
+}
+export interface CurriculumClassification {
+    mastered: CurriculumBucket[];
+    failing: CurriculumBucket[];
+    frontier: CurriculumBucket[];
+}
+export interface CurriculumEventLike {
+    type: string;
+    payload?: unknown;
+}
+export interface GenerateCurriculumSignalsInput {
+    outcomes: readonly CurriculumOutcome[];
+    capabilityGaps?: readonly string[];
+}
+export declare const MAX_CAPABILITY_GAPS = 16;
+export declare const CAPABILITY_GAPS_STATE_KEY = "curriculum:capability_gaps";
+/** Normalize untrusted capability names before they cross adapter, persistence, or selection boundaries. */
+export declare function normalizeCapabilityGaps(value: unknown): string[];
+/** Versioned, bounded snapshot stored atomically in the lifecycle mailbox KV table. */
+export declare function serializeCapabilityGapsState(capabilityGaps: unknown, observedAt: number): string;
+/** Parse only the current bounded snapshot format. Unknown versions fail open without influencing selection. */
+export declare function capabilityGapsFromState(value: unknown): string[];
+/** Stable V2 equivalent of V1 computeSignalKey, excluding previously generated curriculum targets. */
+export declare function curriculumSignalKey(signals: readonly string[]): string;
+/** Classify signal-key outcomes using V1's thresholds. */
+export declare function classifyCurriculumOutcomes(outcomes: readonly CurriculumOutcome[]): CurriculumClassification;
+/** Generate no more than the two target families V1 produced: gap first, then closest frontier. */
+export declare function generateCurriculumSignals(input: GenerateCurriculumSignalsInput): string[];
+/**
+ * Map V2's capability signal conventions to concrete curriculum gaps. A bare cap:* tag is not sufficient by
+ * itself: it becomes a curriculum gap only when the same signal set explicitly declares capability_gap.
+ */
+export declare function capabilityGapsFromSignals(signals: readonly string[]): string[];
+/**
+ * Join cycle.signals_collected to terminal cycle events and retain the latest outcome window. `baseSignals`
+ * wins over `signals`, so history-derived meta-signals do not become a self-reinforcing curriculum key.
+ */
+export declare function curriculumOutcomesFromEvents(events: readonly CurriculumEventLike[], maxOutcomes?: number): CurriculumOutcome[];

package/dist/signals/curriculum.js

@@ -0,0 +1,202 @@
+/**
+ * Progressive curriculum signals, adapted from V1's curriculum producer.
+ *
+ * V2 keeps the policy pure and derives its history from the append-only root event log. This avoids V1's
+ * separate mutable curriculum_state.json sidecar while preserving the behavior that matters to selection:
+ * classify recent outcomes and add at most one capability-gap target plus one frontier target.
+ */
+const MASTERY_THRESHOLD = 0.8;
+const MASTERY_MIN_ATTEMPTS = 3;
+const FAILURE_THRESHOLD = 0.3;
+const MIN_CLASSIFICATION_ATTEMPTS = 2;
+const MAX_CURRICULUM_SIGNALS = 2;
+const MAX_TARGET_CHARS = 60;
+const DEFAULT_OUTCOME_WINDOW = 200;
+const CAPABILITY_NAME = /^[A-Za-z][A-Za-z0-9_-]{0,59}$/;
+export const MAX_CAPABILITY_GAPS = 16;
+export const CAPABILITY_GAPS_STATE_KEY = 'curriculum:capability_gaps';
+const CAPABILITY_GAPS_STATE_VERSION = 1;
+function record(value) {
+    return value && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function stringArray(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    return value.filter((entry) => typeof entry === 'string');
+}
+function boundedWindow(value) {
+    if (!Number.isFinite(value))
+        return DEFAULT_OUTCOME_WINDOW;
+    return Math.max(1, Math.min(10_000, Math.floor(value)));
+}
+/** Normalize untrusted capability names before they cross adapter, persistence, or selection boundaries. */
+export function normalizeCapabilityGaps(value) {
+    if (!Array.isArray(value))
+        return [];
+    const gaps = [];
+    for (const entry of value) {
+        if (typeof entry !== 'string')
+            continue;
+        const normalized = entry.trim().toLowerCase();
+        if (!CAPABILITY_NAME.test(normalized) || gaps.includes(normalized))
+            continue;
+        gaps.push(normalized);
+        if (gaps.length >= MAX_CAPABILITY_GAPS)
+            break;
+    }
+    return gaps;
+}
+/** Versioned, bounded snapshot stored atomically in the lifecycle mailbox KV table. */
+export function serializeCapabilityGapsState(capabilityGaps, observedAt) {
+    const safeObservedAt = Number.isFinite(observedAt) && observedAt >= 0 ? Math.floor(observedAt) : 0;
+    return JSON.stringify({
+        version: CAPABILITY_GAPS_STATE_VERSION,
+        capabilityGaps: normalizeCapabilityGaps(capabilityGaps),
+        observedAt: safeObservedAt,
+    });
+}
+/** Parse only the current bounded snapshot format. Unknown versions fail open without influencing selection. */
+export function capabilityGapsFromState(value) {
+    if (typeof value !== 'string' || value.length === 0)
+        return [];
+    try {
+        const parsed = record(JSON.parse(value));
+        if (!parsed || parsed['version'] !== CAPABILITY_GAPS_STATE_VERSION)
+            return [];
+        const observedAt = parsed['observedAt'];
+        if (typeof observedAt !== 'number' || !Number.isFinite(observedAt) || observedAt < 0)
+            return [];
+        return normalizeCapabilityGaps(parsed['capabilityGaps']);
+    }
+    catch {
+        return [];
+    }
+}
+/** Stable V2 equivalent of V1 computeSignalKey, excluding previously generated curriculum targets. */
+export function curriculumSignalKey(signals) {
+    return [...new Set(signals
+            .map((signal) => signal.trim())
+            .filter((signal) => signal.length > 0 && !signal.startsWith('curriculum_target:')))]
+        .sort()
+        .join('|');
+}
+/** Classify signal-key outcomes using V1's thresholds. */
+export function classifyCurriculumOutcomes(outcomes) {
+    const aggregates = new Map();
+    for (const outcome of outcomes) {
+        const key = typeof outcome?.key === 'string' ? outcome.key.trim() : '';
+        if (!key || (outcome.status !== 'success' && outcome.status !== 'failed'))
+            continue;
+        const aggregate = aggregates.get(key) ?? { success: 0, failed: 0 };
+        if (outcome.status === 'success')
+            aggregate.success += 1;
+        else
+            aggregate.failed += 1;
+        aggregates.set(key, aggregate);
+    }
+    const mastered = [];
+    const failing = [];
+    const frontier = [];
+    for (const [key, aggregate] of aggregates) {
+        const total = aggregate.success + aggregate.failed;
+        if (total < MIN_CLASSIFICATION_ATTEMPTS)
+            continue;
+        const rate = aggregate.success / total;
+        const bucket = { key, success: aggregate.success, failed: aggregate.failed, total, rate };
+        if (rate >= MASTERY_THRESHOLD && total >= MASTERY_MIN_ATTEMPTS)
+            mastered.push(bucket);
+        else if (rate <= FAILURE_THRESHOLD)
+            failing.push(bucket);
+        else
+            frontier.push(bucket);
+    }
+    frontier.sort((left, right) => Math.abs(left.rate - 0.5) - Math.abs(right.rate - 0.5));
+    return { mastered, failing, frontier };
+}
+/** Generate no more than the two target families V1 produced: gap first, then closest frontier. */
+export function generateCurriculumSignals(input) {
+    const analysis = classifyCurriculumOutcomes(input.outcomes);
+    const generated = [];
+    const gap = (input.capabilityGaps ?? []).find((entry) => typeof entry === 'string' && entry.trim().length > 0)?.trim();
+    if (gap) {
+        const normalizedGap = gap.toLowerCase();
+        const alreadyMastered = analysis.mastered.some((entry) => entry.key.toLowerCase().includes(normalizedGap));
+        if (!alreadyMastered)
+            generated.push(`curriculum_target:gap:${gap.slice(0, MAX_TARGET_CHARS)}`);
+    }
+    const best = analysis.frontier[0];
+    if (generated.length < MAX_CURRICULUM_SIGNALS && best) {
+        const alreadyTargeted = generated.some((signal) => signal.includes(best.key));
+        if (!alreadyTargeted)
+            generated.push(`curriculum_target:frontier:${best.key.slice(0, MAX_TARGET_CHARS)}`);
+    }
+    return generated.slice(0, MAX_CURRICULUM_SIGNALS);
+}
+/**
+ * Map V2's capability signal conventions to concrete curriculum gaps. A bare cap:* tag is not sufficient by
+ * itself: it becomes a curriculum gap only when the same signal set explicitly declares capability_gap.
+ */
+export function capabilityGapsFromSignals(signals) {
+    const hasGapMarker = signals.some((signal) => signal === 'capability_gap' || signal.startsWith('capability_gap:'));
+    if (!hasGapMarker)
+        return [];
+    const gaps = [];
+    const add = (raw) => {
+        const normalized = raw.trim().toLowerCase();
+        if (!CAPABILITY_NAME.test(normalized) || gaps.includes(normalized))
+            return;
+        gaps.push(normalized);
+    };
+    for (const signal of signals)
+        if (signal.startsWith('cap:'))
+            add(signal.slice('cap:'.length));
+    for (const signal of signals)
+        if (signal.startsWith('capability_gap:'))
+            add(signal.slice('capability_gap:'.length));
+    return normalizeCapabilityGaps(gaps);
+}
+/**
+ * Join cycle.signals_collected to terminal cycle events and retain the latest outcome window. `baseSignals`
+ * wins over `signals`, so history-derived meta-signals do not become a self-reinforcing curriculum key.
+ */
+export function curriculumOutcomesFromEvents(events, maxOutcomes = DEFAULT_OUTCOME_WINDOW) {
+    const limit = boundedWindow(maxOutcomes);
+    const selectedNewestFirst = [];
+    const terminalCycles = new Set();
+    // Pick the latest unique terminal cycles first. EventStore.readAll already owns the input array, while every
+    // auxiliary collection in this adapter remains bounded by the configured outcome window.
+    for (let index = events.length - 1; index >= 0 && selectedNewestFirst.length < limit; index -= 1) {
+        const event = events[index];
+        if (event.type !== 'cycle.solidified' && event.type !== 'cycle.failed')
+            continue;
+        const payload = record(event.payload);
+        if (!payload || typeof payload['cycleId'] !== 'string' || terminalCycles.has(payload['cycleId']))
+            continue;
+        const cycleId = payload['cycleId'];
+        terminalCycles.add(cycleId);
+        selectedNewestFirst.push({
+            cycleId,
+            status: event.type === 'cycle.failed' || payload['producedValue'] === false ? 'failed' : 'success',
+        });
+    }
+    const signalsByCycle = new Map();
+    // Build the signal lookup independently of terminal ordering. Normal logs collect signals first, but a
+    // recovered/imported history can be reordered without making otherwise valid outcomes disappear.
+    for (const event of events) {
+        const payload = record(event.payload);
+        if (!payload)
+            continue;
+        const cycleId = typeof payload['cycleId'] === 'string' ? payload['cycleId'] : undefined;
+        if (!cycleId || !terminalCycles.has(cycleId) || event.type !== 'cycle.signals_collected')
+            continue;
+        const baseSignals = stringArray(payload['baseSignals']);
+        const fallbackSignals = stringArray(payload['signals']);
+        signalsByCycle.set(cycleId, baseSignals ?? fallbackSignals ?? []);
+    }
+    return selectedNewestFirst.reverse().flatMap(({ cycleId, status }) => {
+        const key = curriculumSignalKey(signalsByCycle.get(cycleId) ?? []);
+        return key ? [{ key, status }] : [];
+    });
+}

package/dist/signals/cycleHistoryFromEvents.js

@@ -8,7 +8,8 @@
 //  - intent:     mutation.built.payload.category (the cycle's GepCategory), if emitted
 //  - genesUsed:  decision.gene_selected.payload.selectedGeneId  ||  cycle.*.payload.gene
 //  - score:      cycle.*.payload.outcome.score
-//  - blastRadius:capsule.produced.payload.blastRadius, if emitted (else absent → not counted as empty)
+//  - blastRadius:capsule.produced.payload.blastRadius, if emitted. Productive {0,0} is omitted because non-git
+//                proofs use it as "unknown"; measured/no-value {0,0} remains an empty-cycle marker.
 // Only terminal cycles (a cycle.solidified or cycle.failed) become records; in-flight cycles are skipped.
 function payloadObj(e) {
     return e.payload && typeof e.payload === 'object' ? e.payload : {};
@@ -22,13 +23,12 @@ function cycleIdOf(p) {
  */
 export function cycleRecordsFromEvents(events) {
     const byCycle = new Map();
-    const order = [];
+    const terminalOrder = [];
     const get = (id) => {
         let a = byCycle.get(id);
         if (!a) {
             a = { terminal: false };
             byCycle.set(id, a);
-            order.push(id);
         }
         return a;
     };
@@ -53,15 +53,24 @@ export function cycleRecordsFromEvents(events) {
                 const br = p['blastRadius'];
                 if (br && typeof br === 'object') {
                     const o = br;
-                    a.blastRadius = {
-                        ...(typeof o['files'] === 'number' ? { files: o['files'] } : {}),
-                        ...(typeof o['lines'] === 'number' ? { lines: o['lines'] } : {}),
-                    };
+                    const files = typeof o['files'] === 'number' ? o['files'] : undefined;
+                    const lines = typeof o['lines'] === 'number' ? o['lines'] : undefined;
+                    // Non-git proofs use {0,0} as "blast unknown". producedValue is the authoritative distinction between
+                    // those productive cycles and a measured zero-change git cycle.
+                    const productiveUnknownBlast = p['producedValue'] === true && files === 0 && lines === 0;
+                    if (!productiveUnknownBlast) {
+                        a.blastRadius = {
+                            ...(files !== undefined ? { files } : {}),
+                            ...(lines !== undefined ? { lines } : {}),
+                        };
+                    }
                 }
                 break;
             }
             case 'cycle.solidified':
             case 'cycle.failed': {
+                if (!a.terminal)
+                    terminalOrder.push(id);
                 a.terminal = true;
                 a.status = e.type === 'cycle.solidified' ? 'success' : 'failed';
                 if (typeof p['gene'] === 'string')
@@ -77,7 +86,7 @@ export function cycleRecordsFromEvents(events) {
         }
     }
     const records = [];
-    for (const id of order) {
+    for (const id of terminalOrder) {
         const a = byCycle.get(id);
         if (!a.terminal)
             continue; // skip in-flight cycles

package/dist/signals/expand.d.ts

@@ -31,4 +31,18 @@ export declare function geneTags(gene: GeneTagInput): string[];
  * literal=1.0 upstream in expandedMatchScore. v1 #99 gave CJK full literal credit via pipe-aliases; v2 reaches
  * the right gene at ~2/3 strength. Lifting this to parity is a scoring-design change beyond this signal port.
  */
-export declare function tagOverlapScore(signals: readonly string[], gene: GeneTagInput): number;
+export declare function tagOverlapScore(signals: readonly string[], gene: GeneTagInput): number;
+export interface SemanticIdfDocument {
+    readonly tags: readonly string[];
+    readonly text: string;
+}
+export interface SemanticIdfProfile {
+    readonly documentCount: number;
+    readonly tagIdf: ReadonlyMap<string, number>;
+    readonly tokenIdf: ReadonlyMap<string, number>;
+    /** Deterministic, data-free identity for replaying the exact document-frequency profile. */
+    readonly version: string;
+}
+export declare function buildSemanticIdfProfile(documents: readonly SemanticIdfDocument[]): SemanticIdfProfile;
+export declare function idfTagOverlapScore(signals: readonly string[], gene: GeneTagInput, profile: SemanticIdfProfile): number;
+export declare function idfBagCosine(a: string, b: string, profile: SemanticIdfProfile): number;