@evomap/evolver-core 2.0.0-beta.0

package/dist/algo/cycleEngine.js

@@ -0,0 +1,417 @@
+import { canTransition } from '../cycle/stateMachine.js';
+import {} from './geneSelection.js';
+import { detectPlateau } from './exploration.js';
+import { epigeneticPenaltyForIds } from './epigenetics.js';
+import { deriveConfidenceEdges, confidenceFor, signalFingerprint, inertBannedGeneIds, INERT_BAN_OBSERVATION_WINDOW, } from './confidence.js';
+import { captureEnvFingerprint, envFingerprintKey } from '../bootstrap/envFingerprint.js';
+import { buildMutation } from './mutation.js';
+import { gatePersonalityRisk } from '../personality/riskGate.js';
+import { emitPersonalityRiskGated, emitPersonalitySelected } from '../personality/events.js';
+import { applySelectForRun, applyStatsUpdate, applyForcePivot } from '../personality/evolveOps.js';
+import { solidify } from './solidify.js';
+import { buildEvolutionEvent } from './evolutionEvent.js';
+import { cycleRecordsFromEvents } from '../signals/cycleHistoryFromEvents.js';
+import { computeMetaSignals, deriveCycleHistory } from '../signals/metaSignals.js';
+import { resolveStrategy } from './strategyPresets.js';
+import { classifyCycleFailure, } from './cycleFailureClassifier.js';
+import { isDistilledGeneId } from './geneIntake.js';
+/** Read the trailing run of cycle outcomes (newest last) from the event log, for plateau detection. */
+function recentCycleOutcomes(ingestor, window) {
+    let events;
+    try {
+        events = ingestor.tail(window);
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const e of events) {
+        if (e.type === 'cycle.solidified')
+            out.push('success');
+        else if (e.type === 'cycle.failed')
+            out.push('failed');
+    }
+    return out;
+}
+/** Read recent per-(gene, env) cycle outcomes from the event log, for epigenetic per-environment suppression. */
+function recentGeneOutcomes(ingestor, window) {
+    let events;
+    try {
+        events = ingestor.tail(window);
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const e of events) {
+        if (e.type !== 'cycle.solidified' && e.type !== 'cycle.failed')
+            continue;
+        const p = e.payload;
+        const gene = typeof p?.gene === 'string' ? p.gene : undefined;
+        const env = typeof p?.env === 'string' ? p.env : undefined;
+        if (!gene || !env)
+            continue; // pre-epigenetic events lack the tags; skip
+        out.push({ geneId: gene, envKey: env, status: e.type === 'cycle.solidified' ? 'success' : 'failed' });
+    }
+    return out;
+}
+function historyMetaSignals(ingestor, window) {
+    try {
+        return computeMetaSignals(deriveCycleHistory(cycleRecordsFromEvents(ingestor.tail(window))));
+    }
+    catch {
+        return [];
+    }
+}
+function historyCycleCount(ingestor, window, currentCycleId) {
+    let events;
+    try {
+        events = ingestor.tail(window);
+    }
+    catch {
+        return 1;
+    }
+    const cycleIds = new Set();
+    for (const e of events) {
+        if (e.type !== 'cycle.started' && e.type !== 'cycle.solidified' && e.type !== 'cycle.failed' && e.type !== 'cycle.aborted')
+            continue;
+        const p = e.payload;
+        if (typeof p?.cycleId === 'string')
+            cycleIds.add(p.cycleId);
+    }
+    cycleIds.add(currentCycleId);
+    return cycleIds.size;
+}
+function mergeSignals(signals, metaSignals) {
+    return [...new Set([...signals, ...metaSignals])];
+}
+function candidateIds(c) {
+    return [...new Set([c.geneId, c.assetId].filter((id) => typeof id === 'string' && id.length > 0))];
+}
+function isCandidateInSet(c, ids) {
+    return candidateIds(c).some((id) => ids.has(id));
+}
+function categoryForStrategy(category, strategy) {
+    if (strategy.name === 'innovate')
+        return 'innovate';
+    if (strategy.name === 'steady-state')
+        return 'optimize';
+    return category;
+}
+/**
+ * Derive preferred-gene confidence observations from the event log (positive cross-cycle learning).
+ * Each terminal cycle (cycle.solidified / cycle.failed) carries the gene that ran and the outcome; the signals
+ * that drove it are carried by the cycle.signals_collected event of the SAME cycleId. We join the two on
+ * cycleId, fingerprint the signals, and emit one (signalFingerprint, geneId, status, at) observation per cycle.
+ * 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) {
+    let events;
+    try {
+        events = ingestor.tail(window);
+    }
+    catch {
+        return [];
+    }
+    // First pass: map cycleId → its collected signals.
+    const signalsByCycle = new Map();
+    for (const e of events) {
+        if (e.type !== 'cycle.signals_collected')
+            continue;
+        const p = e.payload;
+        const cycleId = typeof p?.cycleId === 'string' ? p.cycleId : undefined;
+        const signalSource = Array.isArray(p?.baseSignals) ? p.baseSignals : p?.signals;
+        const signals = Array.isArray(signalSource) ? signalSource.map(String) : undefined;
+        if (!cycleId || !signals)
+            continue;
+        signalsByCycle.set(cycleId, signals);
+    }
+    // Second pass: for each terminal cycle with a real gene, emit an observation under its signal fingerprint.
+    const out = [];
+    for (const e of events) {
+        if (e.type !== 'cycle.solidified' && e.type !== 'cycle.failed')
+            continue;
+        const p = e.payload;
+        const cycleId = typeof p?.cycleId === 'string' ? p.cycleId : undefined;
+        const gene = typeof p?.gene === 'string' ? p.gene : undefined;
+        if (!cycleId || !gene || gene === 'ad-hoc')
+            continue; // innovate cycles credit no existing gene
+        const signals = signalsByCycle.get(cycleId);
+        if (!signals)
+            continue; // cannot fingerprint without the cycle's signals
+        const at = Date.parse(e.ts);
+        // #195: a solidified cycle that produced no measurable value (producedValue === false) is INERT, not a
+        // success — it must build no confidence and instead feeds the inert-streak ban. Failures stay 'failed'.
+        // 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';
+        out.push({
+            signalFingerprint: signalFingerprint(signals),
+            geneId: gene,
+            status,
+            at: Number.isFinite(at) ? at : 0,
+        });
+    }
+    return out;
+}
+/**
+ * cycle engine(M4A-1d): signals → trigger → 选 gene → mutation → 执行 → solidify → Capsule + EvolutionEvent.
+ * 每阶段 emit root_events 并校验状态机迁移; 写入序列守硬化 A4(capsule asset_id 先 → 填 capsule_id → event asset_id).
+ */
+export class CycleEngine {
+    deps;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    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 metaSignals = historyMetaSignals(ingestor, 100);
+        const cycleSignals = mergeSignals(baseSignals, 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.
+        const failureClassPayload = (current, execSessionLog) => {
+            // The agent transcript (#279 production wiring) comes from the execution layer on a failed outcome; the
+            // explicit failureContext.sessionLog (tests / external callers) is the fallback. EITHER one lets the
+            // host_* buckets fire on the real path.
+            const sessionLog = execSessionLog ?? input.failureContext?.sessionLog;
+            // Locality must recognise V2's real gene prefix `gene_distilled_` (isDistilledGeneId), not just the
+            // V1-only `gene_auto_` / content-hash `sha256:` forms — otherwise this gate stays shut for every real V2
+            // gene and classifyCycleFailure never runs (mirror of isLocalGeneratedGene in cycleFailureClassifier.ts).
+            const localCurrentGene = current?.geneId !== undefined && (isDistilledGeneId(current.geneId) || /^sha256:/.test(current.geneId) || /^gene_auto_/.test(current.geneId));
+            // Run classification when we have ANY host context (an exec transcript or an injected failureContext) OR a
+            // local-gene blast to judge; otherwise stay default-open (unclassified, no payload).
+            const hasHostContext = sessionLog !== undefined || input.failureContext !== undefined;
+            if (!hasHostContext && (current?.blastRadius === undefined || !localCurrentGene))
+                return {};
+            const r = classifyCycleFailure({
+                signals: cycleSignals,
+                ...(sessionLog !== undefined ? { sessionLog } : {}),
+                ...(input.failureContext?.recentFailedEvents !== undefined ? { recentEvents: input.failureContext.recentFailedEvents } : {}),
+                ...(current?.geneId !== undefined ? { geneId: current.geneId } : {}),
+                ...(current?.blastRadius !== undefined ? { blastRadius: current.blastRadius } : {}),
+            });
+            return r.reason ? { failure_class: r.failureClass, failure_class_reason: r.reason } : { failure_class: r.failureClass };
+        };
+        const strategy = resolveStrategy({ name: input.strategyName, signals: cycleSignals, cycleCount: historyCycleCount(ingestor, 1000, input.cycleId) });
+        const cycleCategory = categoryForStrategy(input.category, strategy);
+        let stage = 'none';
+        const advance = (to) => {
+            if (!canTransition(stage, to))
+                throw new Error(`非法 cycle 迁移 ${stage}→${to}`);
+            stage = to;
+        };
+        await ingestor.ingest({ type: 'cycle.started', human: { title: `cycle ${input.cycleId} 启动` }, payload: { cycleId: input.cycleId, problemId: input.problem.id } });
+        advance('started');
+        await ingestor.ingest({
+            type: 'cycle.signals_collected',
+            human: { title: `采集 ${cycleSignals.length} 信号` },
+            payload: {
+                cycleId: input.cycleId,
+                signals: cycleSignals,
+                baseSignals,
+                ...(metaSignals.length > 0 ? { metaSignals, strategy: strategy.name } : {}),
+            },
+        });
+        advance('signals_collected');
+        // 触发闸
+        const trig = this.deps.trigger ? await this.deps.trigger(input.problem, now) : { trigger: true, reasons: ['无 trigger 注入, 直接触发'], valueScore: 0 };
+        if (!trig.trigger) {
+            await ingestor.ingest({ type: 'cycle.aborted', human: { title: `cycle ${input.cycleId} 抑制` }, payload: { cycleId: input.cycleId, reasons: trig.reasons } });
+            advance('aborted');
+            return { cycleId: input.cycleId, triggered: false, finalStage: stage, reasons: trig.reasons };
+        }
+        // 选 gene(可解释决策). Exploration: when recent cycles plateau, enable drift to escape local optima.
+        const recentOutcomes = recentCycleOutcomes(ingestor, 100);
+        const plateau = detectPlateau(recentOutcomes);
+        // 可进化人格(可选). 未注入 ⇒ personalityForRun 留 undefined, 整段跳过, 后续行为逐字不变.
+        // 顺序: ③平台期先强制转向(拉高 creativity/risk 进探索) → ①自然选择朝最佳桶靠拢 + 规则触发变异.
+        // 选出的状态落盘(applySelectForRun 内 save), exec bridge 之后读回注入 prompt(用途①); 也喂本轮风险闸.
+        let personalityForRun;
+        let personalityKnown = false;
+        if (this.deps.personality) {
+            const personalityDeps = { store: this.deps.personality, ingestor, cycleId: input.cycleId };
+            // ③ plateau pivot: 在 select 之前, 让 select 从 pivot 后的 current 起步(personality.pivoted).
+            if (plateau.active) {
+                await applyForcePivot(personalityDeps, { severity: plateau.severity, evalsSinceImprovement: plateau.count });
+            }
+            // ① 自然选择 + 触发变异(真变异才发 personality.mutated). driftEnabled 跟随 plateau;
+            //    recentEvents 由事件日志的近期 outcome 派生, 让"失败连击触发变异"在环内真正生效.
+            const sel = await applySelectForRun(personalityDeps, {
+                driftEnabled: plateau.active,
+                signals: baseSignals,
+                recentEvents: recentOutcomes.map((status) => ({ outcome: { status } })),
+            });
+            personalityForRun = sel.state;
+            personalityKnown = sel.known;
+        }
+        // 每轮结束把 outcome/score 回写到当轮所用人格桶(applyStatsUpdate: 只动 stats/history, 不挪 current).
+        // 在每个终止点调用, 使下一轮 applySelectForRun 的自然选择能朝这个桶靠拢. 未注入 ⇒ no-op.
+        const recordPersonalityOutcome = async (outcome, score) => {
+            if (!this.deps.personality || !personalityForRun)
+                return;
+            await applyStatsUpdate({ store: this.deps.personality, ingestor, cycleId: input.cycleId }, { personality: personalityForRun, outcome, score });
+        };
+        const exploration = plateau.active
+            ? { plateau, driftEnabled: true, totalAttempts: input.candidates.reduce((s, c) => s + (c.view?.total ?? 0), 0) }
+            : undefined;
+        // Epigenetic: penalize candidates that fail in THIS environment class (derived from per-env outcome history).
+        const geneOutcomes = recentGeneOutcomes(ingestor, 200);
+        // Confidence (positive cross-cycle learning): reward candidates that keep succeeding under the CURRENT
+        // 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);
+        // #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.
+        // Removing it makes selection fall through to mutation (selected:null → fresh gene), restoring diversity.
+        // The ban is derived from a SEPARATE, much wider window than confidence scoring above: a banned gene runs as
+        // ad-hoc and emits no observation for itself, so a 200-event (~28-cycle) window would let intervening innovate
+        // 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 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 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.
+        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 } : {}) }, { now, cycleId: input.cycleId, ...(this.deps.rng ? { rng: this.deps.rng } : {}) }));
+        await ingestor.ingest({
+            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 } : {}), candidates: decision.candidates, ...(decision.antiWarnings && decision.antiWarnings.length > 0 ? { antiWarnings: decision.antiWarnings } : {}), weightsVersion: decision.weightsVersion, strategy: decision.strategyName, strategyPreset: strategy.name, ...(plateau.active ? { plateau } : {}), ...(inertBanned.size > 0 ? { inertBanned: [...inertBanned] } : {}) },
+        });
+        advance('gene_selected');
+        const geneId = decision.selectedGeneId ?? 'ad-hoc';
+        // 变异
+        const builtMutation = 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);
+            mutation = gate.mutation;
+            await 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 } });
+        advance('mutation_built');
+        // 执行(agent/runtime)
+        let exec;
+        try {
+            exec = await input.execute(mutation, decision);
+        }
+        catch (e) {
+            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) } });
+            advance('failed');
+            await recordPersonalityOutcome('failed', null);
+            return { cycleId: input.cycleId, triggered: true, finalStage: stage, decision, mutation, reasons: [...reasons, `执行异常: ${msg}`] };
+        }
+        if (input.solidifyPermit) {
+            let permit;
+            try {
+                permit = await input.solidifyPermit({
+                    cycleId: input.cycleId,
+                    geneId,
+                    signals: cycleSignals,
+                    mutation,
+                    decision,
+                    outcome: exec.outcome,
+                    ...(exec.proofOfWork ? { proofOfWork: exec.proofOfWork } : {}),
+                    ...(exec.strongEvidence !== undefined ? { strongEvidence: exec.strongEvidence } : {}),
+                });
+            }
+            catch {
+                permit = { ok: false, reason: 'solidify_permit_error' };
+            }
+            if (!permit.ok) {
+                const reason = `solidify permit denied: ${permit.reason}`;
+                await ingestor.ingest({
+                    type: 'cycle.failed',
+                    human: { title: `cycle ${input.cycleId} permit denied` },
+                    payload: {
+                        cycleId: input.cycleId,
+                        reason: permit.reason,
+                        gene: geneId,
+                        env: envKey,
+                        ...failureClassPayload({ geneId }),
+                    },
+                });
+                advance('failed');
+                await recordPersonalityOutcome('failed', null);
+                return { cycleId: input.cycleId, triggered: true, finalStage: stage, decision, mutation, reasons: [...reasons, reason] };
+            }
+        }
+        // solidify → Capsule
+        const sol = 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 } });
+        // EvolutionEvent(capsule_id 引 Capsule; outcome 真值在此)
+        const event = 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 } });
+        if (exec.outcome.status === 'failed') {
+            await ingestor.ingest({
+                type: 'cycle.failed',
+                human: { title: `cycle ${input.cycleId} 失败` },
+                payload: {
+                    cycleId: input.cycleId,
+                    resolutionStatus: sol.resolutionStatus,
+                    outcome: exec.outcome,
+                    gene: geneId,
+                    env: envKey,
+                    // Only forward blast radius as a no-op signal when it was measured from a git_diff proof. solidify.ts
+                    // forces blast to {0,0} for non-git_diff proofs (artifact_hash/external_receipt/tool_call_trace),
+                    // where {0,0} means "blast unknown", NOT "no change" — forwarding it would mis-classify a productive
+                    // run as local_gene_no_blast. Undefined here falls through to default-open unclassified.
+                    ...failureClassPayload({
+                        geneId,
+                        ...((exec.proofOfWork === undefined || exec.proofOfWork.kind === 'git_diff')
+                            ? { blastRadius: sol.capsule.blast_radius }
+                            : {}),
+                    }, 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 } });
+            advance('solidified');
+        }
+        // 人格统计回写(用途②): 用本轮真实 outcome/score 回写当轮人格桶, 供下一轮自然选择靠拢. 未注入 ⇒ no-op.
+        await recordPersonalityOutcome(exec.outcome.status, exec.outcome.score);
+        return { cycleId: input.cycleId, triggered: true, finalStage: stage, decision, mutation, capsule: sol.capsule, event, resolutionStatus: sol.resolutionStatus, reasons };
+    }
+}

package/dist/algo/cycleFailureClassifier.d.ts

@@ -0,0 +1,52 @@
+/** Bucket the failure falls into. unclassified = default-open (treat as a real evolver bug worth filing).
+ *  Bucket string matches V1 (EvoMap/evolver-private-dev#279 commit a89e123e) byte-for-byte so wire / UI
+ *  consumers can branch on the same value regardless of producer. */
+export type CycleFailureClass = 'host_no_transcript' | 'host_provider_error' | 'local_gene_no_blast' | 'unclassified';
+/** Shape of a recent cycle event the classifier reads. Loose so callers can pass partial DTOs. */
+export interface ClassifyRecentEvent {
+    gene?: string;
+    outcome?: {
+        status?: string;
+    };
+    blast_radius?: {
+        files?: number;
+        lines?: number;
+    };
+    blastRadius?: {
+        files?: number;
+        lines?: number;
+    };
+    meta?: {
+        empty_cycle?: boolean;
+    };
+}
+export interface ClassifyCycleFailureInput {
+    /** Cycle signals — used to detect ban_gene:<id> and locality (gene_distilled_/sha256:/gene_auto_). */
+    signals?: readonly string[];
+    /** Current failed gene in V2's hard-ban/filtering path. */
+    geneId?: string;
+    /** Current failed capsule blast radius when available. */
+    blastRadius?: {
+        files?: number;
+        lines?: number;
+    };
+    /** Recent cycle events (failed cycles only matter — blast_radius / meta.empty_cycle are checked). */
+    recentEvents?: readonly ClassifyRecentEvent[];
+    /** Optional session transcript. Empty / sentinel / provider-error text drives host_* buckets. */
+    sessionLog?: string;
+}
+export interface CycleFailureClassification {
+    /** The bucket. */
+    failureClass: CycleFailureClass;
+    /** Short human reason (≤ ~100 chars). Empty for 'unclassified'. */
+    reason: string;
+}
+/**
+ * Triage a cycle failure into a root-cause bucket. Default-open: if no rule fires, returns 'unclassified',
+ * which means "treat this as a real evolver bug" (so unclassified faults are never hidden).
+ *
+ * Pure — does not read filesystem, env, or events store.
+ */
+export declare function classifyCycleFailure(opts: ClassifyCycleFailureInput | null | undefined): CycleFailureClassification;
+/** Buckets we are confident are host-side; everything else is default-open (filed / surfaced). */
+export declare const HOST_SUPPRESS_CLASSES: ReadonlySet<CycleFailureClass>;

package/dist/algo/cycleFailureClassifier.js

@@ -0,0 +1,104 @@
+// Local root-cause triage for cycle failures (ported from v1 src/gep/issueReporter.js: classifyFailure, V1 PR #279).
+//
+// V1 #279 split signal-side (zero-blast cycles no longer feed failure-loop) from issue-reporter-side (triage host vs.
+// evolver faults before opening a public issue). V2 #216 already ported the signal-side via the inert-gene path
+// (producedValue===false → 'inert' in confidence/inertBan). This module is the missing issue-reporter half: it
+// classifies a cycle failure into one of four buckets so downstream consumers (CLI/issue-reporter, hub UI, telemetry)
+// can split confidently-host-side failures from genuine local-gene failures.
+//
+// Pure function — same input shape V1 used (signals, recentEvents, sessionLog). Inert-handling in cycleEngine
+// (#216) is untouched; if the cycle engine threads context here at the failed-write site, the classification is
+// written to the cycle.failed event payload as `failure_class`. Otherwise it is purely opt-in / advisory.
+import { isDistilledGeneId } from './geneIntake.js';
+// "[NO SESSION LOGS FOUND]" et al. — the host gave evolver nothing to evolve from.
+const HOST_NO_TRANSCRIPT_RE = /\[no session logs? found\]|no session log|no transcript/i;
+// Host LLM-provider errors. None of these strings are emitted by evolver core (v1 #279 verified the same;
+// keeping the regex byte-for-byte equivalent), so their presence means the host Agent's provider call failed.
+const HOST_PROVIDER_ERR_RE = /\bLLM ERROR\b|\bMaxTokens\b|field MaxTokens|max_tokens[^\n]{0,24}invalid|insufficient_quota|invalid_api_key|\brate limit(?:ed| exceeded)?\b|quota exceeded|context length exceeded|maximum context length/i;
+// Locality prefixes a "locally-generated" gene id can carry:
+//  - `gene_distilled_` — the ONLY prefix V2 actually mints (geneIntake.DISTILLED_ID_PREFIX,
+//    surfaced via isDistilledGeneId). Without this the whole `local_gene_no_blast` bucket never
+//    fired for real V2 genes (they all carry this prefix). Reuse the single-source-of-truth helper.
+//  - `gene_auto_` — V1-only legacy form (V2 never produces it); kept so V1-shaped inputs still match.
+//  - `sha256:` — a content asset_id (not a logical gene id); kept for back-compat / loose callers.
+function isLocalGeneratedGene(geneId) {
+    return isDistilledGeneId(geneId) || /^sha256:/.test(geneId) || /^gene_auto_/.test(geneId);
+}
+function eventBlast(e) {
+    return e.blast_radius ?? e.blastRadius;
+}
+function isZeroBlast(e) {
+    const br = eventBlast(e);
+    return Boolean(e.meta?.empty_cycle) || (br !== undefined && br.files === 0 && br.lines === 0);
+}
+// NB: blast={files:0,lines:0} only means "real no-op" when it came from a git_diff proof. solidify.ts forces
+// blast to {0,0} for non-git_diff proofs (artifact_hash/external_receipt/tool_call_trace), where it signals
+// "blast unknown", not "no change". The cycleEngine guard only forwards blastRadius for git_diff proofs, so by
+// the time we see a defined br here it is a true measured zero. If a caller ever passes a non-git_diff blast
+// directly, this would mis-classify a productive run as no-op — keep the git_diff guard at the call site.
+function blastIsZero(br) {
+    return br !== undefined && br.files === 0 && br.lines === 0;
+}
+function localNoBlastReason(geneId) {
+    return {
+        failureClass: 'local_gene_no_blast',
+        reason: `locally-generated gene ${geneId.slice(0, 20)}… produces no blast radius`,
+    };
+}
+/**
+ * Triage a cycle failure into a root-cause bucket. Default-open: if no rule fires, returns 'unclassified',
+ * which means "treat this as a real evolver bug" (so unclassified faults are never hidden).
+ *
+ * Pure — does not read filesystem, env, or events store.
+ */
+export function classifyCycleFailure(opts) {
+    const signals = Array.isArray(opts?.signals) ? opts.signals : [];
+    const events = Array.isArray(opts?.recentEvents) ? opts.recentEvents : [];
+    const hasSessionLog = typeof opts?.sessionLog === 'string';
+    const log = hasSessionLog ? opts.sessionLog : undefined;
+    // (a) No transcript -> the host gave evolver nothing to evolve from.
+    if (hasSessionLog && (!log.trim() || HOST_NO_TRANSCRIPT_RE.test(log))) {
+        return { failureClass: 'host_no_transcript', reason: 'no session transcript to evolve from' };
+    }
+    // (b) Host LLM-provider error surfaced in the transcript.
+    const prov = hasSessionLog ? log.match(HOST_PROVIDER_ERR_RE) : null;
+    if (prov) {
+        return { failureClass: 'host_provider_error', reason: `host LLM-provider error: ${String(prov[0]).slice(0, 60)}` };
+    }
+    // (c-v2) V2 hard-bans/filters local no-op genes instead of emitting a soft ban_gene signal. Use the current
+    // failed gene + current blast radius when the engine supplies them, while keeping the legacy ban_gene branch below.
+    const currentGeneId = typeof opts?.geneId === 'string' ? opts.geneId : undefined;
+    if (currentGeneId && isLocalGeneratedGene(currentGeneId)) {
+        if (blastIsZero(opts?.blastRadius))
+            return localNoBlastReason(currentGeneId);
+        const failedForGene = events.filter((e) => e.outcome?.status === 'failed' && (e.gene === undefined || e.gene === currentGeneId));
+        if (failedForGene.length > 0 && failedForGene.every(isZeroBlast))
+            return localNoBlastReason(currentGeneId);
+    }
+    if (!currentGeneId) {
+        const failedLocalEvents = events.filter((e) => e.outcome?.status === 'failed' && typeof e.gene === 'string' && isLocalGeneratedGene(e.gene));
+        for (const e of failedLocalEvents) {
+            if (e.gene && isZeroBlast(e))
+                return localNoBlastReason(e.gene);
+        }
+    }
+    // (c) The banned gene is locally generated AND every recent failing cycle changed nothing — a no-op gene,
+    //     not an evolver bug. (V2 #216 already drops such genes via the inert ban; this is the issue-reporter
+    //     analogue, classifying after a failure_loop fires anyway.)
+    const banned = signals.find((s) => typeof s === 'string' && s.startsWith('ban_gene:'));
+    if (banned) {
+        const geneId = banned.replace('ban_gene:', '');
+        const failed = events.filter((e) => e?.outcome?.status === 'failed');
+        const allZeroBlast = failed.length > 0 && failed.every(isZeroBlast);
+        if (isLocalGeneratedGene(geneId) && allZeroBlast) {
+            return localNoBlastReason(geneId);
+        }
+    }
+    return { failureClass: 'unclassified', reason: '' };
+}
+/** Buckets we are confident are host-side; everything else is default-open (filed / surfaced). */
+export const HOST_SUPPRESS_CLASSES = new Set([
+    'host_no_transcript',
+    'host_provider_error',
+    'local_gene_no_blast',
+]);

package/dist/algo/epigenetics.d.ts

@@ -0,0 +1,14 @@
+import { envFingerprintKey } from '../bootstrap/envFingerprint.js';
+export { envFingerprintKey };
+export interface GeneEnvOutcome {
+    geneId: string;
+    envKey: string;
+    status: 'success' | 'failed';
+}
+/**
+ * Epigenetic penalty in [0, MAX_PENALTY] for `geneId` in the current `envKey`, from recent per-env outcomes.
+ * 0 when there is not enough evidence (< MIN_ENV_ATTEMPTS) or the in-env fail rate is below SUPPRESS_FAIL_RATE;
+ * scales linearly from 0 at SUPPRESS_FAIL_RATE up to MAX_PENALTY at a 100% in-env fail rate.
+ */
+export declare function epigeneticPenaltyForIds(ids: readonly string[], envKey: string, outcomes: readonly GeneEnvOutcome[]): number;
+export declare function epigeneticPenalty(geneId: string, envKey: string, outcomes: readonly GeneEnvOutcome[]): number;

package/dist/algo/epigenetics.js

@@ -0,0 +1,41 @@
+// Epigenetic per-environment gene suppression (ported from v1 src/gep/epigenetics.js, adapted to v2's
+// derive-from-events model). A gene that fails in the CURRENT environment class (but works elsewhere)
+// should be penalized HERE only, not globally — its global health is untouched. v1 stored marks on the
+// gene asset; v2 derives the penalty from recent per-(gene, env) outcomes at selection time, so no asset
+// mutation and no schema churn. The penalty is subtracted from the gene's selection score; a gene that
+// fails hard in this env falls in ranking (and below the floor → innovate) without being globally banned.
+import { envFingerprintKey } from '../bootstrap/envFingerprint.js';
+export { envFingerprintKey };
+const MIN_ENV_ATTEMPTS = 3; // need this many attempts of the gene in this env before the penalty engages
+const SUPPRESS_FAIL_RATE = 0.7; // fail rate (in this env) at/above which the penalty starts
+const MAX_PENALTY = 0.5; // cap (subtracted from a [0,1]-ish score)
+/**
+ * Epigenetic penalty in [0, MAX_PENALTY] for `geneId` in the current `envKey`, from recent per-env outcomes.
+ * 0 when there is not enough evidence (< MIN_ENV_ATTEMPTS) or the in-env fail rate is below SUPPRESS_FAIL_RATE;
+ * scales linearly from 0 at SUPPRESS_FAIL_RATE up to MAX_PENALTY at a 100% in-env fail rate.
+ */
+export function epigeneticPenaltyForIds(ids, envKey, outcomes) {
+    if (!envKey)
+        return 0;
+    const idSet = new Set(ids.filter((id) => id.length > 0));
+    if (idSet.size === 0)
+        return 0;
+    let attempts = 0;
+    let fails = 0;
+    for (const o of outcomes) {
+        if (!idSet.has(o.geneId) || o.envKey !== envKey)
+            continue;
+        attempts += 1;
+        if (o.status === 'failed')
+            fails += 1;
+    }
+    if (attempts < MIN_ENV_ATTEMPTS)
+        return 0;
+    const failRate = fails / attempts;
+    if (failRate < SUPPRESS_FAIL_RATE)
+        return 0;
+    return Math.min(MAX_PENALTY, MAX_PENALTY * ((failRate - SUPPRESS_FAIL_RATE) / (1 - SUPPRESS_FAIL_RATE)));
+}
+export function epigeneticPenalty(geneId, envKey, outcomes) {
+    return epigeneticPenaltyForIds([geneId], envKey, outcomes);
+}

package/dist/algo/evolutionEvent.d.ts

@@ -0,0 +1,23 @@
+import { type EvolutionEvent, type GepCategory } from '../wire/index.js';
+export interface BuildEvolutionEventInput {
+    intent: GepCategory;
+    signals: readonly string[];
+    genesUsed: readonly string[];
+    mutationId: string;
+    blastRadius: {
+        files: number;
+        lines: number;
+    };
+    outcome: {
+        status: 'success' | 'failed';
+        score: number;
+    };
+    capsuleId: string | null;
+    sourceType: 'generated' | 'reused' | 'reference';
+    parent?: string | null;
+}
+/**
+ * EvolutionEvent = 世代记录(outcome 真值在此, 硬化 A4). 单向引 Capsule(capsule_id);
+ * 写入序列: capsule asset_id 先算 → 填 capsule_id → 再算 event asset_id.
+ */
+export declare function buildEvolutionEvent(input: BuildEvolutionEventInput): EvolutionEvent;