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

package/dist/algo/candidateAssembly.d.ts

@@ -5,6 +5,8 @@ import type { ReviewLedger } from '../assetstore/reviewLedger.js';
 import type { AntiWarning, GeneCandidateInput } from './geneSelection.js';
 export interface AssembleOptions {
     limit?: number;
+    /** Build the bounded trusted pre-admission corpus used by semantic IDF. Default true. */
+    includeSemanticCorpus?: boolean;
     provenance?: ProvenanceStore;
     includeUntrusted?: boolean;
     review?: ReviewLedger;
@@ -39,10 +41,13 @@ export interface SelectionPool {
     /**
      * Distilled genes that passed the trust/review/ban gates but do NOT match the live signals. Surfaced
      * separately (NOT in `candidates`, so they never compete in normal scoring) for the v1 #97 fallback: when no
-     * candidate clears the floor, selection reuses one of these broadly-applicable distilled strategies instead of
-     * falling through to a blind innovate. Kept lightweight (no learning-history aggregation) — picked first-match.
+     * normal selection has no reusable positive choice, selection reuses one of these broadly-applicable distilled
+     * strategies instead of falling through to a blind innovate. Kept lightweight (no learning-history aggregation)
+     * — picked first-match.
      */
     distilledFallback: GeneCandidateInput[];
+    /** Trust-filtered library documents captured before live-signal relevance admission. */
+    semanticCorpus: GeneCandidateInput[];
     /**
      * Matched AntiGene guardrails for the live signals. This list is advisory-only and is kept out of candidates and
      * distilledFallback so negative memory cannot be selected as a strategy.

package/dist/algo/candidateAssembly.js

@@ -1,8 +1,10 @@
 import { aggregateLearningHistory } from '../assetstore/learningHistory.js';
 import { reuseSentiment } from '../ops/reuseOutcomes.js';
-import { tagOverlapScore } from '../signals/expand.js';
+import { expandSignals, geneTags, tagOverlapScore, } from '../signals/expand.js';
+import { withoutTaskDomainSignals } from '../signals/taskDomain.js';
 import { bannedGenesFromFailures } from './bans.js';
 import { geneGenerationSource } from './geneIntake.js';
+const SEMANTIC_CORPUS_LIMIT = 1_000;
 function asStrings(v) {
     return Array.isArray(v) ? v.filter((x) => typeof x === 'string') : [];
 }
@@ -59,6 +61,8 @@ function combinedReuseSentiment(map, ...ids) {
 }
 /** Genes banned by repeated signal-matched failures (>=2 failed capsules covering the signals). */
 async function computeBans(store, signals, limit) {
+    if (signals.length === 0)
+        return new Set();
     const caps = await store.search({ kind: 'Capsule', signalsAny: [...signals], limit });
     const failures = caps
         .filter((c) => c['outcome']?.status === 'failed')
@@ -68,6 +72,24 @@ async function computeBans(store, signals, limit) {
     }));
     return bannedGenesFromFailures(failures, signals);
 }
+const GENERIC_NAMESPACE_TAGS = new Set(['action', 'area', 'problem', 'risk', 'signal']);
+// Generic namespace tags and inferred action/signal subtypes are too broad to admit a candidate by themselves.
+function hasSelectionAdmissionEvidence(liveSignals, gene) {
+    const tags = new Set(geneTags(gene));
+    const triggerTags = new Set(expandSignals(gene.signalsMatch ?? []));
+    const categoryActionTag = gene.category ? `action:${gene.category.toLowerCase()}` : undefined;
+    if (liveSignals.some((signal) => ((triggerTags.has(signal) || signal === categoryActionTag)
+        && !GENERIC_NAMESPACE_TAGS.has(signal)))) {
+        return true;
+    }
+    const liveTags = expandSignals(liveSignals);
+    if (liveTags.some((tag) => (tags.has(tag)
+        && (tag.startsWith('problem:')
+            || tag.startsWith('area:')
+            || tag.startsWith('risk:')))))
+        return true;
+    return liveTags.some((tag) => tag.startsWith('signal:') && triggerTags.has(tag));
+}
 /**
  * Assemble the full selection pool from the store for the given signals: the relevant scored candidates AND the
  * distilled-gene fallback pool, in a single pass over the gene list (one store.list + one ban computation). A gene
@@ -77,18 +99,33 @@ async function computeBans(store, signals, limit) {
  */
 export async function assembleSelectionPool(store, signals, opts = {}) {
     const limit = opts.limit ?? 500;
-    const genes = await store.list('Gene', limit);
-    const banned = await computeBans(store, signals, limit);
-    const sigSet = new Set(signals);
+    const includeSemanticCorpus = opts.includeSemanticCorpus !== false;
+    const scanLimit = includeSemanticCorpus ? Math.max(limit, SEMANTIC_CORPUS_LIMIT) : limit;
+    const genes = await store.list('Gene', scanLimit);
+    const matchingSignals = withoutTaskDomainSignals(signals);
+    const banned = await computeBans(store, matchingSignals, limit);
+    const sigSet = new Set(matchingSignals);
     const provenance = opts.provenance?.snapshot();
     const review = opts.review?.snapshot();
     const out = [];
     const distilledFallback = [];
+    const semanticCorpus = [];
+    const semanticIdentities = new Set();
+    const addSemanticCandidate = (candidate) => {
+        if (!includeSemanticCorpus || semanticCorpus.length >= SEMANTIC_CORPUS_LIMIT)
+            return;
+        const identity = candidate.assetId ?? candidate.geneId;
+        if (semanticIdentities.has(identity))
+            return;
+        semanticIdentities.add(identity);
+        semanticCorpus.push(candidate);
+    };
     const antiWarnings = [];
-    for (const g of genes) {
+    for (const [geneIndex, g] of genes.entries()) {
+        const provenanceRecord = provenance?.get(String(g.asset_id));
         // Trust-first (#30): untrusted (e.g. hub-ingested) genes are excluded from the candidate pool by default;
         // they enter only with includeUntrusted or after an explicit promotion. Provenance is keyed by asset_id.
-        if (opts.provenance && !opts.includeUntrusted && provenance?.get(String(g.asset_id))?.trusted === false)
+        if (opts.provenance && !opts.includeUntrusted && provenanceRecord?.trusted === false)
             continue;
         // Review-first (#89/#91): auto-distilled drafts land quarantined until a human approves; rejected drafts stay
         // out too. No record → eligible (cycle/migrate genes). Symmetric to the provenance trust-first filter above.
@@ -103,10 +140,26 @@ export async function assembleSelectionPool(store, signals, opts = {}) {
         if (isBannedCandidate(banned, geneId, assetId))
             continue; // repeated signal-matched failures → not a candidate (nor a fallback)
         const signalsMatch = asStrings(g['signals_match']);
+        const matchingSignalsForGene = withoutTaskDomainSignals(signalsMatch);
         const category = typeof g['category'] === 'string' ? String(g['category']) : undefined;
         const summary = typeof g['summary'] === 'string' ? String(g['summary']) : undefined;
-        const literal = signalsMatch.some((m) => sigSet.has(m));
-        const relevant = literal || tagOverlapScore(signals, { signalsMatch, geneId, category, summary }) > 0;
+        const literal = matchingSignalsForGene.some((m) => sigSet.has(m));
+        const tagInput = { signalsMatch: matchingSignalsForGene, geneId, category, summary };
+        // Experimental probation and explicitly untrusted records may be selectable by opt-in, but never shape global
+        // document frequency. Only trusted, approved/legacy-local records enter the pre-admission semantic corpus.
+        if (provenanceRecord?.trusted !== false && (reviewRecord === undefined || reviewRecord.state === 'approved')) {
+            addSemanticCandidate({
+                geneId,
+                assetId,
+                signalsMatch,
+                view: emptyLearningView(geneId),
+                ...(category ? { category } : {}),
+                ...(summary ? { summary } : {}),
+            });
+        }
+        if (geneIndex >= limit)
+            continue;
+        const relevant = literal || hasSelectionAdmissionEvidence(matchingSignals, tagInput);
         if (!relevant) {
             // #97: a trusted, approved, non-banned distilled (or evolved) gene that doesn't match the live signals is not
             // a normal candidate, but it IS eligible as a last-resort fallback (selection uses it only when nothing clears
@@ -129,6 +182,8 @@ export async function assembleSelectionPool(store, signals, opts = {}) {
             continue;
         }
         const view = await aggregateLearningHistory(store, geneId);
+        const explorationEligible = provenanceRecord?.trusted !== false
+            && (reviewRecord === undefined || reviewRecord.state === 'approved');
         // #268 Bugbot: reuse events key by assetId, which may be the content asset_id (sha256:…) OR the logical id —
         // candidates key by the logical geneId. Look the sentiment up by BOTH so the soft re-order actually matches
         // regardless of which form the reuse-result carried (recall's resolveGene accepts both for the same reason).
@@ -144,25 +199,34 @@ export async function assembleSelectionPool(store, signals, opts = {}) {
             ...(category ? { category } : {}),
             ...(summary ? { summary } : {}),
             ...(reuseAdjustVal !== undefined ? { reuseAdjust: reuseAdjustVal } : {}),
+            explorationEligible,
         });
     }
     // #110: merge hub reuse candidates into the same pool, trust-first — local (trusted) genes win on a
     // geneId collision, and a hub candidate banned by repeated signal-matched failures stays out too.
     if (opts.hubCandidates && opts.hubCandidates.length > 0) {
         const localIds = new Set(out.map((c) => c.geneId));
+        const localAssetIds = new Set(out.map((c) => c.assetId).filter((id) => id !== undefined));
         for (const h of opts.hubCandidates) {
             if (!passesInjectedCandidateGates(h, opts, provenance, review))
                 continue;
             if (localIds.has(h.geneId))
                 continue; // a trusted local gene already covers this id
+            if (h.assetId && localAssetIds.has(h.assetId))
+                continue; // the same content identity is already local/trusted
             if (isBannedCandidate(banned, h.geneId, h.assetId))
                 continue;
             // Stamp the reuse sentiment onto a hub candidate too (only when it didn't carry one), matched by its geneId
             // OR its asset_id — symmetric with local genes, so a map keyed like reuse events (often sha256:…) still hits
             // (#268 Bugbot). A hub candidate that exposes neither matching id is simply left unstamped.
             const hubAdj = h.reuseAdjust === undefined ? combinedReuseSentiment(opts.reuseCounts, h.geneId, h.assetId) : undefined;
-            out.push(hubAdj !== undefined ? { ...h, reuseAdjust: hubAdj } : h);
+            // A transient Hub candidate must never self-assert active-bandit cold-start eligibility. It still competes
+            // under the existing base score and legacy drift; UCB1 fails safe for a mixed window.
+            const guarded = { ...h, explorationEligible: false };
+            out.push(hubAdj !== undefined ? { ...guarded, reuseAdjust: hubAdj } : guarded);
             localIds.add(h.geneId);
+            if (h.assetId)
+                localAssetIds.add(h.assetId);
         }
     }
     for (const a of await store.list('AntiGene', limit)) {
@@ -177,8 +241,10 @@ export async function assembleSelectionPool(store, signals, opts = {}) {
             continue;
         const antiGeneId = stringField(a['id']) ?? String(a.asset_id);
         const summary = stringField(a['summary']);
-        const relevant = trigger.some((m) => sigSet.has(m))
-            || tagOverlapScore(signals, { signalsMatch: trigger, geneId: antiGeneId, summary }) > 0;
+        const matchingTrigger = withoutTaskDomainSignals(trigger);
+        // This is a safety inclusion gate: ubiquitous evidence must still emit warnings.
+        const relevant = matchingTrigger.some((m) => sigSet.has(m))
+            || tagOverlapScore(matchingSignals, { signalsMatch: matchingTrigger, geneId: antiGeneId, summary }) > 0;
         if (!relevant)
             continue;
         const severity = severityOf(a['severity']);
@@ -193,7 +259,7 @@ export async function assembleSelectionPool(store, signals, opts = {}) {
             ...(rationale ? { rationale } : {}),
         });
     }
-    return { candidates: out, distilledFallback, antiWarnings };
+    return { candidates: out, distilledFallback, semanticCorpus, antiWarnings };
 }
 /**
  * Assemble selection candidates from the store for the given signals (the relevant scored set only).
@@ -201,5 +267,7 @@ export async function assembleSelectionPool(store, signals, opts = {}) {
  * distilled-gene fallback pool.
  */
 export async function assembleCandidates(store, signals, opts = {}) {
-    return (await assembleSelectionPool(store, signals, opts)).candidates;
+    // This compatibility wrapper discards semanticCorpus, so preserve its legacy I/O bound instead of scanning
+    // 1,000 records for data the caller cannot consume.
+    return (await assembleSelectionPool(store, signals, { ...opts, includeSemanticCorpus: false })).candidates;
 }

package/dist/algo/capabilityCandidates.js

@@ -20,6 +20,16 @@ const SIGNAL_CANDIDATES = [
     { signal: 'capability_gap', title: 'Fill capability gap' },
     { signal: 'stable_success_plateau', title: 'Explore new strategies during stability plateau' },
     { signal: 'external_opportunity', title: 'Evaluate external A2A asset for local adoption' },
+    // Harness context-budget family (v1 context-compression gene family port). v2 ships no seed-gene catalog, so
+    // the reusable strategies arrive as ADVISORY candidates the runtime may distill into genes — one per bloat
+    // source, because a single "shorten the prompt" proposal loses the distinction that decides what is safe to
+    // drop (an always-on tool schema is lazy-loadable; an approval gate is not).
+    { signal: 'prompt_budget_measurement', title: 'Measure the prompt budget per source before compressing context' },
+    { signal: 'context_explosion', title: 'Attribute a context-window overflow to its largest prompt source' },
+    { signal: 'tool_schema_bloat', title: 'Load exact tool/MCP schemas from the runtime loader instead of always-on prompt text' },
+    { signal: 'skill_list_bloat', title: 'Compress skill and agent-type descriptions into selectable route cards' },
+    { signal: 'transcript_context_bloat', title: 'Compress a pasted transcript into a session handoff packet' },
+    { signal: 'memory_index_budget', title: 'Keep the memory index lean and rely on relevance recall for detail' },
 ];
 /** Highest → lowest priority problem class used to pick a failure cluster's grouping key (ported v1). */
 const PROBLEM_PRIORITY = ['problem:performance', 'problem:protocol', 'problem:reliability', 'problem:stagnation', 'problem:capability'];

package/dist/algo/cycleEngine.d.ts

@@ -4,13 +4,14 @@ import type { GepCategory, Mutation, Capsule, EvolutionEvent } from '../wire/ind
 import type { AssetStoreProvider } from '../assetstore/provider.js';
 import type { StrategyPoint } from '../strategy/strategyPoint.js';
 import { type CycleStage } from '../cycle/stateMachine.js';
-import { type GeneDecision, type SelectionInput, type GeneCandidateInput, type AntiWarning } from './geneSelection.js';
+import { type GeneDecision, type SelectionInput, type GeneCandidateInput, type AntiWarning, type SelectionGuardMode } from './geneSelection.js';
 import { type EnvFingerprint } from '../bootstrap/envFingerprint.js';
 import type { PersonalityStore } from '../personality/store.js';
 import { type ResolutionStatus } from './solidify.js';
 import type { ProofOfWork } from '../schema/proofOfWork.js';
 import { type ClassifyRecentEvent } from './cycleFailureClassifier.js';
 import type { MemoryGraphGeneEvidence } from './memoryGraph.js';
+import { type SelectionPolicy } from './ucb1.js';
 export interface TriggerEval {
     trigger: boolean;
     reasons: string[];
@@ -66,6 +67,8 @@ export interface CycleEngineDeps {
     rng?: () => number;
     /** Injected environment fingerprint (deterministic tests). Defaults to capturing the real runtime env. */
     envFingerprint?: () => EnvFingerprint;
+    /** Latest external capability gaps. Composition owns persistence/wire details; core reads one bounded snapshot. */
+    capabilityGaps?: () => readonly string[];
     /** 触发评估(常注入 TriggerEngine.evaluate 的包装; 缺省=直接触发). */
     trigger?: (p: ProblemPattern, now: number) => Promise<TriggerEval> | TriggerEval;
     /** 可进化人格(可选). 注入后, 每轮:
@@ -82,10 +85,20 @@ export interface CycleInput {
     cycleId: string;
     problem: ProblemPattern;
     signals: readonly string[];
+    /** Curriculum targets already prepared before candidate assembly. Omit for direct runCycle callers. */
+    curriculumSignals?: readonly string[];
     category: GepCategory;
     /** Optional explicit strategy preset name; when set, it wins over history-derived meta-signal auto-detection. */
     strategyName?: string;
     candidates: readonly GeneCandidateInput[];
+    /** Trust-filtered library corpus captured before relevance admission for stable semantic IDF. */
+    semanticCorpus?: readonly GeneCandidateInput[];
+    /** Emergency rollback: use the pre-IDF semantic scorer for this cycle. */
+    disableSemanticIdf?: boolean;
+    /** Experimental plateau selection policy. Default preserves engine-health + legacy random drift. */
+    selectionPolicy?: SelectionPolicy;
+    /** Versioned relevance-guard rollout. Omit for legacy direct-call behavior. */
+    selectionGuard?: SelectionGuardMode;
     selectionFloor?: number;
     /**
      * Explicit GEP/runtime-selected gene. Forwarded after candidate assembly and local hard filters, so it cannot
@@ -102,7 +115,7 @@ export interface CycleInput {
     /**
      * Distilled-gene fallback pool (ported from v1 #97): broadly-applicable distilled genes that do NOT match the
      * live signals, assembled (trust/review/ban-filtered) upstream. Forwarded to selection, which uses one only as a
-     * last resort when no candidate clears the floor — reusing a known distilled strategy instead of a blind innovate.
+     * last resort when normal selection has no reusable positive choice — reusing a known distilled strategy instead of a blind innovate.
      */
     distilledFallback?: readonly GeneCandidateInput[];
     /** Advisory-only AntiGene warnings matched upstream for this cycle's base signals. */
@@ -150,5 +163,13 @@ export interface CycleResult {
 export declare class CycleEngine {
     private readonly deps;
     constructor(deps: CycleEngineDeps);
+    /**
+     * 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: readonly string[]): {
+        signals: string[];
+        curriculumSignals: string[];
+    };
     runCycle(input: CycleInput): Promise<CycleResult>;
 }