@evomap/evolver-core 2.0.0-beta.2 → 2.0.0-beta.22

package/dist/signals/curriculum.js

@@ -0,0 +1,202 @@
+/**
+ * Progressive curriculum signals, adapted from V1's curriculum producer.
+ *
+ * V2 keeps the policy pure and derives its history from the append-only root event log. This avoids V1's
+ * separate mutable curriculum_state.json sidecar while preserving the behavior that matters to selection:
+ * classify recent outcomes and add at most one capability-gap target plus one frontier target.
+ */
+const MASTERY_THRESHOLD = 0.8;
+const MASTERY_MIN_ATTEMPTS = 3;
+const FAILURE_THRESHOLD = 0.3;
+const MIN_CLASSIFICATION_ATTEMPTS = 2;
+const MAX_CURRICULUM_SIGNALS = 2;
+const MAX_TARGET_CHARS = 60;
+const DEFAULT_OUTCOME_WINDOW = 200;
+const CAPABILITY_NAME = /^[A-Za-z][A-Za-z0-9_-]{0,59}$/;
+export const MAX_CAPABILITY_GAPS = 16;
+export const CAPABILITY_GAPS_STATE_KEY = 'curriculum:capability_gaps';
+const CAPABILITY_GAPS_STATE_VERSION = 1;
+function record(value) {
+    return value && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function stringArray(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    return value.filter((entry) => typeof entry === 'string');
+}
+function boundedWindow(value) {
+    if (!Number.isFinite(value))
+        return DEFAULT_OUTCOME_WINDOW;
+    return Math.max(1, Math.min(10_000, Math.floor(value)));
+}
+/** Normalize untrusted capability names before they cross adapter, persistence, or selection boundaries. */
+export function normalizeCapabilityGaps(value) {
+    if (!Array.isArray(value))
+        return [];
+    const gaps = [];
+    for (const entry of value) {
+        if (typeof entry !== 'string')
+            continue;
+        const normalized = entry.trim().toLowerCase();
+        if (!CAPABILITY_NAME.test(normalized) || gaps.includes(normalized))
+            continue;
+        gaps.push(normalized);
+        if (gaps.length >= MAX_CAPABILITY_GAPS)
+            break;
+    }
+    return gaps;
+}
+/** Versioned, bounded snapshot stored atomically in the lifecycle mailbox KV table. */
+export function serializeCapabilityGapsState(capabilityGaps, observedAt) {
+    const safeObservedAt = Number.isFinite(observedAt) && observedAt >= 0 ? Math.floor(observedAt) : 0;
+    return JSON.stringify({
+        version: CAPABILITY_GAPS_STATE_VERSION,
+        capabilityGaps: normalizeCapabilityGaps(capabilityGaps),
+        observedAt: safeObservedAt,
+    });
+}
+/** Parse only the current bounded snapshot format. Unknown versions fail open without influencing selection. */
+export function capabilityGapsFromState(value) {
+    if (typeof value !== 'string' || value.length === 0)
+        return [];
+    try {
+        const parsed = record(JSON.parse(value));
+        if (!parsed || parsed['version'] !== CAPABILITY_GAPS_STATE_VERSION)
+            return [];
+        const observedAt = parsed['observedAt'];
+        if (typeof observedAt !== 'number' || !Number.isFinite(observedAt) || observedAt < 0)
+            return [];
+        return normalizeCapabilityGaps(parsed['capabilityGaps']);
+    }
+    catch {
+        return [];
+    }
+}
+/** Stable V2 equivalent of V1 computeSignalKey, excluding previously generated curriculum targets. */
+export function curriculumSignalKey(signals) {
+    return [...new Set(signals
+            .map((signal) => signal.trim())
+            .filter((signal) => signal.length > 0 && !signal.startsWith('curriculum_target:')))]
+        .sort()
+        .join('|');
+}
+/** Classify signal-key outcomes using V1's thresholds. */
+export function classifyCurriculumOutcomes(outcomes) {
+    const aggregates = new Map();
+    for (const outcome of outcomes) {
+        const key = typeof outcome?.key === 'string' ? outcome.key.trim() : '';
+        if (!key || (outcome.status !== 'success' && outcome.status !== 'failed'))
+            continue;
+        const aggregate = aggregates.get(key) ?? { success: 0, failed: 0 };
+        if (outcome.status === 'success')
+            aggregate.success += 1;
+        else
+            aggregate.failed += 1;
+        aggregates.set(key, aggregate);
+    }
+    const mastered = [];
+    const failing = [];
+    const frontier = [];
+    for (const [key, aggregate] of aggregates) {
+        const total = aggregate.success + aggregate.failed;
+        if (total < MIN_CLASSIFICATION_ATTEMPTS)
+            continue;
+        const rate = aggregate.success / total;
+        const bucket = { key, success: aggregate.success, failed: aggregate.failed, total, rate };
+        if (rate >= MASTERY_THRESHOLD && total >= MASTERY_MIN_ATTEMPTS)
+            mastered.push(bucket);
+        else if (rate <= FAILURE_THRESHOLD)
+            failing.push(bucket);
+        else
+            frontier.push(bucket);
+    }
+    frontier.sort((left, right) => Math.abs(left.rate - 0.5) - Math.abs(right.rate - 0.5));
+    return { mastered, failing, frontier };
+}
+/** Generate no more than the two target families V1 produced: gap first, then closest frontier. */
+export function generateCurriculumSignals(input) {
+    const analysis = classifyCurriculumOutcomes(input.outcomes);
+    const generated = [];
+    const gap = (input.capabilityGaps ?? []).find((entry) => typeof entry === 'string' && entry.trim().length > 0)?.trim();
+    if (gap) {
+        const normalizedGap = gap.toLowerCase();
+        const alreadyMastered = analysis.mastered.some((entry) => entry.key.toLowerCase().includes(normalizedGap));
+        if (!alreadyMastered)
+            generated.push(`curriculum_target:gap:${gap.slice(0, MAX_TARGET_CHARS)}`);
+    }
+    const best = analysis.frontier[0];
+    if (generated.length < MAX_CURRICULUM_SIGNALS && best) {
+        const alreadyTargeted = generated.some((signal) => signal.includes(best.key));
+        if (!alreadyTargeted)
+            generated.push(`curriculum_target:frontier:${best.key.slice(0, MAX_TARGET_CHARS)}`);
+    }
+    return generated.slice(0, MAX_CURRICULUM_SIGNALS);
+}
+/**
+ * Map V2's capability signal conventions to concrete curriculum gaps. A bare cap:* tag is not sufficient by
+ * itself: it becomes a curriculum gap only when the same signal set explicitly declares capability_gap.
+ */
+export function capabilityGapsFromSignals(signals) {
+    const hasGapMarker = signals.some((signal) => signal === 'capability_gap' || signal.startsWith('capability_gap:'));
+    if (!hasGapMarker)
+        return [];
+    const gaps = [];
+    const add = (raw) => {
+        const normalized = raw.trim().toLowerCase();
+        if (!CAPABILITY_NAME.test(normalized) || gaps.includes(normalized))
+            return;
+        gaps.push(normalized);
+    };
+    for (const signal of signals)
+        if (signal.startsWith('cap:'))
+            add(signal.slice('cap:'.length));
+    for (const signal of signals)
+        if (signal.startsWith('capability_gap:'))
+            add(signal.slice('capability_gap:'.length));
+    return normalizeCapabilityGaps(gaps);
+}
+/**
+ * Join cycle.signals_collected to terminal cycle events and retain the latest outcome window. `baseSignals`
+ * wins over `signals`, so history-derived meta-signals do not become a self-reinforcing curriculum key.
+ */
+export function curriculumOutcomesFromEvents(events, maxOutcomes = DEFAULT_OUTCOME_WINDOW) {
+    const limit = boundedWindow(maxOutcomes);
+    const selectedNewestFirst = [];
+    const terminalCycles = new Set();
+    // Pick the latest unique terminal cycles first. EventStore.readAll already owns the input array, while every
+    // auxiliary collection in this adapter remains bounded by the configured outcome window.
+    for (let index = events.length - 1; index >= 0 && selectedNewestFirst.length < limit; index -= 1) {
+        const event = events[index];
+        if (event.type !== 'cycle.solidified' && event.type !== 'cycle.failed')
+            continue;
+        const payload = record(event.payload);
+        if (!payload || typeof payload['cycleId'] !== 'string' || terminalCycles.has(payload['cycleId']))
+            continue;
+        const cycleId = payload['cycleId'];
+        terminalCycles.add(cycleId);
+        selectedNewestFirst.push({
+            cycleId,
+            status: event.type === 'cycle.failed' || payload['producedValue'] === false ? 'failed' : 'success',
+        });
+    }
+    const signalsByCycle = new Map();
+    // Build the signal lookup independently of terminal ordering. Normal logs collect signals first, but a
+    // recovered/imported history can be reordered without making otherwise valid outcomes disappear.
+    for (const event of events) {
+        const payload = record(event.payload);
+        if (!payload)
+            continue;
+        const cycleId = typeof payload['cycleId'] === 'string' ? payload['cycleId'] : undefined;
+        if (!cycleId || !terminalCycles.has(cycleId) || event.type !== 'cycle.signals_collected')
+            continue;
+        const baseSignals = stringArray(payload['baseSignals']);
+        const fallbackSignals = stringArray(payload['signals']);
+        signalsByCycle.set(cycleId, baseSignals ?? fallbackSignals ?? []);
+    }
+    return selectedNewestFirst.reverse().flatMap(({ cycleId, status }) => {
+        const key = curriculumSignalKey(signalsByCycle.get(cycleId) ?? []);
+        return key ? [{ key, status }] : [];
+    });
+}

package/dist/signals/cycleHistoryFromEvents.js

@@ -8,7 +8,8 @@
 //  - intent:     mutation.built.payload.category (the cycle's GepCategory), if emitted
 //  - genesUsed:  decision.gene_selected.payload.selectedGeneId  ||  cycle.*.payload.gene
 //  - score:      cycle.*.payload.outcome.score
-//  - blastRadius:capsule.produced.payload.blastRadius, if emitted (else absent → not counted as empty)
+//  - blastRadius:capsule.produced.payload.blastRadius, if emitted. Productive {0,0} is omitted because non-git
+//                proofs use it as "unknown"; measured/no-value {0,0} remains an empty-cycle marker.
 // Only terminal cycles (a cycle.solidified or cycle.failed) become records; in-flight cycles are skipped.
 function payloadObj(e) {
     return e.payload && typeof e.payload === 'object' ? e.payload : {};
@@ -22,13 +23,12 @@ function cycleIdOf(p) {
  */
 export function cycleRecordsFromEvents(events) {
     const byCycle = new Map();
-    const order = [];
+    const terminalOrder = [];
     const get = (id) => {
         let a = byCycle.get(id);
         if (!a) {
             a = { terminal: false };
             byCycle.set(id, a);
-            order.push(id);
         }
         return a;
     };
@@ -53,15 +53,24 @@ export function cycleRecordsFromEvents(events) {
                 const br = p['blastRadius'];
                 if (br && typeof br === 'object') {
                     const o = br;
-                    a.blastRadius = {
-                        ...(typeof o['files'] === 'number' ? { files: o['files'] } : {}),
-                        ...(typeof o['lines'] === 'number' ? { lines: o['lines'] } : {}),
-                    };
+                    const files = typeof o['files'] === 'number' ? o['files'] : undefined;
+                    const lines = typeof o['lines'] === 'number' ? o['lines'] : undefined;
+                    // Non-git proofs use {0,0} as "blast unknown". producedValue is the authoritative distinction between
+                    // those productive cycles and a measured zero-change git cycle.
+                    const productiveUnknownBlast = p['producedValue'] === true && files === 0 && lines === 0;
+                    if (!productiveUnknownBlast) {
+                        a.blastRadius = {
+                            ...(files !== undefined ? { files } : {}),
+                            ...(lines !== undefined ? { lines } : {}),
+                        };
+                    }
                 }
                 break;
             }
             case 'cycle.solidified':
             case 'cycle.failed': {
+                if (!a.terminal)
+                    terminalOrder.push(id);
                 a.terminal = true;
                 a.status = e.type === 'cycle.solidified' ? 'success' : 'failed';
                 if (typeof p['gene'] === 'string')
@@ -77,7 +86,7 @@ export function cycleRecordsFromEvents(events) {
         }
     }
     const records = [];
-    for (const id of order) {
+    for (const id of terminalOrder) {
         const a = byCycle.get(id);
         if (!a.terminal)
             continue; // skip in-flight cycles

package/dist/signals/expand.d.ts

@@ -31,4 +31,18 @@ export declare function geneTags(gene: GeneTagInput): string[];
  * 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 declare function tagOverlapScore(signals: readonly string[], gene: GeneTagInput): number;
+export declare function tagOverlapScore(signals: readonly string[], gene: GeneTagInput): number;
+export interface SemanticIdfDocument {
+    readonly tags: readonly string[];
+    readonly text: string;
+}
+export interface SemanticIdfProfile {
+    readonly documentCount: number;
+    readonly tagIdf: ReadonlyMap<string, number>;
+    readonly tokenIdf: ReadonlyMap<string, number>;
+    /** Deterministic, data-free identity for replaying the exact document-frequency profile. */
+    readonly version: string;
+}
+export declare function buildSemanticIdfProfile(documents: readonly SemanticIdfDocument[]): SemanticIdfProfile;
+export declare function idfTagOverlapScore(signals: readonly string[], gene: GeneTagInput, profile: SemanticIdfProfile): number;
+export declare function idfBagCosine(a: string, b: string, profile: SemanticIdfProfile): number;

package/dist/signals/expand.js

@@ -1,3 +1,4 @@
+import { createHash } from 'node:crypto';
 // 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 —
@@ -8,6 +9,18 @@
 // 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 SUCCESS_OUTCOME_TAGS = ['signal:success', 'action:optimize', 'action:innovate'];
+const EXPLICIT_SUCCESS_SIGNALS = new Set([
+    'issue_already_resolved',
+    'issue_resolved',
+    'openclaw_self_healed',
+    'resolved',
+    'self_healed',
+    'stable_success_plateau',
+    'success_prose',
+    'verified-success',
+    'verified_success',
+]);
 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
@@ -19,13 +32,28 @@ const EXPANSION_RULES = [
     // 功能/機能/기능 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'] },
+    // Negative lookbehind on `plateau`: `stable_success_plateau` contains the substring `plateau`, but it is a
+    // SUCCESS signal (#578), not a stagnation signal. Without (?<!success_) the stagnation rule would fire on it,
+    // producing contradictory tags (problem:stagnation + signal:success) in a single expandSignals pass.
+    { re: /(stagnation|(?<!success_)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'] },
+    // Harness context budget (v1 context-compression gene family port): an agent harness that injects large
+    // tool/MCP schemas, long skill manuals, agent-type descriptions, a memory index, or a pasted transcript can
+    // exhaust the model's context window before the task starts. That is a prompt-assembly (area:prompt) cost
+    // problem, and shrinking it is an optimize action — NOT a reliability failure. v2 has no seed-gene catalog,
+    // so these rules ARE the shared vocabulary that lets a context-bloat signal reach a compression strategy.
+    { re: /(context_bloat|context_explosion|context window|token_budget|prompt_budget|上下文爆|上下文预算|token 超限|token超限)/, tags: ['problem:context_budget', 'action:optimize', 'area:prompt'] },
+    // Tool/MCP schema weight is the always-on half of the budget; lazy-loading it is the corrective action.
+    { re: /(tool_schema|schema_bloat|mcp_tool_schema|lazy_load_schema|just-in-time schema|工具 schema|工具schema)/, tags: ['problem:context_budget', 'action:optimize', 'area:prompt', 'area:orchestration'] },
+    // Skill manuals / agent-type descriptions are the other always-on half (area:skills already exists above).
+    { re: /(skill_list_bloat|skill_manual_bloat|agent type description|mcp server instructions|skill 列表太长|技能列表太长)/, tags: ['problem:context_budget', 'action:optimize', 'area:skills', 'area:prompt'] },
+    // A pasted transcript / session handoff is the caller-supplied half — compressing it is a memory-shaped concern.
+    { re: /(transcript_bloat|transcript_context_bloat|conversation_handoff|session handoff|pasted transcript|会话上下文就爆|完整转录)/, tags: ['problem:context_budget', 'action:optimize', 'area:memory'] },
     { re: /(validation|canary|rollback|constraint|blast radius|destructive)/, tags: ['risk:validation'] },
 ];
 /**
@@ -41,6 +69,11 @@ export function expandSignals(signals, extraText = '') {
         if (base && base !== str)
             tags.add(base); // namespace prefix (e.g. 'auth:token' → 'auth')
     }
+    // #578 success markers are structured signals; prose inference accepts negated forms too easily.
+    if (signals.some((signal) => EXPLICIT_SUCCESS_SIGNALS.has(String(signal).trim().toLowerCase().normalize('NFKC')))) {
+        for (const tag of SUCCESS_OUTCOME_TAGS)
+            tags.add(tag);
+    }
     const text = (signals.join(' ') + ' ' + extraText).toLowerCase().normalize('NFKC');
     for (const rule of EXPANSION_RULES) {
         if (rule.re.test(text))
@@ -122,4 +155,139 @@ export function tagOverlapScore(signals, gene) {
         if (geneTagSet.has(t))
             hits++;
     return hits / sigTags.length;
+}
+const SEMANTIC_IDF_DOCUMENT_LIMIT = 1_000;
+const SEMANTIC_IDF_TEXT_CHARS_PER_DOCUMENT = 4_096;
+const SEMANTIC_IDF_TAG_INPUTS_PER_DOCUMENT = 256;
+const SEMANTIC_IDF_TAG_CHARS = 1_024;
+const SEMANTIC_IDF_TAGS_PER_DOCUMENT = 64;
+const SEMANTIC_IDF_TOKENS_PER_DOCUMENT = 128;
+const SEMANTIC_IDF_TAG_VOCABULARY_LIMIT = 8_192;
+const SEMANTIC_IDF_TOKEN_VOCABULARY_LIMIT = 32_768;
+function normalizeSemanticTag(tag) {
+    return tag.normalize('NFKC').trim().toLowerCase();
+}
+function inverseDocumentFrequency(documentCount, documentFrequency) {
+    return Math.log(documentCount / documentFrequency);
+}
+function tokenFrequency(text) {
+    const frequencies = new Map();
+    for (const token of tokenize(text)) {
+        frequencies.set(token, (frequencies.get(token) ?? 0) + 1);
+    }
+    return frequencies;
+}
+function compareCodeUnits(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}
+function boundedUnique(values, limit) {
+    return [...new Set(values.filter(Boolean))].sort(compareCodeUnits).slice(0, limit);
+}
+function boundedVocabulary(valuesByDocument, limit) {
+    const vocabulary = new Set();
+    for (const values of valuesByDocument) {
+        for (const value of values)
+            vocabulary.add(value);
+    }
+    // Selecting by code-unit order makes the cap independent of corpus/document order. The source set is itself
+    // bounded by the per-document and document-count limits above, so this sort cannot grow without bound.
+    return new Set([...vocabulary].sort(compareCodeUnits).slice(0, limit));
+}
+function semanticProfileVersion(documentCount, tagDocumentFrequency, tokenDocumentFrequency) {
+    // Hash only normalized document-frequency entries so decision telemetry never contains plaintext corpus data.
+    // A 128-bit SHA-256 prefix keeps the identifier compact while avoiding the collision rate of a 32-bit checksum.
+    const hash = createHash('sha256');
+    hash.update(`documents:${documentCount};`, 'utf8');
+    for (const [tag, frequency] of [...tagDocumentFrequency].sort(([left], [right]) => compareCodeUnits(left, right))) {
+        hash.update(`tag:${tag.length}:${tag}:${frequency};`, 'utf8');
+    }
+    for (const [token, frequency] of [...tokenDocumentFrequency].sort(([left], [right]) => compareCodeUnits(left, right))) {
+        hash.update(`token:${token.length}:${token}:${frequency};`, 'utf8');
+    }
+    return `idf-2:n=${documentCount};tags=${tagDocumentFrequency.size};tokens=${tokenDocumentFrequency.size};sha256=${hash.digest('hex').slice(0, 32)}`;
+}
+export function buildSemanticIdfProfile(documents) {
+    const boundedDocuments = documents.slice(0, SEMANTIC_IDF_DOCUMENT_LIMIT).map((document) => ({
+        tags: boundedUnique(document.tags
+            .slice(0, SEMANTIC_IDF_TAG_INPUTS_PER_DOCUMENT)
+            .map((tag) => normalizeSemanticTag(tag.slice(0, SEMANTIC_IDF_TAG_CHARS))), SEMANTIC_IDF_TAGS_PER_DOCUMENT),
+        tokens: boundedUnique(tokenize(document.text.slice(0, SEMANTIC_IDF_TEXT_CHARS_PER_DOCUMENT)), SEMANTIC_IDF_TOKENS_PER_DOCUMENT),
+    }));
+    const tagVocabulary = boundedVocabulary(boundedDocuments.map((document) => document.tags), SEMANTIC_IDF_TAG_VOCABULARY_LIMIT);
+    const tokenVocabulary = boundedVocabulary(boundedDocuments.map((document) => document.tokens), SEMANTIC_IDF_TOKEN_VOCABULARY_LIMIT);
+    const tagDocumentFrequency = new Map();
+    const tokenDocumentFrequency = new Map();
+    for (const document of boundedDocuments) {
+        for (const tag of document.tags) {
+            if (!tagVocabulary.has(tag))
+                continue;
+            tagDocumentFrequency.set(tag, (tagDocumentFrequency.get(tag) ?? 0) + 1);
+        }
+        for (const token of document.tokens) {
+            if (!tokenVocabulary.has(token))
+                continue;
+            tokenDocumentFrequency.set(token, (tokenDocumentFrequency.get(token) ?? 0) + 1);
+        }
+    }
+    const documentCount = boundedDocuments.length;
+    const tagIdf = new Map();
+    const tokenIdf = new Map();
+    for (const [tag, frequency] of tagDocumentFrequency) {
+        tagIdf.set(tag, inverseDocumentFrequency(documentCount, frequency));
+    }
+    for (const [token, frequency] of tokenDocumentFrequency) {
+        tokenIdf.set(token, inverseDocumentFrequency(documentCount, frequency));
+    }
+    return {
+        documentCount,
+        tagIdf,
+        tokenIdf,
+        version: semanticProfileVersion(documentCount, tagDocumentFrequency, tokenDocumentFrequency),
+    };
+}
+export function idfTagOverlapScore(signals, gene, profile) {
+    if (profile.documentCount <= 1)
+        return tagOverlapScore(signals, gene);
+    const signalTags = [...new Set(expandSignals(signals).map(normalizeSemanticTag))];
+    const geneTagSet = new Set(geneTags(gene).map(normalizeSemanticTag));
+    let matchedWeight = 0;
+    let totalWeight = 0;
+    for (const tag of signalTags) {
+        const weight = profile.tagIdf.get(tag);
+        if (weight === undefined)
+            continue;
+        totalWeight += weight;
+        if (geneTagSet.has(tag))
+            matchedWeight += weight;
+    }
+    return totalWeight > 0 ? matchedWeight / totalWeight : 0;
+}
+export function idfBagCosine(a, b, profile) {
+    if (profile.documentCount <= 1)
+        return bagCosine(a, b);
+    const bagA = tokenFrequency(a);
+    const bagB = tokenFrequency(b);
+    let dot = 0;
+    let normA = 0;
+    let normB = 0;
+    for (const [token, count] of bagA) {
+        const weight = profile.tokenIdf.get(token);
+        if (weight === undefined)
+            continue;
+        const weightedCount = count * weight;
+        normA += weightedCount * weightedCount;
+        const otherCount = bagB.get(token);
+        if (otherCount !== undefined)
+            dot += weightedCount * otherCount * weight;
+    }
+    for (const [token, count] of bagB) {
+        const weight = profile.tokenIdf.get(token);
+        if (weight === undefined)
+            continue;
+        const weightedCount = count * weight;
+        normB += weightedCount * weightedCount;
+    }
+    if (normA === 0 || normB === 0)
+        return 0;
+    return dot / (Math.sqrt(normA) * Math.sqrt(normB));
 }

package/dist/signals/extractor.d.ts

@@ -6,8 +6,8 @@ export interface SignalSourceTurn {
     errorMessage?: string;
     isMeta?: boolean;
 }
-/** 信号强度三条腿(批注#13): strong=零成本结构化判断 / agent=自标记 / weak=需 LLM 分析. */
-export type SignalStrength = 'strong' | 'agent' | 'weak';
+/** 信号强度四条腿(批注#13): strong=零成本结构化错误判断 / agent=自标记 / weak=需 LLM 分析 / success=成功信号(Issue#578). */
+export type SignalStrength = 'strong' | 'agent' | 'weak' | 'success';
 export interface ExtractedSignal {
     id: string;
     strength: SignalStrength;

package/dist/signals/extractor.js

@@ -4,7 +4,16 @@ 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;
+const DIFFICULTY = /(无法|失败|搞不定|stuck|can'?t|unable to|not working|fail(?:ed|ing|ure)?|broken|did not pass|no tests? passed|报错|卡住)/i;
+/** 成功信号: 工具执行成功/测试通过/构建成功 — 零成本结构化判断, 不动 LLM(Issue#578).
+ *  注意: bare `verified` 和 `green` 已移至 SUCCESS_PROSE(needsAnalysis:true), 因为它们在非成功语境下高频出现
+ *  ("verified the bug exists" / "green field" / "green button") 且 SUCCESS_TEXT 的 needsAnalysis:false 无 LLM 兜底.
+ *  Emoji are accepted only with test-result context; a bare checklist mark is not proof of session success. */
+const SUCCESS_TEXT = /\b(exit code:?\s*0|all tests?\s+pass(ed)?|tests?\s+pass(ed)?|validation\s+pass(ed)?|build\s+succeed(ed)?|published\s+successfully|completed\s+successfully)\b|(?:^|\n)\s*(?:✓\s*(?:\d+\s+)?(?:tests?\s+)?pass(ed)?\b|(?:Tests|Test Files):?\s+[1-9]\d*\s+pass(ed)?\b|(?:=+\s*)?[1-9]\d*\s+pass(ed)?(?:\s+in\s+\d+(?:\.\d+)?s?|\s*=*\s*$)|PASS\s+\S+|ok\s+\S+\s+(?:\d+(?:\.\d+)?s|\(cached\))(?:\s|$))|\btests?\s+🟢(?:\s|$)/im;
+/** Deterministic success must fail closed when the same result carries a current negative outcome. */
+const SUCCESS_CONFLICT = /\b(?:no|zero|0)(?:\s+of\s+\d+)?\s+tests?\s+pass(ed)?\b|\bsome\s+tests?\s+pass(ed)?\b|\b(?:tests?|validation|verification|build)\s+(?:fail(?:ed|ing|ure)?|did\s+not\s+pass)\b|\b\d+\s+(?:tests?\s+)?failed\b|\b(?:implementation\s+)?(?:still\s+|remains?\s+)(?:broken|failing|not\s+working)\b|\b(?:not|never|did\s+not|has\s+not|hasn't|have\s+not|haven't)\s+(?:succeed(ed)?|complete(d)?\s+successfully)\b/i;
+/** 成功措辞(非结构化但表达完成/解决): 需上下文确认(Issue#578). bare `verified` 也在此层: "verified the fix" vs "verified the bug" 需 LLM 判断. */
+const SUCCESS_PROSE = /\b(successful(?:ly)?|verified|resolved|fixed|working\s+now|works\s+correctly|problem\s+solved|issue\s+resolved|done|complete)\b/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
@@ -33,7 +42,8 @@ export function extractSignals(turns) {
             continue;
         }
         const text = t.text ?? '';
-        if (!text.trim())
+        const toolResult = t.toolResult ?? '';
+        if (!text.trim() && !toolResult.trim())
             continue;
         // 腿3 agent: 显式标记
         const marker = AGENT_MARKERS.map((re) => text.match(re)).find(Boolean);
@@ -41,16 +51,31 @@ export function extractSignals(turns) {
             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 });
+        // Leg 1 strong: inspect both fields. Some adapters populate only toolResult, while older callers may populate
+        // text as well; a failure in either representation must outrank a positive substring in the other.
+        const resultText = toolResult.trim() ? toolResult : text;
+        const structuredFailureText = STRONG_TEXT.test(text) ? text : (STRONG_TEXT.test(toolResult) ? toolResult : '');
+        if (structuredFailureText) {
+            if (!isHarnessNoise(structuredFailureText)) {
+                out.push({ id: makeUlid(), strength: 'strong', kind: 'structured_error', text: structuredFailureText.slice(0, 2000), ...(t.toolName ? { toolName: t.toolName } : {}), needsAnalysis: false });
+            }
+            continue;
+        }
+        // Leg 4 success: prefer the actual tool result; adapters intentionally keep tool-turn text empty.
+        if (SUCCESS_TEXT.test(resultText) && !SUCCESS_CONFLICT.test(resultText)) {
+            if (!isHarnessNoise(resultText)) {
+                out.push({ id: makeUlid(), strength: 'success', kind: 'verified_success', text: resultText.slice(0, 2000), ...(t.toolName ? { toolName: t.toolName } : {}), 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 });
+            continue;
+        }
+        // 腿4 success: 非结构化成功措辞(resolved/fixed/working now 等) → 需上下文确认(Issue#578)
+        if (SUCCESS_PROSE.test(text)) {
+            out.push({ id: makeUlid(), strength: 'success', kind: 'success_prose', text: text.slice(0, 2000), needsAnalysis: true });
         }
     }
     return out;

package/dist/signals/index.d.ts

@@ -3,4 +3,7 @@ export * from './signalGate.js';
 export * from './expand.js';
 export * from './traceSignals.js';
 export * from './metaSignals.js';
-export * from './cycleHistoryFromEvents.js';
+export * from './cycleHistoryFromEvents.js';
+export * from './curriculum.js';
+export * from './taskDomain.js';
+export * from './scopeVocabulary.js';

package/dist/signals/index.js

@@ -3,4 +3,7 @@ export * from './signalGate.js';
 export * from './expand.js';
 export * from './traceSignals.js';
 export * from './metaSignals.js';
-export * from './cycleHistoryFromEvents.js';
+export * from './cycleHistoryFromEvents.js';
+export * from './curriculum.js';
+export * from './taskDomain.js';
+export * from './scopeVocabulary.js';

package/dist/signals/metaSignals.d.ts

@@ -8,6 +8,10 @@ export interface CycleHistory {
     consecutiveEmptyCycles: number;
     /** Trailing run of consecutive failed cycles at the tail. */
     consecutiveFailureCount: number;
+    /** Trailing run of consecutive successful cycles at the tail. */
+    consecutiveSuccessCount: number;
+    /** Successful cycles within the recent window. */
+    successCycleCount: 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). */