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

package/dist/algo/cycleEngine.js

@@ -1,4 +1,5 @@
-import { canTransition } from '../cycle/stateMachine.js';
+import { LineTooLargeError } from '../events/eventStore.js';
+import { TERMINAL, canTransition, stageForEventType } from '../cycle/stateMachine.js';
 import {} from './geneSelection.js';
 import { detectPlateau } from './exploration.js';
 import { epigeneticPenaltyForIds } from './epigenetics.js';
@@ -11,10 +12,122 @@ import { applySelectForRun, applyStatsUpdate, applyForcePivot } from '../persona
 import { solidify } from './solidify.js';
 import { buildEvolutionEvent } from './evolutionEvent.js';
 import { cycleRecordsFromEvents } from '../signals/cycleHistoryFromEvents.js';
+import { withoutTaskDomainSignals } from '../signals/taskDomain.js';
 import { computeMetaSignals, deriveCycleHistory } from '../signals/metaSignals.js';
+import { capabilityGapsFromSignals, curriculumOutcomesFromEvents, generateCurriculumSignals, normalizeCapabilityGaps, } from '../signals/curriculum.js';
 import { resolveStrategy } from './strategyPresets.js';
 import { classifyCycleFailure, } from './cycleFailureClassifier.js';
 import { isDistilledGeneId } from './geneIntake.js';
+import { deriveUcb1History } from './ucb1.js';
+function persistedTerminalAfterLatestSelection(ingestor, cycleId) {
+    const events = ingestor.readAll();
+    let selectedSeq = -1;
+    for (let index = events.length - 1; index >= 0; index -= 1) {
+        const event = events[index];
+        if (event.type === 'decision.gene_selected' && event.payload['cycleId'] === cycleId) {
+            selectedSeq = event.seq;
+            break;
+        }
+    }
+    if (selectedSeq < 0)
+        return null;
+    for (let index = events.length - 1; index >= 0; index -= 1) {
+        const event = events[index];
+        if (event.seq <= selectedSeq)
+            break;
+        if (event.payload['cycleId'] !== cycleId)
+            continue;
+        const terminal = stageForEventType(event.type);
+        if (terminal && TERMINAL.has(terminal))
+            return terminal;
+    }
+    return null;
+}
+function selectionPolicyEventProjection(trace) {
+    return {
+        requested: trace.requested,
+        effective: trace.effective,
+        version: trace.selectionPolicyVersion,
+        rewardVersion: trace.rewardPolicyVersion,
+        ...(trace.arm ? {
+            arm: {
+                id: trace.arm.armId,
+                pulls: trace.arm.pulls,
+                completed: trace.arm.completedPulls,
+                total: trace.arm.totalPulls,
+                mean: trace.arm.meanReward,
+                index: trace.arm.index,
+            },
+        } : {}),
+        ...(trace.shadowDisagrees !== undefined ? { disagrees: trace.shadowDisagrees } : {}),
+        ...(trace.fallbackReason ? { fallback: trace.fallbackReason } : {}),
+    };
+}
+function minimalSelectionPolicyEventProjection(trace) {
+    return {
+        requested: trace.requested,
+        effective: trace.effective,
+        version: trace.selectionPolicyVersion,
+        rewardVersion: trace.rewardPolicyVersion,
+    };
+}
+function selectionGuardEventProjection(trace) {
+    return {
+        mode: trace.mode,
+        version: trace.version,
+        status: trace.status,
+        ...(trace.reason ? { reason: trace.reason } : {}),
+        ...(trace.maxMatch !== undefined ? { maxMatch: trace.maxMatch } : {}),
+        ...(trace.matchSpread !== undefined ? { spread: trace.matchSpread } : {}),
+    };
+}
+function minimalSelectionGuardEventProjection(trace) {
+    return {
+        mode: trace.mode,
+        version: trace.version,
+        status: trace.status,
+        ...(trace.reason ? { reason: trace.reason } : {}),
+    };
+}
+function selectionCandidateEventProjection(candidate) {
+    const { matchScore: _matchScore, ...persisted } = candidate;
+    return persisted;
+}
+async function ingestGeneSelectedWithTraceBudget(ingestor, event, policyTrace, guardTrace) {
+    const guard = guardTrace ? selectionGuardEventProjection(guardTrace) : undefined;
+    const minimalGuard = guardTrace ? minimalSelectionGuardEventProjection(guardTrace) : undefined;
+    const projections = [];
+    if (policyTrace) {
+        projections.push({ selectionPolicy: selectionPolicyEventProjection(policyTrace), ...(guard ? { selectionGuard: guard } : {}) });
+        projections.push({ selectionPolicy: minimalSelectionPolicyEventProjection(policyTrace), ...(guard ? { selectionGuard: guard } : {}) });
+        if (minimalGuard) {
+            projections.push({ selectionPolicy: minimalSelectionPolicyEventProjection(policyTrace), selectionGuard: minimalGuard });
+            projections.push({ selectionGuard: minimalGuard });
+        }
+        projections.push({ selectionPolicy: minimalSelectionPolicyEventProjection(policyTrace) });
+    }
+    else if (guard) {
+        projections.push({ selectionGuard: guard });
+        if (minimalGuard)
+            projections.push({ selectionGuard: minimalGuard });
+    }
+    projections.push({});
+    for (let index = 0; index < projections.length; index += 1) {
+        const projection = projections[index];
+        try {
+            await ingestor.ingest({
+                type: event.type,
+                human: event.human,
+                payload: { ...event.payload, ...projection },
+            });
+            return;
+        }
+        catch (error) {
+            if (!(error instanceof LineTooLargeError) || index === projections.length - 1)
+                throw error;
+        }
+    }
+}
 /** Read the trailing run of cycle outcomes (newest last) from the event log, for plateau detection. */
 function recentCycleOutcomes(ingestor, window) {
     let events;
@@ -106,7 +219,7 @@ function categoryForStrategy(category, strategy) {
  * Reading from the same append-only log makes this fully replayable. ad-hoc (innovate) cycles have no gene to
  * credit and are skipped.
  */
-function recentConfidenceObservations(ingestor, window) {
+function recentConfidenceObservations(ingestor, window, opts = {}) {
     let events;
     try {
         events = ingestor.tail(window);
@@ -146,8 +259,9 @@ function recentConfidenceObservations(ingestor, window) {
         // Older events predate the producedValue tag; when it is absent we treat the cycle as a real success, so we
         // never retroactively reclassify history into a surprise ban.
         const status = e.type === 'cycle.failed' ? 'failed' : p?.producedValue === false ? 'inert' : 'success';
+        const fingerprintSignals = opts.ignoreTaskDomain ? withoutTaskDomainSignals(signals) : signals;
         out.push({
-            signalFingerprint: signalFingerprint(signals),
+            signalFingerprint: signalFingerprint(fingerprintSignals),
             geneId: gene,
             status,
             at: Number.isFinite(at) ? at : 0,
@@ -164,14 +278,44 @@ export class CycleEngine {
     constructor(deps) {
         this.deps = deps;
     }
+    /**
+     * Add V1-compatible curriculum targets from V2's replayable event history. Public so the orchestrator can run
+     * it before candidate assembly; runCycle calls it again for direct callers. Set merging makes that idempotent.
+     */
+    prepareCurriculumSignals(signals) {
+        let externalCapabilityGaps = [];
+        try {
+            externalCapabilityGaps = normalizeCapabilityGaps(this.deps.capabilityGaps?.() ?? []);
+        }
+        catch {
+            // An optional lifecycle-state reader must never suppress local curriculum generation.
+        }
+        try {
+            const localCapabilityGaps = capabilityGapsFromSignals(signals);
+            const curriculumSignals = generateCurriculumSignals({
+                outcomes: curriculumOutcomesFromEvents(this.deps.ingestor.readAll()),
+                // Preserve existing explicit local-signal precedence; Hub gaps fill the otherwise-missing V1 source.
+                capabilityGaps: normalizeCapabilityGaps([...localCapabilityGaps, ...externalCapabilityGaps]),
+            });
+            return { signals: mergeSignals(signals, curriculumSignals), curriculumSignals };
+        }
+        catch {
+            return { signals: [...signals], curriculumSignals: [] };
+        }
+    }
     async runCycle(input) {
         const { ingestor, store } = this.deps;
         const now = this.deps.now();
         const envKey = envFingerprintKey((this.deps.envFingerprint ?? captureEnvFingerprint)());
         const reasons = [];
-        const baseSignals = input.signals;
+        const baseSignals = [...input.signals];
+        const preparedSignals = input.curriculumSignals === undefined
+            ? this.prepareCurriculumSignals(input.signals)
+            : { signals: mergeSignals(input.signals, input.curriculumSignals), curriculumSignals: [...input.curriculumSignals] };
+        const selectionSignals = preparedSignals.signals;
+        const curriculumSignals = preparedSignals.curriculumSignals;
         const metaSignals = historyMetaSignals(ingestor, 100);
-        const cycleSignals = mergeSignals(baseSignals, metaSignals);
+        const cycleSignals = mergeSignals(selectionSignals, metaSignals);
         // PORT v1 #279 issue-reporter: classify cycle.failed payloads when the caller supplies host context. The
         // post-solidify failed path adds V2-local context (current gene + blast radius) so hard-filtered local no-op
         // genes are reachable without re-emitting the old ban_gene soft signal.
@@ -221,6 +365,7 @@ export class CycleEngine {
                 cycleId: input.cycleId,
                 signals: cycleSignals,
                 baseSignals,
+                ...(curriculumSignals.length > 0 ? { curriculumSignals } : {}),
                 ...(metaSignals.length > 0 ? { metaSignals, strategy: strategy.name } : {}),
             },
         });
@@ -250,7 +395,7 @@ export class CycleEngine {
             //    recentEvents 由事件日志的近期 outcome 派生, 让"失败连击触发变异"在环内真正生效.
             const sel = await applySelectForRun(personalityDeps, {
                 driftEnabled: plateau.active,
-                signals: baseSignals,
+                signals: selectionSignals,
                 recentEvents: recentOutcomes.map((status) => ({ outcome: { status } })),
             });
             personalityForRun = sel.state;
@@ -263,8 +408,24 @@ export class CycleEngine {
                 return;
             await applyStatsUpdate({ store: this.deps.personality, ingestor, cycleId: input.cycleId }, { personality: personalityForRun, outcome, score });
         };
+        let ucb1History;
+        if (plateau.active && input.selectionPolicy && input.selectionPolicy !== 'engine-health') {
+            try {
+                ucb1History = deriveUcb1History(ingestor.readAllStrict());
+            }
+            catch {
+                // Active UCB1 fails safe to legacy drift; shadow records missing_history in its compact policy trace.
+                ucb1History = undefined;
+            }
+        }
         const exploration = plateau.active
-            ? { plateau, driftEnabled: true, totalAttempts: input.candidates.reduce((s, c) => s + (c.view?.total ?? 0), 0) }
+            ? {
+                plateau,
+                driftEnabled: true,
+                totalAttempts: input.candidates.reduce((s, c) => s + (c.view?.total ?? 0), 0),
+                ...(input.selectionPolicy ? { policy: input.selectionPolicy } : {}),
+                ...(ucb1History ? { ucb1History } : {}),
+            }
             : undefined;
         // Epigenetic: penalize candidates that fail in THIS environment class (derived from per-env outcome history).
         const geneOutcomes = recentGeneOutcomes(ingestor, 200);
@@ -272,7 +433,7 @@ export class CycleEngine {
         // signal fingerprint. Derived from the same event log, applied as a soft fourth factor in selection.
         const confidenceObs = recentConfidenceObservations(ingestor, 200);
         const confidenceEdges = deriveConfidenceEdges(confidenceObs);
-        const currentFingerprint = signalFingerprint(baseSignals);
+        const currentConfidenceFingerprint = signalFingerprint(baseSignals);
         // #195: drop genes stuck producing only inert (zero-work) cycles on THIS signal. A sole-matching do-nothing
         // gene is otherwise re-selected every cycle (drift can't diversify a single candidate) and the failure-streak
         // ban never fires because nothing "fails" — so it dominates --loop forever while producing no artifacts.
@@ -282,46 +443,85 @@ export class CycleEngine {
         // cycles evict its inert run (or the earlier real success that exempts it) and the ban would flap. Recomputing
         // it over INERT_BAN_OBSERVATION_WINDOW events (mirroring v1's memory-graph read horizon) keeps the trailing run
         // and the successCount exemption alive across intervening cycles. tail() reads the full log either way (no I/O cost).
-        const inertBanObs = recentConfidenceObservations(ingestor, INERT_BAN_OBSERVATION_WINDOW);
-        const inertBanned = inertBannedGeneIds(deriveConfidenceEdges(inertBanObs), inertBanObs, currentFingerprint);
+        const inertBanObs = recentConfidenceObservations(ingestor, INERT_BAN_OBSERVATION_WINDOW, { ignoreTaskDomain: true });
+        const inertBanFingerprint = signalFingerprint(withoutTaskDomainSignals(baseSignals));
+        const inertBanned = inertBannedGeneIds(deriveConfidenceEdges(inertBanObs), inertBanObs, inertBanFingerprint);
         const candidates = input.candidates
             .filter((c) => !isCandidateInSet(c, inertBanned))
             .map((c) => {
             const epi = epigeneticPenaltyForIds(candidateIds(c), envKey, geneOutcomes);
-            const conf = confidenceFor(confidenceEdges, currentFingerprint, c.geneId, now);
+            const conf = confidenceFor(confidenceEdges, currentConfidenceFingerprint, c.geneId, now);
             const withEpi = epi > 0 ? { ...c, epigeneticPenalty: epi } : c;
             return conf > 0 ? { ...withEpi, confidence: conf } : withEpi;
         });
         // #97 distilled-gene fallback pool: attach the env-scoped epigenetic penalty (so selection can hard-skip a
         // suppressed fallback, v1 parity) and drop any inert-banned id (composes with #195). Selection uses these only
-        // when no normal candidate clears the floor.
+        // when normal selection has no reusable positive choice.
         const distilledFallback = (input.distilledFallback ?? [])
             .filter((c) => !isCandidateInSet(c, inertBanned))
             .map((c) => {
             const epi = epigeneticPenaltyForIds(candidateIds(c), envKey, geneOutcomes);
             return epi > 0 ? { ...c, epigeneticPenalty: epi } : c;
         });
-        const decision = (await this.deps.selection.run({ signals: baseSignals, candidates, floor: input.selectionFloor, ...(input.forcedGeneId !== undefined ? { forcedGeneId: input.forcedGeneId } : {}), ...(exploration ? { exploration } : {}), ...(distilledFallback.length > 0 ? { distilledFallback } : {}), ...(input.antiWarnings && input.antiWarnings.length > 0 ? { antiWarnings: input.antiWarnings } : {}), ...(input.memoryEvidence && input.memoryEvidence.length > 0 ? { memoryEvidence: input.memoryEvidence } : {}) }, { now, cycleId: input.cycleId, ...(this.deps.rng ? { rng: this.deps.rng } : {}) }));
-        await ingestor.ingest({
+        const semanticCorpus = input.semanticCorpus?.filter((c) => !isCandidateInSet(c, inertBanned));
+        const decision = (await this.deps.selection.run({ signals: selectionSignals, candidates, ...(semanticCorpus ? { semanticCorpus } : {}), ...(input.disableSemanticIdf ? { disableSemanticIdf: true } : {}), floor: input.selectionFloor, ...(input.selectionGuard ? { selectionGuard: input.selectionGuard } : {}), ...(input.forcedGeneId !== undefined ? { forcedGeneId: input.forcedGeneId } : {}), ...(exploration ? { exploration } : {}), ...(distilledFallback.length > 0 ? { distilledFallback } : {}), ...(input.antiWarnings && input.antiWarnings.length > 0 ? { antiWarnings: input.antiWarnings } : {}), ...(input.memoryEvidence && input.memoryEvidence.length > 0 ? { memoryEvidence: input.memoryEvidence } : {}) }, { now, cycleId: input.cycleId, ...(this.deps.rng ? { rng: this.deps.rng } : {}) }));
+        const geneId = decision.selectedGeneId ?? 'ad-hoc';
+        const runPostSelectionStep = async (phase, step) => {
+            try {
+                return await step();
+            }
+            catch (error) {
+                let persistedTerminal = null;
+                try {
+                    persistedTerminal = persistedTerminalAfterLatestSelection(ingestor, input.cycleId);
+                }
+                catch {
+                    // Readback is best-effort; compensation below remains the fallback when the log is unavailable.
+                }
+                if (persistedTerminal && !TERMINAL.has(stage) && canTransition(stage, persistedTerminal)) {
+                    advance(persistedTerminal);
+                }
+                if (!persistedTerminal && !TERMINAL.has(stage)) {
+                    try {
+                        await ingestor.ingest({
+                            type: 'cycle.failed',
+                            human: { title: `cycle ${input.cycleId} selection 后异常` },
+                            payload: { cycleId: input.cycleId, reason: 'post_selection_error', phase, gene: geneId, env: envKey },
+                        });
+                        advance('failed');
+                        try {
+                            await recordPersonalityOutcome('failed', null);
+                        }
+                        catch {
+                            // Personality is soft state; never let its writeback replace the original failure.
+                        }
+                    }
+                    catch {
+                        // The event store itself may be unavailable. Preserve and rethrow the original step failure.
+                    }
+                }
+                throw error;
+            }
+        };
+        await runPostSelectionStep('decision_event', () => ingestGeneSelectedWithTraceBudget(ingestor, {
             type: 'decision.gene_selected',
             human: { title: `选 gene ${decision.selectedGeneId ?? '(innovate)'}`, why: decision.candidates.map((c) => `${c.geneId}:${c.score.toFixed(3)}`).join(', ') || '无候选→innovate' },
-            payload: { cycleId: input.cycleId, selectedGeneId: decision.selectedGeneId, ...(decision.selectedAssetId ? { selectedAssetId: decision.selectedAssetId } : {}), ...(decision.selectedReason ? { selectedReason: decision.selectedReason } : {}), candidates: decision.candidates, ...(decision.antiWarnings && decision.antiWarnings.length > 0 ? { antiWarnings: decision.antiWarnings } : {}), ...(decision.memoryEvidence && decision.memoryEvidence.length > 0 ? { memoryEvidence: decision.memoryEvidence } : {}), weightsVersion: decision.weightsVersion, strategy: decision.strategyName, strategyPreset: strategy.name, ...(plateau.active ? { plateau } : {}), ...(inertBanned.size > 0 ? { inertBanned: [...inertBanned] } : {}) },
-        });
+            payload: { cycleId: input.cycleId, selectedGeneId: decision.selectedGeneId, ...(decision.selectedAssetId ? { selectedAssetId: decision.selectedAssetId } : {}), ...(decision.selectedReason ? { selectedReason: decision.selectedReason } : {}), candidates: decision.candidates.map(selectionCandidateEventProjection), ...(decision.antiWarnings && decision.antiWarnings.length > 0 ? { antiWarnings: decision.antiWarnings } : {}), ...(decision.memoryEvidence && decision.memoryEvidence.length > 0 ? { memoryEvidence: decision.memoryEvidence } : {}), weightsVersion: decision.weightsVersion, ...(decision.semanticProfileVersion ? { semanticProfileVersion: decision.semanticProfileVersion } : {}), ...(decision.semanticDocumentCount !== undefined ? { semanticDocumentCount: decision.semanticDocumentCount } : {}), strategy: decision.strategyName, strategyPreset: strategy.name, ...(plateau.active ? { plateau } : {}), ...(inertBanned.size > 0 ? { inertBanned: [...inertBanned] } : {}) },
+        }, decision.selectionPolicy, decision.selectionGuard));
         advance('gene_selected');
-        const geneId = decision.selectedGeneId ?? 'ad-hoc';
         // 变异
-        const builtMutation = buildMutation({ decision, category: cycleCategory, signals: cycleSignals, target: input.target, expectedEffect: input.expectedEffect });
+        const builtMutation = await runPostSelectionStep('mutation_build', () => buildMutation({ decision, category: cycleCategory, signals: cycleSignals, target: input.target, expectedEffect: input.expectedEffect }));
         // 人格风险闸(用途②): 高危人格禁 innovate / 未达阈值的 high-risk 降级. 未注入人格 ⇒ 原样放行.
         // 用本轮 applySelectForRun 选出的状态(personalityForRun), 而非再读一次 store.currentState() ——
         // 保证"喂 prompt 的风格 / 过风险闸 / 回写统计"三者用的是同一个当轮人格.
         let mutation = builtMutation;
         if (this.deps.personality && personalityForRun) {
-            await emitPersonalitySelected(ingestor, { cycleId: input.cycleId, personality: personalityForRun, known: personalityKnown });
-            const gate = gatePersonalityRisk(builtMutation, personalityForRun);
+            await runPostSelectionStep('personality_selected', () => emitPersonalitySelected(ingestor, { cycleId: input.cycleId, personality: personalityForRun, known: personalityKnown }));
+            const gate = await runPostSelectionStep('personality_risk_gate', () => gatePersonalityRisk(builtMutation, personalityForRun));
             mutation = gate.mutation;
-            await emitPersonalityRiskGated(ingestor, { cycleId: input.cycleId, personality: personalityForRun, gate });
+            await runPostSelectionStep('personality_risk_gate', () => emitPersonalityRiskGated(ingestor, { cycleId: input.cycleId, personality: personalityForRun, gate }));
         }
-        await ingestor.ingest({ type: 'mutation.built', human: { title: `变异 ${mutation.category} → ${mutation.target}` }, payload: { cycleId: input.cycleId, mutationId: mutation.id, risk: mutation.risk_level, category: mutation.category, strategyPreset: strategy.name } });
+        await runPostSelectionStep('mutation_event', () => ingestor.ingest({ type: 'mutation.built', human: { title: `变异 ${mutation.category} → ${mutation.target}` }, payload: { cycleId: input.cycleId, mutationId: mutation.id, risk: mutation.risk_level, category: mutation.category, strategyPreset: strategy.name } }));
         advance('mutation_built');
         // 执行(agent/runtime)
         let exec;
@@ -332,7 +532,7 @@ export class CycleEngine {
             const msg = e instanceof Error ? e.message : String(e);
             // execute threw before returning a transcript; the error text IS the host context (a provider error that
             // surfaces as a thrown exception still classifies as host_provider_error). Pass it as the sessionLog.
-            await ingestor.ingest({ type: 'cycle.failed', human: { title: `cycle ${input.cycleId} 执行抛错` }, payload: { cycleId: input.cycleId, error: msg, gene: geneId, env: envKey, ...failureClassPayload({ geneId }, msg) } });
+            await runPostSelectionStep('terminal_event', () => ingestor.ingest({ type: 'cycle.failed', human: { title: `cycle ${input.cycleId} 执行抛错` }, payload: { cycleId: input.cycleId, error: msg, gene: geneId, env: envKey, ...failureClassPayload({ geneId }, msg) } }));
             advance('failed');
             await recordPersonalityOutcome('failed', null);
             return { cycleId: input.cycleId, triggered: true, finalStage: stage, producedValue: false, decision, mutation, reasons: [...reasons, `执行异常: ${msg}`] };
@@ -356,7 +556,7 @@ export class CycleEngine {
             }
             if (!permit.ok) {
                 const reason = `solidify permit denied: ${permit.reason}`;
-                await ingestor.ingest({
+                await runPostSelectionStep('terminal_event', () => ingestor.ingest({
                     type: 'cycle.failed',
                     human: { title: `cycle ${input.cycleId} permit denied` },
                     payload: {
@@ -367,30 +567,30 @@ export class CycleEngine {
                         ...executionMetadata(exec),
                         ...failureClassPayload({ geneId }),
                     },
-                });
+                }));
                 advance('failed');
                 await recordPersonalityOutcome('failed', null);
                 return { cycleId: input.cycleId, triggered: true, finalStage: stage, producedValue: false, decision, mutation, ...executionMetadata(exec), reasons: [...reasons, reason] };
             }
         }
         // solidify → Capsule
-        const sol = solidify({
+        const sol = await runPostSelectionStep('solidify', () => solidify({
             geneId, trigger: cycleSignals, summary: input.summary, confidence: input.confidence,
             outcome: exec.outcome, proofOfWork: exec.proofOfWork, strongEvidence: exec.strongEvidence,
-        });
+        }));
         reasons.push(...sol.reasons);
-        await store.put(sol.capsule);
-        await ingestor.ingest({ type: 'capsule.produced', human: { title: `Capsule ${sol.resolutionStatus}` }, payload: { cycleId: input.cycleId, capsuleId: sol.capsule.asset_id, resolutionStatus: sol.resolutionStatus, producedValue: sol.producedValue, blastRadius: sol.capsule.blast_radius } });
+        await runPostSelectionStep('capsule_store', () => store.put(sol.capsule));
+        await runPostSelectionStep('capsule_event', () => ingestor.ingest({ type: 'capsule.produced', human: { title: `Capsule ${sol.resolutionStatus}` }, payload: { cycleId: input.cycleId, capsuleId: sol.capsule.asset_id, resolutionStatus: sol.resolutionStatus, producedValue: sol.producedValue, blastRadius: sol.capsule.blast_radius } }));
         // EvolutionEvent(capsule_id 引 Capsule; outcome 真值在此)
-        const event = buildEvolutionEvent({
+        const event = await runPostSelectionStep('evolution_event_build', () => buildEvolutionEvent({
             intent: cycleCategory, signals: cycleSignals, genesUsed: decision.selectedGeneId ? [decision.selectedGeneId] : [],
             mutationId: mutation.id, blastRadius: sol.capsule.blast_radius, outcome: exec.outcome,
             capsuleId: sol.capsule.asset_id, sourceType: decision.selectedGeneId ? 'reused' : 'generated',
-        });
-        await store.put(event);
-        await ingestor.ingest({ type: 'evolution_event.projected', human: { title: `世代记录 ${exec.outcome.status}` }, payload: { cycleId: input.cycleId, eventId: event.asset_id, capsuleId: sol.capsule.asset_id, outcome: exec.outcome } });
+        }));
+        await runPostSelectionStep('evolution_event_store', () => store.put(event));
+        await runPostSelectionStep('evolution_event_projection', () => ingestor.ingest({ type: 'evolution_event.projected', human: { title: `世代记录 ${exec.outcome.status}` }, payload: { cycleId: input.cycleId, eventId: event.asset_id, capsuleId: sol.capsule.asset_id, outcome: exec.outcome } }));
         if (exec.outcome.status === 'failed') {
-            await ingestor.ingest({
+            await runPostSelectionStep('terminal_event', () => ingestor.ingest({
                 type: 'cycle.failed',
                 human: { title: `cycle ${input.cycleId} 失败` },
                 payload: {
@@ -411,11 +611,11 @@ export class CycleEngine {
                             : {}),
                     }, exec.sessionLog),
                 },
-            });
+            }));
             advance('failed');
         }
         else {
-            await ingestor.ingest({ type: 'cycle.solidified', human: { title: `cycle ${input.cycleId} 固化` }, payload: { cycleId: input.cycleId, capsuleId: sol.capsule.asset_id, outcome: exec.outcome, gene: geneId, env: envKey, producedValue: sol.producedValue } });
+            await runPostSelectionStep('terminal_event', () => ingestor.ingest({ type: 'cycle.solidified', human: { title: `cycle ${input.cycleId} 固化` }, payload: { cycleId: input.cycleId, capsuleId: sol.capsule.asset_id, outcome: exec.outcome, gene: geneId, env: envKey, producedValue: sol.producedValue } }));
             advance('solidified');
         }
         // 人格统计回写(用途②): 用本轮真实 outcome/score 回写当轮人格桶, 供下一轮自然选择靠拢. 未注入 ⇒ no-op.

package/dist/algo/exploration.d.ts

@@ -1,3 +1,4 @@
+import type { SelectionPolicy, Ucb1History } from './ucb1.js';
 export type PlateauSeverity = 'suggested' | 'required';
 export interface PlateauState {
     active: boolean;
@@ -6,12 +7,16 @@ export interface PlateauState {
 }
 /** Exploration control fed into selection. Absent → pure deterministic top-score selection. */
 export interface ExplorationInput {
+    /** Selection policy requested by the composition layer. Default preserves legacy engine-health + drift. */
+    policy?: SelectionPolicy;
     /** Force drift on even without a plateau (e.g. an explicit explore policy). */
     driftEnabled?: boolean;
     /** Plateau detected upstream; an active plateau forces drift intensity up. */
     plateau?: PlateauState;
     /** Total attempts across the candidate pool (drives the maturity decay of the drift offset). */
     totalAttempts?: number;
+    /** Event-log-derived state for UCB1. Undefined means fail-safe to legacy drift. */
+    ucb1History?: Ucb1History;
 }
 /**
  * Adaptive drift intensity (ported v1): 1/sqrt(Ne) + an offset that decays from 0.3 → 0.02 as the pool
@@ -25,6 +30,8 @@ export interface DriftDecision {
     index: number;
     intensity: number;
 }
+/** Deterministic top-N window shared by legacy random drift and UCB1. */
+export declare function explorationWindowSize(eligibleCount: number, exp: ExplorationInput | undefined): number;
 /**
  * Pick which ranked candidate to take among `eligibleCount` above-floor candidates.
  * No exploration → deterministic top (index 0). With exploration → compute intensity (an active plateau

package/dist/algo/exploration.js

@@ -15,8 +15,9 @@ const PLATEAU_FORCE = 10;
 export function computeDriftIntensity(ne, totalAttempts = 0) {
     if (!Number.isFinite(ne) || ne <= 1)
         return 0.7;
+    const attempts = Number.isFinite(totalAttempts) ? Math.max(0, totalAttempts) : 0;
     const maturityThreshold = ne * MATURITY_ATTEMPTS_PER_GENE;
-    const maturity = maturityThreshold > 0 ? Math.min(1, totalAttempts / maturityThreshold) : 0;
+    const maturity = maturityThreshold > 0 ? Math.min(1, attempts / maturityThreshold) : 0;
     const offset = DRIFT_OFFSET_MAX - (DRIFT_OFFSET_MAX - DRIFT_OFFSET_MIN) * maturity;
     return Math.min(1, 1 / Math.sqrt(ne) + offset);
 }
@@ -34,6 +35,18 @@ export function detectPlateau(recentOutcomes) {
         return { active: true, severity: 'suggested', count };
     return { active: false, severity: 'suggested', count };
 }
+function explorationActive(exp) {
+    return Boolean(exp && (exp.driftEnabled || exp.plateau?.active));
+}
+/** Deterministic top-N window shared by legacy random drift and UCB1. */
+export function explorationWindowSize(eligibleCount, exp) {
+    if (!explorationActive(exp) || eligibleCount <= 1)
+        return Math.min(1, Math.max(0, eligibleCount));
+    let intensity = computeDriftIntensity(eligibleCount, exp.totalAttempts ?? 0);
+    if (exp.plateau?.active)
+        intensity = Math.max(intensity, exp.plateau.severity === 'required' ? 1.0 : 0.7);
+    return Math.min(eligibleCount, Math.max(2, Math.ceil(eligibleCount * intensity)));
+}
 /**
  * Pick which ranked candidate to take among `eligibleCount` above-floor candidates.
  * No exploration → deterministic top (index 0). With exploration → compute intensity (an active plateau
@@ -41,7 +54,7 @@ export function detectPlateau(recentOutcomes) {
  * with intensity). rng() is called at most twice; pass a seeded rng for deterministic tests.
  */
 export function driftSelect(eligibleCount, exp, rng) {
-    if (!exp || (!exp.driftEnabled && !exp.plateau?.active) || eligibleCount <= 1) {
+    if (!explorationActive(exp) || eligibleCount <= 1) {
         return { driftMode: 'deterministic', index: 0, intensity: 0 };
     }
     let intensity = computeDriftIntensity(eligibleCount, exp.totalAttempts ?? 0);
@@ -49,7 +62,7 @@ export function driftSelect(eligibleCount, exp, rng) {
         intensity = Math.max(intensity, exp.plateau.severity === 'required' ? 1.0 : 0.7);
     if (rng() >= intensity)
         return { driftMode: 'deterministic', index: 0, intensity };
-    const topN = Math.min(eligibleCount, Math.max(2, Math.ceil(eligibleCount * intensity)));
+    const topN = explorationWindowSize(eligibleCount, exp);
     const index = Math.min(topN - 1, Math.max(0, Math.floor(rng() * topN)));
     return { driftMode: exp.plateau?.active ? 'plateau_drift' : 'drift', index, intensity };
 }

package/dist/algo/geneHealth.d.ts

@@ -12,10 +12,10 @@ export interface GeneHealthWeights {
     reuse: number;
     antiPattern: number;
 }
-export declare const HEALTH_WEIGHTS_VERSION = "gh-1";
+export declare const HEALTH_WEIGHTS_VERSION = "gh-2";
 export declare const DEFAULT_HEALTH_WEIGHTS: GeneHealthWeights;
 /**
- * gene 健康分 = w1·successRate + w2·reuse归一 − w3·antiPattern密度.
+ * gene 健康分 = successRate·(w1 + w2·reuse归一) − w3·antiPattern密度.
  * 输入 = M3-6 聚合视图(不内联 learning_history) + anti_patterns 数 + 复用计数.
  */
 export declare function geneHealthScore(view: GeneLearningView, opts?: {

package/dist/algo/geneHealth.js

@@ -1,16 +1,17 @@
-export const HEALTH_WEIGHTS_VERSION = 'gh-1';
-export const DEFAULT_HEALTH_WEIGHTS = { successRate: 0.6, reuse: 0.3, antiPattern: 0.4 };
+export const HEALTH_WEIGHTS_VERSION = 'gh-2';
+export const DEFAULT_HEALTH_WEIGHTS = { successRate: 0.6, reuse: 0.1, antiPattern: 0.4 };
 /** reuseCount 归一(对数压缩, 复用越多分越高但边际递减). */
 function reuseScore(count) {
     return count <= 0 ? 0 : Math.min(1, Math.log10(count + 1) / 2); // 100 次≈封顶
 }
 /**
- * gene 健康分 = w1·successRate + w2·reuse归一 − w3·antiPattern密度.
+ * gene 健康分 = successRate·(w1 + w2·reuse归一) − w3·antiPattern密度.
  * 输入 = M3-6 聚合视图(不内联 learning_history) + anti_patterns 数 + 复用计数.
  */
 export function geneHealthScore(view, opts = {}, w = DEFAULT_HEALTH_WEIGHTS) {
     const reuseCount = opts.reuseCount ?? view.total;
     const antiPatternPenalty = Math.min(1, (opts.antiPatternCount ?? 0) / 5); // 5+ anti-pattern 封顶惩罚
-    const score = w.successRate * view.successRate + w.reuse * reuseScore(reuseCount) - w.antiPattern * antiPatternPenalty;
+    const confidenceAdjustedSuccess = view.successRate * (w.successRate + w.reuse * reuseScore(reuseCount));
+    const score = confidenceAdjustedSuccess - w.antiPattern * antiPatternPenalty;
     return { geneId: view.geneId, successRate: view.successRate, reuseCount, antiPatternPenalty, score };
 }