@evomap/evolver-core 2.0.0-beta.0

package/dist/signals/expand.js

@@ -0,0 +1,125 @@
+// Signal expansion & tag classification (ported from v1 src/gep/learningSignals.js).
+// Raw signals (e.g. '429') are expanded into broader semantic tags (e.g. 'problem:reliability',
+// 'action:repair') so gene selection can match by MEANING, not just literal string intersection —
+// closing the recall gap where a '429' signal could not reach a gene tagged for 'repair'.
+// Regex → semantic tags. A rule fires if its pattern matches anywhere in the lowercased signal text.
+// The reliability / protocol / performance / capability families also carry CN/JA/KO synonyms so a
+// non-Latin signal ('错误' / 'エラー' / '오류') expands to the same tags an English one would and can
+// reach an English-keyworded gene through tagOverlapScore. This is the v2-native port of v1 #99's
+// multilingual signals_match aliases: v1 attached `|`-pipe synonyms to shipped seed genes, but v2 has
+// no seed-gene catalog and no pipe-alias parsing — its expansion rules ARE the shared signal vocabulary.
+const EXPANSION_RULES = [
+    { re: /(error|exception|failed|unstable|log_error|runtime|429|错误|异常|エラー|오류|例外|예외|失败|失敗|실패|不稳定|不安定|불안정)/, tags: ['problem:reliability', 'action:repair'] },
+    // Korean 감사 alone is a homograph (audit == "thank you"), so it is matched only via compounds / audit-context
+    // phrases (감사로그 / 감사추적 / 감사 로그 / 감사 추적 / 코드 감사) — never bare 감사, so benign gratitude text like
+    // '감사합니다' cannot fire. Bare CN 提示 (= hint/notice) is likewise omitted; only the unambiguous 提示词 (= prompt)
+    // is matched. The 'reusable' cluster (可复用 / 再利用 / 재사용) recalls the optimize/protocol family (v1 #99).
+    { re: /(protocol|prompt|audit|gep|schema|drift|reusable|协议|プロトコル|프로토콜|提示词|プロンプト|프롬프트|审计|監査|可复用|再利用|재사용|감사로그|감사추적|감사 로그|감사 추적|코드 감사)/, tags: ['problem:protocol', 'action:optimize', 'area:prompt'] },
+    { re: /(perf|performance|bottleneck|latency|slow|throughput|性能|瓶颈|パフォーマンス|성능|병목)/, tags: ['problem:performance', 'action:optimize'] },
+    // 功能/機能/기능 alone are too broad: as unanchored substrings they match the malfunction vocabulary
+    // (機能不全 / 기능장애 / 功能障碍), which are reliability problems — use the v1 #99 feature-request compounds.
+    { re: /(feature|capability_gap|user_feature_request|external_opportunity|stagnation recommendation|功能请求|機能リクエスト|기능요청|能力缺口|機能ギャップ|역량공백|改进建议|改善提案|개선제안|外部机会|外部機会|외부기회)/, tags: ['problem:capability', 'action:innovate'] },
+    { re: /(stagnation|plateau|steady_state|saturation|empty_cycle_loop|loop_detected|recurring)/, tags: ['problem:stagnation', 'action:innovate'] },
+    { re: /(task|worker|heartbeat|hub|commitment|assignment|orchestration)/, tags: ['area:orchestration'] },
+    // Tool-integrity (ported from v1 #99 gene_tool_integrity): bypassing a registered tool or looping on raw
+    // shell is an orchestration-discipline / validation risk. CN/JA/KO aliases included for recall parity.
+    { re: /(tool_bypass|tool_loop|工具绕过|工具循环|ツール迂回|ツールループ|도구우회|도구반복)/, tags: ['area:orchestration', 'risk:validation'] },
+    { re: /(memory|narrative|reflection)/, tags: ['area:memory'] },
+    { re: /(skill|dashboard)/, tags: ['area:skills'] },
+    { re: /(validation|canary|rollback|constraint|blast radius|destructive)/, tags: ['risk:validation'] },
+];
+/**
+ * Expand a signal list into literal signals + namespace prefixes + semantic category tags.
+ * e.g. ['429', 'auth:token'] → ['429', 'auth:token', 'auth', 'problem:reliability', 'action:repair'].
+ */
+export function expandSignals(signals, extraText = '') {
+    const tags = new Set();
+    for (const s of signals) {
+        const str = String(s);
+        tags.add(str);
+        const base = str.split(':')[0];
+        if (base && base !== str)
+            tags.add(base); // namespace prefix (e.g. 'auth:token' → 'auth')
+    }
+    const text = (signals.join(' ') + ' ' + extraText).toLowerCase().normalize('NFKC');
+    for (const rule of EXPANSION_RULES) {
+        if (rule.re.test(text))
+            for (const t of rule.tags)
+                tags.add(t);
+    }
+    return [...tags];
+}
+/**
+ * Tokenize free text into a lowercased bag of words (letter/number runs of length >= 2).
+ * Unicode-aware (`\p{L}\p{N}`): a Latin-only `[^a-z0-9]+` split silently dropped CJK / Cyrillic /
+ * Arabic content, so CN/JA/KO signals like '错误' / 'タスク失敗' / '오류' tokenized to [] and the
+ * {@link bagCosine} recall path scored 0 on every cycle for non-Latin users (ported from v1 #99,
+ * which fixed the same Latin-only regex in selector.tokenize). Lowercased then NFKC-normalized before splitting (the established house idiom in
+ * signatures.ts), so full-width / half-width IME forms ('４２９' / 'ＥＲＲＯＲ' / 'ｴﾗｰ') fold to the
+ * normal forms the rules and gene text already use, and punctuation/symbols are stripped so
+ * 'error.' and 'error' tokenize identically.
+ */
+function tokenize(text) {
+    return text.toLowerCase().normalize('NFKC').split(/[^\p{L}\p{N}]+/u).filter((t) => t.length >= 2);
+}
+/**
+ * Bag-of-words cosine similarity (0..1) between two free-text strings (ported from v1 scoreGeneSemantic).
+ * Term-frequency vectors, cosine of the angle. Returns 0 when either side has no tokens or they share none.
+ * This is the lexical-similarity recall path that complements {@link tagOverlapScore}'s curated tags:
+ * a signal 'timeout_slow' and a gene summarized "fix the slow timeout" share the 'timeout'/'slow' tokens
+ * even when neither the literal signal nor the expansion rules connect them.
+ */
+export function bagCosine(a, b) {
+    const av = new Map();
+    const bv = new Map();
+    for (const t of tokenize(a))
+        av.set(t, (av.get(t) ?? 0) + 1);
+    for (const t of tokenize(b))
+        bv.set(t, (bv.get(t) ?? 0) + 1);
+    if (av.size === 0 || bv.size === 0)
+        return 0;
+    let dot = 0;
+    for (const [t, c] of av)
+        dot += c * (bv.get(t) ?? 0);
+    if (dot === 0)
+        return 0;
+    const mag = (m) => Math.sqrt([...m.values()].reduce((s, c) => s + c * c, 0));
+    return dot / (mag(av) * mag(bv));
+}
+/** Expand a gene's category + signals_match + id + summary into its semantic tag set. */
+export function geneTags(gene) {
+    const inputs = [];
+    if (gene.category)
+        inputs.push('action:' + gene.category.toLowerCase());
+    if (gene.signalsMatch)
+        inputs.push(...gene.signalsMatch);
+    if (gene.geneId)
+        inputs.push(gene.geneId);
+    if (gene.summary)
+        inputs.push(gene.summary);
+    return expandSignals(inputs, '');
+}
+/**
+ * Semantic tag overlap (0..1): fraction of the expanded SIGNAL tags that the gene's expanded tags cover.
+ * Normalized on the signal (query) side so a gene with a long id/summary is not penalized by noise.
+ * This is the recall component: '429' and a gene tagged 'error'/'repair' both expand to
+ * 'problem:reliability'/'action:repair', so they overlap even with zero literal string match.
+ *
+ * Known v1→v2 fidelity delta: a lone non-Latin signal caps near ~2/3 here — its raw token ('错误') is in the
+ * signal tag-set but never on the English-keyworded gene side, while an exact English signal short-circuits to
+ * literal=1.0 upstream in expandedMatchScore. v1 #99 gave CJK full literal credit via pipe-aliases; v2 reaches
+ * the right gene at ~2/3 strength. Lifting this to parity is a scoring-design change beyond this signal port.
+ */
+export function tagOverlapScore(signals, gene) {
+    const sigTags = expandSignals(signals);
+    if (sigTags.length === 0)
+        return 0;
+    const geneTagSet = new Set(geneTags(gene));
+    if (geneTagSet.size === 0)
+        return 0;
+    let hits = 0;
+    for (const t of sigTags)
+        if (geneTagSet.has(t))
+            hits++;
+    return hits / sigTags.length;
+}

package/dist/signals/extractor.d.ts

@@ -0,0 +1,25 @@
+/** 信号源的最小结构(结构化匹配 runtime-adapters 的 NormalizedTurn; core 不跨包依赖, 守边界). */
+export interface SignalSourceTurn {
+    text?: string;
+    toolName?: string;
+    toolResult?: string;
+    errorMessage?: string;
+    isMeta?: boolean;
+}
+/** 信号强度三条腿(批注#13): strong=零成本结构化判断 / agent=自标记 / weak=需 LLM 分析. */
+export type SignalStrength = 'strong' | 'agent' | 'weak';
+export interface ExtractedSignal {
+    id: string;
+    strength: SignalStrength;
+    kind: string;
+    text: string;
+    toolName?: string;
+    needsAnalysis: boolean;
+}
+/** Whether a candidate signal text is harness-coordination noise rather than a real engineering problem. */
+export declare function isHarnessNoise(text: string): boolean;
+/**
+ * 从 tool_use/tool_result/assistant 文本提取信号(M4A-2). **不读文件内容**, 只看 tool 事件+文本(批注#7/#11).
+ * 三条腿: tool 错误结果/显式 Error=strong; agent 标记=agent; 困难措辞无结构=weak(defer LLM).
+ */
+export declare function extractSignals(turns: readonly SignalSourceTurn[]): ExtractedSignal[];

package/dist/signals/extractor.js

@@ -0,0 +1,57 @@
+import { ulid as makeUlid } from 'ulid';
+/** agent 显式信号标记(第三条腿; 与 evolver 显式信号注入旁枝呼应). */
+const AGENT_MARKERS = [/\bEVOLVE_SIGNAL:\s*(.+)/i, /\[SIGNAL\]\s*(.+)/i];
+/** 结构化强信号: 栈/退出码/显式 Error — 零成本判断, 不动 LLM. */
+const STRONG_TEXT = /(^|\n)\s*(Error:|Traceback|Exception|FAILED|panic:|\bexit code [1-9])/;
+/** 弱信号: 表达困难但无结构, 需 LLM 拼语境. */
+const DIFFICULTY = /(无法|失败|搞不定|stuck|can'?t|unable to|not working|报错|卡住)/i;
+/**
+ * Harness-coordination noise — agent/tool mechanics, NOT engineering problems to evolve genes for.
+ * Observation showed these dominate the "strong" leg (tool errors) and drown out real problems: the agent
+ * re-reads a stale file, a string-replace misses, a permission is declined, a request aborts. Dropping them
+ * keeps the signal corpus about the environment's *engineering* problems, not the harness's own retry chatter.
+ */
+const HARNESS_NOISE = /(tool_use_error|has not been read yet|has been modified since|modified since read|String to replace not found|old_string|InputValidationError|permission denied by user|user doesn't want|Request was aborted|operation was aborted|File has not been read)/i;
+/** Whether a candidate signal text is harness-coordination noise rather than a real engineering problem. */
+export function isHarnessNoise(text) {
+    return HARNESS_NOISE.test(text);
+}
+/**
+ * 从 tool_use/tool_result/assistant 文本提取信号(M4A-2). **不读文件内容**, 只看 tool 事件+文本(批注#7/#11).
+ * 三条腿: tool 错误结果/显式 Error=strong; agent 标记=agent; 困难措辞无结构=weak(defer LLM).
+ */
+export function extractSignals(turns) {
+    const out = [];
+    for (const t of turns) {
+        if (t.isMeta)
+            continue;
+        // 腿1 strong: tool_result 报错(is_error) — 但先滤掉 harness 协调噪声(不是工程问题)
+        if (t.errorMessage) {
+            if (!isHarnessNoise(t.errorMessage)) {
+                out.push({ id: makeUlid(), strength: 'strong', kind: 'error_result', text: t.errorMessage.slice(0, 2000), ...(t.toolName ? { toolName: t.toolName } : {}), needsAnalysis: false });
+            }
+            continue;
+        }
+        const text = t.text ?? '';
+        if (!text.trim())
+            continue;
+        // 腿3 agent: 显式标记
+        const marker = AGENT_MARKERS.map((re) => text.match(re)).find(Boolean);
+        if (marker) {
+            out.push({ id: makeUlid(), strength: 'agent', kind: 'agent_marked', text: (marker[1] ?? text).trim().slice(0, 2000), needsAnalysis: false });
+            continue;
+        }
+        // 腿1 strong: 结构化 Error 文本(同样滤掉 harness 噪声)
+        if (STRONG_TEXT.test(text)) {
+            if (!isHarnessNoise(text)) {
+                out.push({ id: makeUlid(), strength: 'strong', kind: 'structured_error', text: text.slice(0, 2000), needsAnalysis: false });
+            }
+            continue;
+        }
+        // 腿2 weak: 困难措辞无结构 → 交 LLM
+        if (DIFFICULTY.test(text)) {
+            out.push({ id: makeUlid(), strength: 'weak', kind: 'difficulty', text: text.slice(0, 2000), needsAnalysis: true });
+        }
+    }
+    return out;
+}

package/dist/signals/index.d.ts

@@ -0,0 +1,6 @@
+export * from './extractor.js';
+export * from './signalGate.js';
+export * from './expand.js';
+export * from './traceSignals.js';
+export * from './metaSignals.js';
+export * from './cycleHistoryFromEvents.js';

package/dist/signals/index.js

@@ -0,0 +1,6 @@
+export * from './extractor.js';
+export * from './signalGate.js';
+export * from './expand.js';
+export * from './traceSignals.js';
+export * from './metaSignals.js';
+export * from './cycleHistoryFromEvents.js';

package/dist/signals/metaSignals.d.ts

@@ -0,0 +1,57 @@
+/** Counters describing the recent shape of the evolution loop, mirroring v1 analyzeRecentHistory. */
+export interface CycleHistory {
+    /** Trailing run of consecutive 'repair'-intent cycles at the tail. */
+    consecutiveRepairCount: number;
+    /** Empty cycles (zero blast radius) within the recent window. */
+    emptyCycleCount: number;
+    /** Trailing run of consecutive empty cycles at the tail (saturation). */
+    consecutiveEmptyCycles: number;
+    /** Trailing run of consecutive failed cycles at the tail. */
+    consecutiveFailureCount: number;
+    /** Fraction of the recent window that failed (0..1). */
+    recentFailureRatio: number;
+    /** geneId → times used within the recent window (informs which gene dominates a failure loop). */
+    geneFreq: Readonly<Record<string, number>>;
+}
+/** A normalized per-cycle record (v2-shaped mirror of v1's recentEvents entries). All fields optional. */
+export interface CycleRecord {
+    /** Intent category of the cycle ('repair' | 'optimize' | 'innovate' | 'explore' | ...). */
+    intent?: string;
+    /** Final cycle outcome. */
+    outcome?: {
+        status?: 'success' | 'failed';
+        score?: number;
+    };
+    /** Change footprint; files===0 && lines===0 (or meta.emptyCycle) marks an empty cycle. */
+    blastRadius?: {
+        files?: number;
+        lines?: number;
+    };
+    /** Explicit empty-cycle marker (when blast radius is unavailable). */
+    emptyCycle?: boolean;
+    /** Genes used in the cycle (for failure-loop gene frequency). */
+    genesUsed?: readonly string[];
+}
+/**
+ * Derive the v1 history counters from a normalized cycle-record window (newest LAST), mirroring v1
+ * analyzeRecentHistory. Pure + deterministic. Use {@link cycleRecordsFromEvents} to adapt the v2 event log.
+ */
+export declare function deriveCycleHistory(records: readonly CycleRecord[]): CycleHistory;
+/**
+ * Compute the history-derived meta-signal vocabulary from the loop's recent shape (ported v1 signals.js
+ * ~555-655 for the signals NOT already owned by exploration/bans). The returned signals are MEANT to be
+ * merged into the cycle's signal set so strategy selection (resolveStrategy) and signal expansion can react.
+ *
+ * Ports (thresholds faithful to v1):
+ *  - consecutiveRepairCount >= 3  → repair_loop_detected + force_innovation_after_repair_loop
+ *  - emptyCycleCount        >= 4  → empty_cycle_loop_detected
+ *  - consecutiveEmptyCycles >= 5  → force_steady_state + evolution_saturation
+ *  - consecutiveEmptyCycles >= 3  → evolution_saturation (+ explore_opportunity)
+ *  - consecutiveFailureCount>= 3  → consecutive_failure_streak_<N>
+ *  - consecutiveFailureCount>= 5  → failure_loop_detected   (ban_gene deferred to algo/bans.ts)
+ *  - recentFailureRatio  >= 0.75  → high_failure_ratio + force_innovation_after_repair_loop
+ *
+ * Deferred (handled elsewhere, see RECONCILIATION above): plateau_pivot_* → algo/exploration.ts;
+ * ban_gene:<top> → algo/bans.ts.
+ */
+export declare function computeMetaSignals(history: CycleHistory): string[];

package/dist/signals/metaSignals.js

@@ -0,0 +1,158 @@
+// Meta-signal vocabulary (ported from v1 src/gep/signals.js analyzeRecentHistory + the meta-signal pass).
+// These are HISTORY-DERIVED signals that drive STRATEGY ADAPTATION: when the evolution loop gets stuck
+// (repair loops, empty cycles, saturation, failure streaks, high failure ratio) the loop emits signals that
+// downstream strategy selection reacts to — e.g. evolution_saturation → steady-state, repair_loop_detected /
+// high_failure_ratio → innovate. v2 had only restored plateau→drift (algo/exploration.ts); this restores the
+// rest of the vocabulary so the loop can adapt to being stuck instead of spinning.
+//
+// RECONCILIATION (reuse, don't duplicate):
+//  - PLATEAU: v1 also emitted plateau_pivot_required/_suggested here from recent outcome scores. v2 already
+//    owns plateau detection in algo/exploration.ts (detectPlateau over the cycle-outcome stream, which then
+//    forces drift in gene selection). We DO NOT re-derive plateau here; callers keep using exploration.ts.
+//  - BAN_GENE: v1 emitted ban_gene:<topGene> on a long failure streak. v2 already owns gene banning in
+//    algo/bans.ts (bannedGenesFromFailures, signal-overlap based) which drops failing genes from the
+//    candidate set directly — a stronger mechanism than a soft signal. We DO NOT emit ban_gene here; the
+//    failure-streak meta-signals below are the strategy-posture half, bans.ts is the candidate-exclusion half.
+//
+// Pure + deterministic: input is a normalized cycle-history view; no clock / fs / env reads.
+const RECENT_WINDOW = 10; // v1: last 10 events
+const FREQ_WINDOW = 8; // v1: gene/failure frequency over the last 8
+/** Is a record an empty cycle (no real change)? Mirrors v1: meta.empty_cycle || (files===0 && lines===0). */
+function isEmptyCycle(r) {
+    if (r.emptyCycle)
+        return true;
+    const br = r.blastRadius;
+    return !!br && (br.files ?? -1) === 0 && (br.lines ?? -1) === 0;
+}
+function isFailed(r) {
+    return r.outcome?.status === 'failed';
+}
+/**
+ * Derive the v1 history counters from a normalized cycle-record window (newest LAST), mirroring v1
+ * analyzeRecentHistory. Pure + deterministic. Use {@link cycleRecordsFromEvents} to adapt the v2 event log.
+ */
+export function deriveCycleHistory(records) {
+    const empty = {
+        consecutiveRepairCount: 0,
+        emptyCycleCount: 0,
+        consecutiveEmptyCycles: 0,
+        consecutiveFailureCount: 0,
+        recentFailureRatio: 0,
+        geneFreq: {},
+    };
+    if (!Array.isArray(records) || records.length === 0)
+        return empty;
+    const recent = records.slice(-RECENT_WINDOW);
+    const tail = recent.slice(-FREQ_WINDOW);
+    // Consecutive repair-intent cycles at the tail.
+    let consecutiveRepairCount = 0;
+    for (let i = recent.length - 1; i >= 0; i--) {
+        if (recent[i].intent === 'repair')
+            consecutiveRepairCount++;
+        else
+            break;
+    }
+    // Empty cycles within the frequency window + gene frequency.
+    let emptyCycleCount = 0;
+    const geneFreq = {};
+    for (const r of tail) {
+        if (isEmptyCycle(r))
+            emptyCycleCount++;
+        for (const g of r.genesUsed ?? [])
+            geneFreq[String(g)] = (geneFreq[String(g)] ?? 0) + 1;
+    }
+    // Consecutive empty cycles at the tail (saturation).
+    let consecutiveEmptyCycles = 0;
+    for (let i = recent.length - 1; i >= 0; i--) {
+        if (isEmptyCycle(recent[i]))
+            consecutiveEmptyCycles++;
+        else
+            break;
+    }
+    // Consecutive failures at the tail. Empty cycles are zero-blast no-ops in v1's history model: even when the
+    // terminal status is failed, they break the failure streak instead of extending it.
+    let consecutiveFailureCount = 0;
+    for (let i = recent.length - 1; i >= 0; i--) {
+        if (isEmptyCycle(recent[i]))
+            break;
+        if (isFailed(recent[i]))
+            consecutiveFailureCount++;
+        else
+            break;
+    }
+    // Failure ratio over the frequency window, excluding empty cycles from both numerator and denominator.
+    let recentFailureCount = 0;
+    let nonEmptyCycleCount = 0;
+    for (const r of tail) {
+        if (isEmptyCycle(r))
+            continue;
+        nonEmptyCycleCount++;
+        if (isFailed(r))
+            recentFailureCount++;
+    }
+    return {
+        consecutiveRepairCount,
+        emptyCycleCount,
+        consecutiveEmptyCycles,
+        consecutiveFailureCount,
+        recentFailureRatio: nonEmptyCycleCount > 0 ? recentFailureCount / nonEmptyCycleCount : 0,
+        geneFreq,
+    };
+}
+/**
+ * Compute the history-derived meta-signal vocabulary from the loop's recent shape (ported v1 signals.js
+ * ~555-655 for the signals NOT already owned by exploration/bans). The returned signals are MEANT to be
+ * merged into the cycle's signal set so strategy selection (resolveStrategy) and signal expansion can react.
+ *
+ * Ports (thresholds faithful to v1):
+ *  - consecutiveRepairCount >= 3  → repair_loop_detected + force_innovation_after_repair_loop
+ *  - emptyCycleCount        >= 4  → empty_cycle_loop_detected
+ *  - consecutiveEmptyCycles >= 5  → force_steady_state + evolution_saturation
+ *  - consecutiveEmptyCycles >= 3  → evolution_saturation (+ explore_opportunity)
+ *  - consecutiveFailureCount>= 3  → consecutive_failure_streak_<N>
+ *  - consecutiveFailureCount>= 5  → failure_loop_detected   (ban_gene deferred to algo/bans.ts)
+ *  - recentFailureRatio  >= 0.75  → high_failure_ratio + force_innovation_after_repair_loop
+ *
+ * Deferred (handled elsewhere, see RECONCILIATION above): plateau_pivot_* → algo/exploration.ts;
+ * ban_gene:<top> → algo/bans.ts.
+ */
+export function computeMetaSignals(history) {
+    const signals = [];
+    // Repair loop: 3+ consecutive repair-intent cycles → push to innovate to break the loop.
+    if (history.consecutiveRepairCount >= 3) {
+        signals.push('repair_loop_detected');
+        signals.push('force_innovation_after_repair_loop');
+    }
+    // Empty-cycle loop: many zero-change cycles in the window → the loop is spinning without effect.
+    if (history.emptyCycleCount >= 4) {
+        signals.push('empty_cycle_loop_detected');
+    }
+    // Saturation (graceful degradation): consecutive empty cycles → steady-state / saturation posture.
+    if (history.consecutiveEmptyCycles >= 5) {
+        signals.push('force_steady_state');
+        signals.push('evolution_saturation');
+    }
+    else if (history.consecutiveEmptyCycles >= 3) {
+        signals.push('evolution_saturation');
+    }
+    // Exploration opportunity: when saturated, nudge proactive exploration rather than idling.
+    if (history.consecutiveEmptyCycles >= 3) {
+        signals.push('explore_opportunity');
+    }
+    // Failure streak awareness: tell the loop "you have failed N times in a row — slow down".
+    if (history.consecutiveFailureCount >= 3) {
+        signals.push('consecutive_failure_streak_' + history.consecutiveFailureCount);
+        if (history.consecutiveFailureCount >= 5) {
+            signals.push('failure_loop_detected');
+            // NB: v1 also pushed ban_gene:<topGene> here. v2 defers gene banning to algo/bans.ts
+            // (bannedGenesFromFailures), which excludes the failing gene from the candidate set directly.
+        }
+    }
+    // High failure ratio in the recent window → break out by innovating.
+    if (history.recentFailureRatio >= 0.75) {
+        signals.push('high_failure_ratio');
+        signals.push('force_innovation_after_repair_loop');
+    }
+    // De-dup while preserving first-seen order.
+    return [...new Set(signals)];
+}

package/dist/signals/signalGate.d.ts

@@ -0,0 +1,15 @@
+import type { ExtractedSignal } from './extractor.js';
+export interface ScoredSignal extends ExtractedSignal {
+    signature: string;
+    occurrences: number;
+    score: number;
+}
+export interface SignalGateConfig {
+    minScore?: number;
+    maxOutput?: number;
+}
+/**
+ * 信号打分 + 去重闸(M4A-3, task 队列前最后一道). 同签名去重并累计 occurrences(持久=更高分),
+ * 丢弃低分, 截断防低质信号灌爆 task 队列(批注#18).
+ */
+export declare function signalGate(signals: readonly ExtractedSignal[], cfg?: SignalGateConfig): ScoredSignal[];

package/dist/signals/signalGate.js

@@ -0,0 +1,40 @@
+import { createHash } from 'node:crypto';
+import { normalizeText } from '../signatures/signatures.js';
+const STRENGTH_WEIGHT = { strong: 1.0, agent: 0.8, weak: 0.4 };
+function signatureOf(s) {
+    return createHash('sha1').update(`${s.kind}\x1f${normalizeText(s.text)}`).digest('hex').slice(0, 16);
+}
+/** 单信号基础分 = 强度权重 ×(0.7 + 特异度). 特异度: 带 toolName/具体 kind 加成. */
+function baseScore(s) {
+    let specificity = 0;
+    if (s.toolName)
+        specificity += 0.2;
+    if (s.kind !== 'difficulty')
+        specificity += 0.1;
+    return STRENGTH_WEIGHT[s.strength] * (0.7 + specificity);
+}
+/**
+ * 信号打分 + 去重闸(M4A-3, task 队列前最后一道). 同签名去重并累计 occurrences(持久=更高分),
+ * 丢弃低分, 截断防低质信号灌爆 task 队列(批注#18).
+ */
+export function signalGate(signals, cfg = {}) {
+    const minScore = cfg.minScore ?? 0.3;
+    const maxOutput = cfg.maxOutput ?? 50;
+    const merged = new Map();
+    for (const s of signals) {
+        const sig = signatureOf(s);
+        const existing = merged.get(sig);
+        if (existing) {
+            existing.occurrences += 1;
+            // 持久信号加成(对数, 边际递减)
+            existing.score = baseScore(existing) * (1 + Math.min(0.5, Math.log10(existing.occurrences + 1)));
+        }
+        else {
+            merged.set(sig, { ...s, signature: sig, occurrences: 1, score: baseScore(s) });
+        }
+    }
+    return [...merged.values()]
+        .filter((s) => s.score >= minScore)
+        .sort((a, b) => b.score - a.score)
+        .slice(0, maxOutput);
+}

package/dist/signals/traceSignals.d.ts

@@ -0,0 +1,44 @@
+import type { ExtractedSignal } from './extractor.js';
+/**
+ * Minimal structural shape of one parsed llm-trace JSONL record. snake_case on purpose: these are the
+ * on-disk wire field names of the proxy's LlmTurnTrace. The shape is DUPLICATED structurally rather than
+ * imported because evolver-core must stay proxy-agnostic (the same boundary discipline as
+ * SignalSourceTurn vs runtime-adapters' NormalizedTurn). Fields are `unknown` because the input is
+ * untrusted JSON — every rule narrows with typeof checks, and a corrupt record simply matches no rule.
+ */
+export interface LlmTraceRecord {
+    event?: unknown;
+    status?: unknown;
+    fallback?: unknown;
+    stop_reason?: unknown;
+    ttfb_ms?: unknown;
+    latency_ms?: unknown;
+    error?: unknown;
+    upstream_mode?: unknown;
+}
+/** Thresholds for the aggregate rules. Defaults are deliberately conservative — see each rule's comment. */
+export interface TraceSignalThresholds {
+    /** Min upstream 5xx responses in the batch before they count as a pattern. Default 2. */
+    min5xx?: number;
+    /** Min upstream 429 responses before rate-limit pressure is a signal. Default 3. */
+    minRateLimited?: number;
+    /** Min 401/403 responses before credential breakage is assumed. Default 2. */
+    minAuthFailures?: number;
+    /** Min `stop_reason: max_tokens` turns before truncation pressure is a signal. Default 3. */
+    minTruncations?: number;
+    /** Min occurrences of a POLICY fallback (downgrade_blocked) before it is a signal. Default 3. */
+    minPolicyFallbacks?: number;
+    /** TTFB at/above this many ms counts as a slow turn. Default 30000. */
+    slowTtfbMs?: number;
+    /** Min slow turns before sustained latency fires. Default 5. */
+    minSlowTurns?: number;
+    /** Min share of eligible (successful) turns that must be slow. Default 0.2. */
+    minSlowShare?: number;
+}
+/**
+ * Extract economic/reliability signals from a batch of llm-trace records. Returns the SAME signal shape as
+ * `extractSignals` (one batch-aggregated signal per fired rule, not one per record — a day file holds
+ * thousands of turns and per-record emission would flood every downstream consumer with duplicates).
+ * Records whose `event` is not `'llm_turn'` are ignored, so callers can pass a raw parsed JSONL batch.
+ */
+export declare function extractTraceSignals(records: readonly LlmTraceRecord[], cfg?: TraceSignalThresholds): ExtractedSignal[];