@evomap/evolver-core 2.0.0-beta.0

package/dist/algo/geneSelection.js

@@ -0,0 +1,222 @@
+import { StrategyPoint } from '../strategy/strategyPoint.js';
+import { geneHealthScore, HEALTH_WEIGHTS_VERSION } from './geneHealth.js';
+import { tagOverlapScore, bagCosine } from '../signals/expand.js';
+import { driftSelect } from './exploration.js';
+import { isDistilledGeneId } from './geneIntake.js';
+function decisionWithWarnings(input, decision) {
+    return input.antiWarnings && input.antiWarnings.length > 0
+        ? { ...decision, antiWarnings: [...input.antiWarnings] }
+        : decision;
+}
+function signalMatchScore(signals, match) {
+    if (signals.length === 0 || match.length === 0)
+        return 0;
+    const set = new Set(signals);
+    const hit = match.filter((m) => set.has(m)).length;
+    return hit / match.length; // 覆盖率
+}
+// Weight of the bag-of-words cosine path when it fills the recall gap left by literal + tag overlap.
+const SEMANTIC_WEIGHT = 0.5;
+/**
+ * Weight of the preferred-gene confidence factor (fourth factor, positive cross-cycle learning). Kept small so
+ * it only re-orders near-ties between already-eligible candidates rather than overriding health / signal match.
+ */
+export const CONFIDENCE_WEIGHT = 0.15;
+/**
+ * Weight of the cross-runtime reuse-sentiment factor (#268 phase 1). Deliberately SMALLER than CONFIDENCE_WEIGHT:
+ * a self-reported reuse outcome is weaker evidence than the confidence sidecar (which is built from verified cycle
+ * history), so it only re-orders near-ties. Clamped to a [-1,1] sentiment, so its contribution is bounded to
+ * ±REUSE_WEIGHT and can never dominate health/signal-match.
+ */
+export const REUSE_WEIGHT = 0.1;
+/**
+ * Version of the full engine-health weight vector (health 0.6 + signal-match 0.4 − epigenetic penalty
+ * + CONFIDENCE_WEIGHT × confidence + REUSE_WEIGHT × reuse-sentiment). Bumped whenever a factor is added so golden
+ * weight snapshots track the change. Composed from the health-weights version so a change to either layer shows.
+ */
+export const SELECTION_WEIGHTS_VERSION = `sel-3(${HEALTH_WEIGHTS_VERSION},conf=${CONFIDENCE_WEIGHT},reuse=${REUSE_WEIGHT})`;
+/**
+ * Match score with semantic signal expansion (ported from v1): literal coverage first, then fill the
+ * recall gap with semantic tag overlap, then with bag-of-words cosine similarity. A perfect literal match
+ * short-circuits to 1; otherwise tag overlap adds partial credit (so a '429' signal can reach a gene tagged
+ * for 'repair'), and cosine catches lexical similarity the curated tags miss (e.g. a 'timeout_slow' signal
+ * vs a gene summarized "fix the slow timeout"). Each layer only fills the gap the previous one left.
+ */
+function expandedMatchScore(signals, c) {
+    const literal = signalMatchScore(signals, c.signalsMatch);
+    if (literal >= 1)
+        return { score: 1, literal, tag: 0, cos: 0 };
+    const tag = tagOverlapScore(signals, { signalsMatch: c.signalsMatch, geneId: c.geneId, category: c.category, summary: c.summary });
+    const base = Math.min(1, literal + (1 - literal) * tag);
+    if (base >= 1)
+        return { score: 1, literal, tag, cos: 0 };
+    const geneText = [...c.signalsMatch, c.category ?? '', c.summary ?? ''].join(' ');
+    const cos = bagCosine(signals.join(' '), geneText);
+    return { score: Math.min(1, base + (1 - base) * cos * SEMANTIC_WEIGHT), literal, tag, cos };
+}
+/** Score one candidate under the engine-health weight vector (health 0.6 + 信号匹配 0.4 − epigenetic + confidence). */
+function scoreCandidate(signals, c) {
+    const health = geneHealthScore(c.view, { reuseCount: c.reuseCount, antiPatternCount: c.antiPatternCount });
+    const m = expandedMatchScore(signals, c);
+    const epi = c.epigeneticPenalty ?? 0;
+    // Confidence is the fourth (positive) factor: a [0,1] preferred-gene edge for this signal fingerprint.
+    // Clamped defensively so an upstream bug cannot turn the soft nudge into a dominant term.
+    const conf = Math.max(0, Math.min(1, c.confidence ?? 0));
+    // Cross-runtime reuse sentiment (#268 phase 1): clamped to [-1,1] so an upstream bug cannot turn the soft nudge
+    // into a dominant (or unbounded) term. Absent → 0 → no effect (default-off until a caller injects it).
+    const reuse = Math.max(-1, Math.min(1, c.reuseAdjust ?? 0));
+    const score = 0.6 * health.score + 0.4 * m.score - epi + CONFIDENCE_WEIGHT * conf + REUSE_WEIGHT * reuse;
+    const breakdown = m.tag > 0 || m.cos > 0 ? `(literal=${m.literal.toFixed(2)}+tag=${m.tag.toFixed(2)}+cos=${m.cos.toFixed(2)})` : '';
+    const reasons = [`health=${health.score.toFixed(3)}(succ=${health.successRate.toFixed(2)},reuse=${health.reuseCount})`, `信号匹配=${m.score.toFixed(2)}${breakdown}`];
+    if (epi > 0)
+        reasons.push(`epigenetic 环境抑制 -${epi.toFixed(2)}`);
+    if (conf > 0)
+        reasons.push(`preferred-gene confidence +${(CONFIDENCE_WEIGHT * conf).toFixed(3)} (conf=${conf.toFixed(2)})`);
+    if (reuse !== 0)
+        reasons.push(`cross-runtime reuse ${reuse >= 0 ? '+' : ''}${(REUSE_WEIGHT * reuse).toFixed(3)} (sentiment=${reuse.toFixed(2)})`);
+    return { geneId: c.geneId, ...(c.assetId ? { assetId: c.assetId } : {}), score, health, reasons };
+}
+function matchesForcedGeneId(c, forcedGeneId) {
+    return c.geneId === forcedGeneId || c.assetId === forcedGeneId;
+}
+function matchesCandidateIdentity(s, c) {
+    return c.assetId ? s.assetId === c.assetId : s.geneId === c.geneId;
+}
+function matchesScoredIdentity(a, b) {
+    return b.assetId ? a.assetId === b.assetId : a.geneId === b.geneId;
+}
+function withoutCandidateIdentity(scored, c) {
+    return scored.filter((s) => !matchesCandidateIdentity(s, c));
+}
+function forcedSelection(input, scored, scoreForcedFallback, floor) {
+    const forcedGeneId = input.forcedGeneId?.trim();
+    if (!forcedGeneId)
+        return { scoredForChoice: scored };
+    const source = input.candidates.find((c) => matchesForcedGeneId(c, forcedGeneId));
+    if (source) {
+        const forced = scored.find((s) => matchesCandidateIdentity(s, source));
+        if (!forced)
+            return { scoredForChoice: scored };
+        if ((source.epigeneticPenalty ?? 0) > 0) {
+            forced.reasons.push('forced gene rejected: epigenetic suppression');
+            return { scoredForChoice: withoutCandidateIdentity(scored, source), forceRejected: true };
+        }
+        forced.reasons.push(`forced gene selected: explicit forcedGeneId matched assembled candidate (${forcedGeneId})`);
+        if (floor !== undefined && forced.score <= floor)
+            forced.reasons.push(`forced gene selected despite floor ${floor}`);
+        return { selectedGeneId: source.geneId, ...(source.assetId ? { selectedAssetId: source.assetId } : {}), scoredForChoice: scored };
+    }
+    const fallback = (input.distilledFallback ?? []).find((c) => matchesForcedGeneId(c, forcedGeneId));
+    if (!fallback)
+        return { scoredForChoice: scored };
+    const scoredCandidatesOnly = scored.slice();
+    const forcedFallback = scoreForcedFallback(fallback);
+    scored.push(forcedFallback);
+    if ((fallback.epigeneticPenalty ?? 0) > 0) {
+        forcedFallback.reasons.push('forced gene rejected: epigenetic suppression');
+        return { scoredForChoice: scoredCandidatesOnly, forceRejected: true };
+    }
+    if (!isDistilledGeneId(fallback.geneId)) {
+        forcedFallback.reasons.push('forced gene rejected: suppressed fallback');
+        return { scoredForChoice: scoredCandidatesOnly, forceRejected: true };
+    }
+    forcedFallback.reasons.push(`forced gene selected: explicit forcedGeneId matched assembled distilled fallback (${forcedGeneId})`);
+    if (floor !== undefined && forcedFallback.score <= floor)
+        forcedFallback.reasons.push(`forced gene selected despite floor ${floor}`);
+    return { selectedGeneId: fallback.geneId, ...(fallback.assetId ? { selectedAssetId: fallback.assetId } : {}), scoredForChoice: scoredCandidatesOnly };
+}
+/** 实现1: engine 健康分主导(health 0.6 + 信号匹配 0.4). */
+export const engineHealthSelection = {
+    name: 'engine-health',
+    version: '1',
+    run(input, ctx) {
+        const scored = input.candidates.map((c) => scoreCandidate(input.signals, c)).sort((a, b) => b.score - a.score);
+        const floor = input.floor ?? 0;
+        const forced = forcedSelection(input, scored, (c) => scoreCandidate(input.signals, c), floor);
+        const eligible = forced.scoredForChoice.filter((s) => s.score > floor);
+        // Deterministic top by default; exploration drift picks from the top-N to escape local optima.
+        const drift = driftSelect(eligible.length, input.exploration, ctx?.rng ?? Math.random);
+        const chosen = eligible[drift.index] ?? eligible[0];
+        let selectedGeneId = forced.selectedGeneId ?? (chosen ? chosen.geneId : null);
+        let selectedAssetId = forced.selectedAssetId ?? chosen?.assetId;
+        if (!selectedGeneId) {
+            // Issue #97 (ported from v1 selector.js): no candidate matched any live signal (every gene scored <= 0). Rather
+            // than fall straight through to a blind innovate, reuse a *distilled* gene if one is available. NB the prefix
+            // does NOT mean "skill-derived" in v2 the way it did in v1: v1 tagged only skill genes gene_distilled_ (auto-
+            // evolved genes were gene_auto_), but v2's intakeGene tags EVERY intaken gene gene_distilled_ (autoExec even
+            // intakes task strategies that way) and has no gene_auto_. So this pool is "any trusted/approved/non-suppressed
+            // pooled gene that does not match", not specifically skill-derived — the safety rests on the upstream gates
+            // (trust #30 / review #89-91 / signal-ban / inert-ban #195) plus the epigenetic skip below, not on a skill-
+            // provenance low-blast-radius assumption. We skip any distilled fallback epigenetically suppressed in this env;
+            // v2's event-log-derived epigeneticPenalty is the analog of v1's asset-mark hard suppression (related band, not
+            // the identical predicate). No usable distilled fallback → stay null so the caller still innovates (the contract).
+            //
+            // v1 #97 parity: the distilled fallback is a *no-signal-match* last resort — it must fire only when NOTHING
+            // scored above zero, NOT merely when nothing cleared a positive `floor`. Otherwise a real but weak signal match
+            // (0 < score <= floor) would be preempted by an unrelated zero-evidence distilled gene; V1 (which has no floor)
+            // keeps such a match. When candidates scored > 0 but below floor, defer to V2's floor policy (innovate).
+            const noSignalMatch = !forced.forceRejected && forced.scoredForChoice.every((s) => s.score <= 0);
+            const fb = noSignalMatch
+                ? (input.distilledFallback ?? []).find((c) => isDistilledGeneId(c.geneId) && (c.epigeneticPenalty ?? 0) === 0)
+                : undefined;
+            if (fb) {
+                const fbScored = scoreCandidate(input.signals, fb);
+                fbScored.reasons.push('distilled_fallback(#97): 无信号匹配, 低置信度复用蒸馏 gene');
+                scored.push(fbScored);
+                selectedGeneId = fb.geneId;
+                selectedAssetId = fb.assetId;
+            }
+            else {
+                forced.scoredForChoice.forEach((s) => s.reasons.push(`< floor ${floor} → innovate`));
+            }
+        }
+        else if (forced.selectedGeneId === undefined && drift.driftMode !== 'deterministic') {
+            scored.find((s) => s.geneId === selectedGeneId)?.reasons.push(`drift(${drift.driftMode},intensity=${drift.intensity.toFixed(2)})`);
+        }
+        return decisionWithWarnings(input, { selectedGeneId, ...(selectedAssetId ? { selectedAssetId } : {}), candidates: scored, weightsVersion: SELECTION_WEIGHTS_VERSION, strategyName: 'engine-health' });
+    },
+};
+/** 实现2: 纯信号匹配采样(忽略 health, 对照基线 — 经验主义要可对比). */
+export const signalMatchSelection = {
+    name: 'signal-match',
+    version: '1',
+    run(input) {
+        const scoreSignalCandidate = (c) => ({
+            geneId: c.geneId, ...(c.assetId ? { assetId: c.assetId } : {}), score: signalMatchScore(input.signals, c.signalsMatch),
+            reasons: [`纯信号匹配=${signalMatchScore(input.signals, c.signalsMatch).toFixed(2)}`],
+        });
+        const scored = input.candidates.map((c) => scoreSignalCandidate(c)).sort((a, b) => b.score - a.score);
+        const forced = forcedSelection(input, scored, scoreSignalCandidate, input.floor ?? 0);
+        const top = forced.scoredForChoice[0];
+        const selectedGeneId = forced.selectedGeneId ?? (top && top.score > (input.floor ?? 0) ? top.geneId : null);
+        const selectedAssetId = forced.selectedAssetId ?? (selectedGeneId === top?.geneId ? top.assetId : undefined);
+        return decisionWithWarnings(input, {
+            selectedGeneId,
+            ...(selectedAssetId ? { selectedAssetId } : {}),
+            candidates: scored, weightsVersion: 'none', strategyName: 'signal-match',
+        });
+    },
+};
+/** 实现3: agent 主导(注入决策回调; engine 只给候选+分, agent 拍板, D26 agent 一等公民). */
+export function agentLedSelection(pick) {
+    return {
+        name: 'agent-led',
+        version: '1',
+        run(input, ctx) {
+            const baseDecision = engineHealthSelection.run(input, ctx);
+            const base = baseDecision.candidates;
+            const forced = input.forcedGeneId ? base.find((s) => s.reasons.some((r) => r.includes('forced gene'))) : undefined;
+            if (forced?.reasons.some((r) => r.includes('forced gene selected'))) {
+                return decisionWithWarnings(input, { selectedGeneId: forced.geneId, ...(forced.assetId ? { selectedAssetId: forced.assetId } : {}), candidates: base, weightsVersion: SELECTION_WEIGHTS_VERSION, strategyName: 'agent-led' });
+            }
+            const candidatesForPick = forced?.reasons.some((r) => r.includes('forced gene rejected')) ? base.filter((s) => !matchesScoredIdentity(s, forced)) : base;
+            const choice = pick(candidatesForPick, input);
+            const selected = candidatesForPick.find((s) => s.geneId === choice) ?? base.find((s) => s.geneId === choice);
+            return decisionWithWarnings(input, { selectedGeneId: choice, ...(selected?.assetId ? { selectedAssetId: selected.assetId } : {}), candidates: base, weightsVersion: SELECTION_WEIGHTS_VERSION, strategyName: 'agent-led' });
+        },
+    };
+}
+/** 选 gene StrategyPoint: 默认 engine-health, 备选 signal-match(+ 可注册 agent-led). */
+export function makeGeneSelectionPoint() {
+    return new StrategyPoint('gene-selection', engineHealthSelection).register(signalMatchSelection);
+}

package/dist/algo/index.d.ts

@@ -0,0 +1,18 @@
+export * from './geneHealth.js';
+export * from './exploration.js';
+export * from './epigenetics.js';
+export * from './confidence.js';
+export * from './capabilityCandidates.js';
+export * from './geneIntake.js';
+export * from './candidateAssembly.js';
+export * from './genePromotion.js';
+export * from './bans.js';
+export * from './antiDistill.js';
+export * from './orchestrator.js';
+export * from './geneSelection.js';
+export * from './mutation.js';
+export * from './solidify.js';
+export * from './evolutionEvent.js';
+export * from './cycleEngine.js';
+export * from './strategyPresets.js';
+export * from './cycleFailureClassifier.js';

package/dist/algo/index.js

@@ -0,0 +1,18 @@
+export * from './geneHealth.js';
+export * from './exploration.js';
+export * from './epigenetics.js';
+export * from './confidence.js';
+export * from './capabilityCandidates.js';
+export * from './geneIntake.js';
+export * from './candidateAssembly.js';
+export * from './genePromotion.js';
+export * from './bans.js';
+export * from './antiDistill.js';
+export * from './orchestrator.js';
+export * from './geneSelection.js';
+export * from './mutation.js';
+export * from './solidify.js';
+export * from './evolutionEvent.js';
+export * from './cycleEngine.js';
+export * from './strategyPresets.js';
+export * from './cycleFailureClassifier.js';

package/dist/algo/mutation.d.ts

@@ -0,0 +1,12 @@
+import type { GepCategory, Mutation } from '../wire/index.js';
+import type { GeneDecision } from './geneSelection.js';
+export interface BuildMutationInput {
+    decision: GeneDecision;
+    category: GepCategory;
+    signals: readonly string[];
+    target: string;
+    expectedEffect: string;
+    riskOverride?: Mutation['risk_level'];
+}
+/** 由选择决策构造 Mutation(瞬态, 不落资产库; 进 root_events). */
+export declare function buildMutation(input: BuildMutationInput): Mutation;

package/dist/algo/mutation.js

@@ -0,0 +1,22 @@
+import { ulid as makeUlid } from 'ulid';
+/** category → 基线风险(innovate/explore 改动开放面大, repair 收敛). 选不到 gene(innovate)再升一档. */
+function baselineRisk(category, noGene) {
+    if (category === 'innovate' || category === 'explore')
+        return 'high';
+    if (noGene)
+        return 'medium'; // 无现成 gene = 新路径
+    return category === 'repair' ? 'low' : 'medium';
+}
+/** 由选择决策构造 Mutation(瞬态, 不落资产库; 进 root_events). */
+export function buildMutation(input) {
+    const noGene = input.decision.selectedGeneId === null;
+    return {
+        type: 'Mutation',
+        id: makeUlid(),
+        category: input.category,
+        trigger_signals: [...input.signals],
+        target: input.target,
+        expected_effect: input.expectedEffect,
+        risk_level: input.riskOverride ?? baselineRisk(input.category, noGene),
+    };
+}

package/dist/algo/orchestrator.d.ts

@@ -0,0 +1,65 @@
+import type { AssetStoreProvider } from '../assetstore/provider.js';
+import type { ProvenanceStore } from '../assetstore/provenance.js';
+import type { ReviewLedger } from '../assetstore/reviewLedger.js';
+import type { GepCategory } from '../wire/index.js';
+import type { ProblemPattern } from '../schema/problem.js';
+import type { GeneCandidateInput } from './geneSelection.js';
+import { CycleEngine, type CycleInput, type CycleResult, type SolidifyPermitGate } from './cycleEngine.js';
+import { type PendingSignalsContext } from '../assetstore/pendingSignals.js';
+import { type ReuseOutcomeSummary, type ReuseOutcomeEvent } from '../ops/reuseOutcomes.js';
+export interface RunCycleOptions {
+    cycleId: string;
+    problem: ProblemPattern;
+    signals: readonly string[];
+    category: GepCategory;
+    /** Optional explicit strategy preset name forwarded to CycleEngine. */
+    strategyName?: string;
+    target: string;
+    expectedEffect: string;
+    summary: string;
+    confidence: number;
+    selectionFloor?: number;
+    /** Optional explicit gene chosen by GEP / an external runtime; forwarded to CycleEngine after assembly. */
+    forcedGeneId?: string;
+    /** The agent runtime's work: run the mutation, return the outcome. */
+    execute: CycleInput['execute'];
+    /** Optional triage context forwarded to CycleEngine for cycle.failed classification. */
+    failureContext?: CycleInput['failureContext'];
+    /** Optional adapter/runtime permit gate. Runs after execute succeeds and before solidify writes assets. */
+    solidifyPermit?: SolidifyPermitGate;
+    /** Cap on how many genes are pulled from the store as candidates. */
+    candidateLimit?: number;
+    /** Trust-first selection (#30): exclude hub-ingested genes unless promoted. */
+    provenance?: ProvenanceStore;
+    /** Review-first selection (#89/#91): exclude quarantined/rejected auto-distilled drafts. */
+    review?: ReviewLedger;
+    /** Probation (#306, gated): let a quarantined draft be TRIED to earn evidence (rejected stays out). Default off. */
+    includeProbation?: boolean;
+    /**
+     * Reuse-before-solve hub candidates (#110): already-resolved hub assets (the adapter's free search →
+     * pure score → paid fetch flow) injected to compete in the SAME selection pool as local genes. Core stays
+     * hub-agnostic — it only forwards these into assembleCandidates, which merges them trust-first (a geneId
+     * colliding with a trusted local gene keeps the local one). Omit (the default) → no hub candidates → exactly
+     * today's behavior. The hub call/billing/cache all live in the adapter; this is the in-cycle injection point.
+     */
+    hubCandidates?: readonly GeneCandidateInput[];
+    /** Optional v1-compatible pending_signals.json path context. */
+    pendingSignalsContext?: PendingSignalsContext;
+    /** Disable only when the caller already consumed pending_signals.json before invoking this cycle. */
+    consumePendingSignals?: boolean;
+    /**
+     * Cross-runtime reuse-outcome summary (#268 phase 1): when provided, it is mapped to a per-gene sentiment that
+     * SOFTLY re-orders selection (down-rank genes foreign agents keep finding unhelpful, up-rank ones they reuse
+     * successfully). Omit (the default) → no reuse re-order → exactly today's behavior. The signal is computed by
+     * the composition layer from reuse-outcome events; core just folds it into the selection pool here.
+     */
+    reuseOutcomes?: ReuseOutcomeSummary;
+    /**
+     * Observed `value.recall` events (#274 slice 3): folded into the same soft re-order as reuse outcomes, at a lower
+     * weight (RECALL_WEIGHT) — `used` nudges up, `unused` nudges down. This is how transcript-OBSERVED recall (not
+     * agent self-report) gains teeth on selection. Omit → no recall contribution. Never feeds quarantine.
+     */
+    recallEvents?: readonly ReuseOutcomeEvent[];
+}
+/** Drive one full evolution cycle end-to-end: assemble candidates from the store, then run the cycle. */
+export declare function runEvolutionCycle(engine: CycleEngine, store: AssetStoreProvider, opts: RunCycleOptions): Promise<CycleResult>;

package/dist/algo/orchestrator.js

@@ -0,0 +1,63 @@
+import { CycleEngine } from './cycleEngine.js';
+import { assembleSelectionPool } from './candidateAssembly.js';
+import { mergePendingSignalsForStore } from '../assetstore/pendingSignals.js';
+import { reuseCountsFromSummary, recallCountsFromEvents } from '../ops/reuseOutcomes.js';
+/** Drive one full evolution cycle end-to-end: assemble candidates from the store, then run the cycle. */
+export async function runEvolutionCycle(engine, store, opts) {
+    let signals = [...opts.signals];
+    if (opts.consumePendingSignals !== false) {
+        try {
+            const explicit = mergePendingSignalsForStore(store, opts.signals, opts.pendingSignalsContext);
+            signals = explicit.signals;
+            if (explicit.injected > 0) {
+                console.log(`[ExplicitSignals] Injected ${explicit.injected} user-declared signal(s) from pending_signals.json.`);
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.warn(`[ExplicitSignals] Failed to consume pending signals (non-fatal): ${message}`);
+        }
+    }
+    // #268 phase 1 + #274 slice 3: fold cross-runtime reuse counts AND observed recall into the pool (soft re-order).
+    // Absent both → no map → default-off. Recall is folded at a lower weight (RECALL_WEIGHT). Assembly sums a gene's
+    // ids → sentiment; bounded + clamped in geneSelection; the hard trust/review/ban gates in assembly run first.
+    const reuseCounts = opts.reuseOutcomes ? reuseCountsFromSummary(opts.reuseOutcomes) : new Map();
+    if (opts.recallEvents && opts.recallEvents.length > 0) {
+        for (const [id, rc] of recallCountsFromEvents(opts.recallEvents)) {
+            const c = reuseCounts.get(id) ?? { success: 0, negative: 0 };
+            c.success += rc.success;
+            c.negative += rc.negative;
+            reuseCounts.set(id, c);
+        }
+    }
+    const asmOpts = {
+        ...(opts.candidateLimit ? { limit: opts.candidateLimit } : {}),
+        ...(opts.provenance ? { provenance: opts.provenance } : {}),
+        ...(opts.review ? { review: opts.review } : {}),
+        ...(opts.includeProbation ? { includeProbation: true } : {}),
+        ...(opts.hubCandidates && opts.hubCandidates.length > 0 ? { hubCandidates: opts.hubCandidates } : {}),
+        ...(reuseCounts.size > 0 ? { reuseCounts } : {}),
+    };
+    const { candidates, distilledFallback, antiWarnings } = await assembleSelectionPool(store, signals, asmOpts);
+    return engine.runCycle({
+        cycleId: opts.cycleId,
+        problem: opts.problem,
+        signals,
+        category: opts.category,
+        ...(opts.strategyName !== undefined ? { strategyName: opts.strategyName } : {}),
+        candidates,
+        target: opts.target,
+        expectedEffect: opts.expectedEffect,
+        summary: opts.summary,
+        confidence: opts.confidence,
+        ...(opts.selectionFloor !== undefined ? { selectionFloor: opts.selectionFloor } : {}),
+        ...(opts.forcedGeneId !== undefined ? { forcedGeneId: opts.forcedGeneId } : {}),
+        execute: opts.execute,
+        ...(opts.failureContext !== undefined ? { failureContext: opts.failureContext } : {}),
+        ...(opts.solidifyPermit ? { solidifyPermit: opts.solidifyPermit } : {}),
+        // #97: forward the distilled-gene fallback pool so a no-signal-match cycle reuses a distilled strategy
+        // (instead of a blind innovate) when nothing clears the floor.
+        ...(distilledFallback.length > 0 ? { distilledFallback } : {}),
+        ...(antiWarnings.length > 0 ? { antiWarnings } : {}),
+    });
+}

package/dist/algo/solidify.d.ts

@@ -0,0 +1,43 @@
+import { type Capsule } from '../wire/index.js';
+import type { ProofOfWork } from '../schema/proofOfWork.js';
+export type ResolutionStatus = 'pending' | 'suppressed_observationally' | 'resolved_by_evidence' | 'regressed' | 'inconclusive';
+export interface SolidifyInput {
+    geneId: string;
+    trigger: readonly string[];
+    summary: string;
+    confidence: number;
+    outcome: {
+        status: 'success' | 'failed';
+        score: number;
+    };
+    proofOfWork?: ProofOfWork;
+    /** 是否有强证据(validation/测试在证据下通过). 默认 false → 不自动升级到 resolved. */
+    strongEvidence?: boolean;
+    /** regressed 判定阈: 失败且分低于此 → regressed, 否则 inconclusive. 默认 0.3. */
+    regressThreshold?: number;
+}
+export interface SolidifyResult {
+    capsule: Capsule;
+    resolutionStatus: ResolutionStatus;
+    producedValue: boolean;
+    reasons: string[];
+}
+/** ProofOfWork 是否表明有实际产出(解锁非 coding agent, 批注#17/#19). */
+export declare function proofIndicatesOutput(p?: ProofOfWork): boolean;
+/**
+ * 两级 resolution(M4A-8) + ProofOfWork 判价值(M4A-5):
+ * - 失败: 分 < 阈 → regressed, 否则 inconclusive.
+ * - 成功 + 强证据(proofOfWork 有产出 ∧ strongEvidence) → resolved_by_evidence.
+ * - 成功但仅观测(无证据) → suppressed_observationally.
+ * 默认**不自动**从 suppressed 升级到 resolved(军杰§6).
+ */
+export declare function decideResolution(input: SolidifyInput): {
+    status: ResolutionStatus;
+    producedValue: boolean;
+    reasons: string[];
+};
+/**
+ * solidify: 把执行结果固化成 Capsule(表现型/纯产物). resolution_status/proof_of_work 是 v2-delta
+ * (本地存得下; 发 hub 须先 gep-sdk bump, 由 wire/schemaGate 把关).
+ */
+export declare function solidify(input: SolidifyInput): SolidifyResult;

package/dist/algo/solidify.js

@@ -0,0 +1,63 @@
+import { ulid as makeUlid } from 'ulid';
+import { computeAssetId, SCHEMA_VERSION } from '../wire/index.js';
+/** ProofOfWork 是否表明有实际产出(解锁非 coding agent, 批注#17/#19). */
+export function proofIndicatesOutput(p) {
+    if (!p)
+        return false;
+    switch (p.kind) {
+        case 'git_diff': return (p.gitDiff?.files ?? 0) > 0 || (p.gitDiff?.lines ?? 0) > 0;
+        case 'artifact_hash': return Boolean(p.artifactHash?.sha256);
+        case 'external_receipt': return Boolean(p.externalReceipt?.receiptId);
+        case 'tool_call_trace': return (p.toolCallTrace?.calls ?? 0) > 0;
+        default: return false;
+    }
+}
+/**
+ * 两级 resolution(M4A-8) + ProofOfWork 判价值(M4A-5):
+ * - 失败: 分 < 阈 → regressed, 否则 inconclusive.
+ * - 成功 + 强证据(proofOfWork 有产出 ∧ strongEvidence) → resolved_by_evidence.
+ * - 成功但仅观测(无证据) → suppressed_observationally.
+ * 默认**不自动**从 suppressed 升级到 resolved(军杰§6).
+ */
+export function decideResolution(input) {
+    const reasons = [];
+    const producedValue = proofIndicatesOutput(input.proofOfWork);
+    if (input.outcome.status === 'failed') {
+        const status = input.outcome.score < (input.regressThreshold ?? 0.3) ? 'regressed' : 'inconclusive';
+        reasons.push(`失败 score=${input.outcome.score} → ${status}`);
+        return { status, producedValue, reasons };
+    }
+    if (producedValue && input.strongEvidence) {
+        reasons.push('成功 + ProofOfWork 有产出 + 强证据 → resolved_by_evidence');
+        return { status: 'resolved_by_evidence', producedValue, reasons };
+    }
+    reasons.push(producedValue ? '成功 + 有产出但无强证据 → suppressed_observationally(不自动升级)' : '成功但无 ProofOfWork 产出证据 → suppressed_observationally');
+    return { status: 'suppressed_observationally', producedValue, reasons };
+}
+/**
+ * solidify: 把执行结果固化成 Capsule(表现型/纯产物). resolution_status/proof_of_work 是 v2-delta
+ * (本地存得下; 发 hub 须先 gep-sdk bump, 由 wire/schemaGate 把关).
+ */
+export function solidify(input) {
+    const { status, producedValue, reasons } = decideResolution(input);
+    // blast_radius is only a real measurement for git_diff proofs. For non-git_diff proofs
+    // (artifact_hash/external_receipt/tool_call_trace) gd is undefined and blast falls back to {0,0} — which here
+    // means "blast unknown", NOT "no change". Consumers that read blast=0 as a no-op signal (e.g. cycleFailure's
+    // local_gene_no_blast bucket) MUST first confirm the proof kind is git_diff; the cycleEngine guard does this.
+    const gd = input.proofOfWork?.kind === 'git_diff' ? input.proofOfWork.gitDiff : undefined;
+    const base = {
+        type: 'Capsule',
+        schema_version: SCHEMA_VERSION,
+        id: makeUlid(),
+        trigger: [...input.trigger],
+        gene: input.geneId,
+        summary: input.summary,
+        confidence: input.confidence,
+        blast_radius: { files: gd?.files ?? 0, lines: gd?.lines ?? 0 },
+        outcome: input.outcome,
+        resolution_status: status,
+        ...(input.proofOfWork ? { proof_of_work: input.proofOfWork } : {}),
+    };
+    const asset_id = computeAssetId(base);
+    return { capsule: { ...base, asset_id }, resolutionStatus: status, producedValue, reasons };
+}

package/dist/algo/strategyPresets.d.ts

@@ -0,0 +1,32 @@
+export interface StrategyPreset {
+    name: string;
+    label: string;
+    description: string;
+    /** Target allocation ratios that inform the cycle's intent mix (sum ≈ 1). */
+    repair: number;
+    optimize: number;
+    innovate: number;
+    explore: number;
+    /** Repair ratio over recent cycles that should force innovation to break a repair loop. */
+    repairLoopThreshold: number;
+}
+export declare const STRATEGY_PRESETS: Record<string, StrategyPreset>;
+export declare function strategyNames(): string[];
+export interface ResolveStrategyInput {
+    /** Explicit strategy (e.g. EVOLVE_STRATEGY). Undefined / 'balanced' / 'auto' enable auto-detection. */
+    name?: string;
+    /** Recent signal kinds (for saturation detection). */
+    signals?: readonly string[];
+    /** Current evolution cycle count (for the early-stabilize heuristic). */
+    cycleCount?: number;
+    /** Back-compat: forces 'innovate' when no explicit name is set. */
+    forceInnovation?: boolean;
+}
+/**
+ * Resolve the active strategy preset. Explicit name wins (unknown → balanced). Otherwise auto-detect:
+ * first 1-5 cycles → early-stabilize; an innovate-pivot meta-signal (repair loop / high failure ratio) →
+ * innovate; a saturation signal → steady-state (overrides both); forceInnovation → innovate. This is where
+ * the history-derived meta-signals (see signals/metaSignals.ts) actually drive strategy adaptation.
+ * Pure — no env/fs reads (the caller supplies the inputs).
+ */
+export declare function resolveStrategy(input?: ResolveStrategyInput): StrategyPreset;

package/dist/algo/strategyPresets.js

@@ -0,0 +1,61 @@
+// Evolution strategy presets (ported from v1 gep/strategy.js). An operator-selectable POSTURE that biases the
+// repair/optimize/innovate/explore mix for a cycle — "harden after a big change", "repair-only emergency",
+// "innovate when stable" — plus a repair-loop threshold. resolveStrategy is pure + fully input-driven (the
+// caller supplies the chosen name, recent signals, and cycle count from env/state); auto-detection picks
+// early-stabilize for the first few cycles and steady-state when saturation signals appear.
+export const STRATEGY_PRESETS = {
+    balanced: { name: 'balanced', label: 'Balanced', description: 'Normal operation. Steady growth with stability.', repair: 0.2, optimize: 0.2, innovate: 0.5, explore: 0.1, repairLoopThreshold: 0.5 },
+    innovate: { name: 'innovate', label: 'Innovation Focus', description: 'System is stable. Maximize new features and capabilities.', repair: 0.05, optimize: 0.1, innovate: 0.8, explore: 0.05, repairLoopThreshold: 0.3 },
+    harden: { name: 'harden', label: 'Hardening', description: 'After a big change. Focus on stability and robustness.', repair: 0.4, optimize: 0.35, innovate: 0.2, explore: 0.05, repairLoopThreshold: 0.7 },
+    'repair-only': { name: 'repair-only', label: 'Repair Only', description: 'Emergency. Fix everything before doing anything else.', repair: 0.8, optimize: 0.18, innovate: 0.0, explore: 0.02, repairLoopThreshold: 1.0 },
+    'early-stabilize': { name: 'early-stabilize', label: 'Early Stabilization', description: 'First cycles. Prioritize fixing existing issues before innovating.', repair: 0.6, optimize: 0.22, innovate: 0.15, explore: 0.03, repairLoopThreshold: 0.8 },
+    'steady-state': { name: 'steady-state', label: 'Steady State', description: 'Evolution saturated. Maintain existing capabilities. Explore for new directions.', repair: 0.55, optimize: 0.25, innovate: 0.05, explore: 0.15, repairLoopThreshold: 0.9 },
+};
+export function strategyNames() {
+    return Object.keys(STRATEGY_PRESETS);
+}
+/** Saturation meta-signals that switch auto-detection to steady-state (graceful degradation). */
+const SATURATION_SIGNALS = new Set(['force_steady_state', 'evolution_saturation']);
+/**
+ * Meta-signals that mean "stuck repairing / failing — break out by innovating" (ported from v1 strategy.js
+ * intent: a repair loop or a high failure ratio should pivot the posture off repair toward new directions).
+ * Saturation takes precedence (it wins when both are present, matching v1's steady-state-on-saturation rule).
+ */
+const INNOVATE_PIVOT_SIGNALS = new Set([
+    'repair_loop_detected',
+    'force_innovation_after_repair_loop',
+    'high_failure_ratio',
+]);
+/**
+ * Resolve the active strategy preset. Explicit name wins (unknown → balanced). Otherwise auto-detect:
+ * first 1-5 cycles → early-stabilize; an innovate-pivot meta-signal (repair loop / high failure ratio) →
+ * innovate; a saturation signal → steady-state (overrides both); forceInnovation → innovate. This is where
+ * the history-derived meta-signals (see signals/metaSignals.ts) actually drive strategy adaptation.
+ * Pure — no env/fs reads (the caller supplies the inputs).
+ */
+export function resolveStrategy(input = {}) {
+    const explicit = typeof input.name === 'string' && input.name.trim() !== '';
+    let name = (explicit ? input.name : 'balanced').toLowerCase().trim();
+    let forceInnovation = false;
+    if (!explicit && input.forceInnovation) {
+        name = 'innovate';
+        forceInnovation = true;
+    }
+    const isDefault = !explicit || name === 'balanced' || name === 'auto';
+    if (isDefault && !forceInnovation) {
+        const signals = input.signals ?? [];
+        const cycleCount = input.cycleCount ?? 0;
+        if (cycleCount > 0 && cycleCount <= 5)
+            name = 'early-stabilize';
+        // Stuck repairing / failing → pivot to innovate to break the loop (v1 strategy.js intent).
+        if (signals.some((s) => INNOVATE_PIVOT_SIGNALS.has(s)))
+            name = 'innovate';
+        // Saturation → steady-state. Last so it overrides early-stabilize AND the innovate pivot:
+        // when the loop has exhausted its innovation space, hardening/maintenance beats more innovation.
+        if (signals.some((s) => SATURATION_SIGNALS.has(s)))
+            name = 'steady-state';
+    }
+    if (name === 'auto')
+        name = 'balanced';
+    return STRATEGY_PRESETS[name] ?? STRATEGY_PRESETS['balanced'];
+}

package/dist/assetstore/index.d.ts

@@ -0,0 +1,8 @@
+export * from './provider.js';
+export * from './localJsonl.js';
+export * from './remoteStub.js';
+export * from './learningHistory.js';
+export * from './provenance.js';
+export * from './reviewLedger.js';
+export * from './reviewFilter.js';
+export * from './pendingSignals.js';