@evomap/evolver-core 2.0.0-beta.12 → 2.0.0-beta.14

package/dist/hooks/hooks.js

@@ -69,6 +69,7 @@ export function composeSessionStartWithRecap(base, recapCtx, estimateTokensOrOpt
 export function signalsFromToolUse(event) {
     const turn = {
         toolName: event.toolName,
+        ...(event.toolResult ? { toolResult: event.toolResult } : {}),
         ...(event.isError && event.toolResult ? { errorMessage: event.toolResult } : {}),
         ...(event.text ? { text: event.text } : {}),
         isMeta: false,

package/dist/hub/questionGenerator.d.ts

@@ -54,6 +54,10 @@ export interface QuestionGenerationResult {
     state: QuestionGeneratorState;
     changed: boolean;
 }
-export declare function extractTopicKeywords(transcript: string | undefined, memory: string | undefined, max?: number): string[];
+export interface TopicKeywordOptions {
+    minOccurrences?: number;
+    preserveSourceOrder?: boolean;
+}
+export declare function extractTopicKeywords(transcript: string | undefined, memory: string | undefined, max?: number, opts?: TopicKeywordOptions): string[];
 export declare function generateQuestions(input?: GenerateQuestionsInput): QuestionGenerationResult;
 export declare function generateUrgentQuestions(input?: GenerateUrgentQuestionsInput): QuestionGenerationResult;

package/dist/hub/questionGenerator.js

@@ -21,7 +21,7 @@ const EXPLORE_STOPWORDS = new Set([
     'agent', 'about', 'into', 'then', 'than', 'they', 'them', 'their', 'there',
     'here', 'will', 'would', 'could', 'should', 'been', 'were', 'using', 'used',
     'cycle', 'evolution', 'error', 'errors', 'failed', 'failure', 'null', 'undefined',
-    'true', 'false', 'console', 'return', 'function', 'const', 'value', 'result',
+    'true', 'false', 'console', 'return', 'function', 'const', 'value', 'result', 'redacted',
 ]);
 const SENSITIVE_TOPIC_RE = /secret|token|api[_-]?key|password|passwd|credential|bearer|authorization|cookie|session[_-]?id|private[_-]?key|oauth|refresh[_-]?token/i;
 const LONG_OPAQUE_RE = /^[a-z0-9_-]{32,}$/i;
@@ -106,8 +106,8 @@ function safeTopicToken(token) {
         return false;
     return true;
 }
-export function extractTopicKeywords(transcript, memory, max = 5) {
-    const text = `${String(transcript ?? '')} ${String(memory ?? '')}`.toLowerCase();
+export function extractTopicKeywords(transcript, memory, max = 5, opts = {}) {
+    const text = redactString(`${String(transcript ?? '')} ${String(memory ?? '')}`).toLowerCase();
     const words = text.match(/[a-z][a-z0-9_-]{4,}/g) ?? [];
     const freq = new Map();
     for (const word of words) {
@@ -115,9 +115,11 @@ export function extractTopicKeywords(transcript, memory, max = 5) {
             continue;
         freq.set(word, (freq.get(word) ?? 0) + 1);
     }
-    return [...freq.entries()]
-        .filter(([, count]) => count >= 2)
-        .sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]))
+    const entries = [...freq.entries()]
+        .filter(([, count]) => count >= Math.max(1, Math.trunc(opts.minOccurrences ?? 2)));
+    if (!opts.preserveSourceOrder)
+        entries.sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]));
+    return entries
         .map(([word]) => word)
         .slice(0, max);
 }

package/dist/schema/signal.d.ts

@@ -7,7 +7,7 @@ export declare const problemSignature: z.ZodString;
 export declare const signal: z.ZodObject<{
     signalId: z.ZodString;
     fromMaterial: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
-    kind: z.ZodEnum<["strong_structured", "weak_corpus", "agent_marked"]>;
+    kind: z.ZodEnum<["strong_structured", "weak_corpus", "agent_marked", "verified_success"]>;
     text: z.ZodString;
     score: z.ZodDefault<z.ZodNumber>;
     eventSignature: z.ZodString;
@@ -16,7 +16,7 @@ export declare const signal: z.ZodObject<{
     discoveredAt: z.ZodString;
     extensions: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, "strip", z.ZodTypeAny, {
-    kind: "strong_structured" | "weak_corpus" | "agent_marked";
+    kind: "strong_structured" | "weak_corpus" | "agent_marked" | "verified_success";
     extensions: Record<string, unknown>;
     signalId: string;
     fromMaterial: string[];
@@ -27,7 +27,7 @@ export declare const signal: z.ZodObject<{
     signatureV: number;
     discoveredAt: string;
 }, {
-    kind: "strong_structured" | "weak_corpus" | "agent_marked";
+    kind: "strong_structured" | "weak_corpus" | "agent_marked" | "verified_success";
     signalId: string;
     text: string;
     eventSignature: string;

package/dist/schema/signal.js

@@ -8,7 +8,7 @@ export const problemSignature = z.string();
 export const signal = z.object({
     signalId: ulid,
     fromMaterial: z.array(ulid).default([]),
-    kind: z.enum(['strong_structured', 'weak_corpus', 'agent_marked']),
+    kind: z.enum(['strong_structured', 'weak_corpus', 'agent_marked', 'verified_success']),
     text: z.string(),
     score: z.number().min(0).max(1).default(0),
     eventSignature,

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.js

@@ -19,7 +19,16 @@ 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'] },
+    // Success signals (v2-native, #578): a stable success plateau or resolved issue expands to
+    // signal:success + action:optimize/action:innovate so a gene tagged for optimization/innovation can be selected
+    // when the loop is succeeding — enabling "learn from what works" rather than only "fix what's broken".
+    // `verified[-_]success` matches both the underscore form (meta-signal naming) and the hyphen form
+    // (distillPrimitives signalTokens token) so success genes distilled from sessions are also expanded.
+    { re: /(stable_success_plateau|issue_already_resolved|openclaw_self_healed|self_healed|resolved|verified[-_]success|success_prose)/, tags: ['signal:success', 'action:optimize', '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.

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/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). */

package/dist/signals/metaSignals.js

@@ -27,6 +27,9 @@ function isEmptyCycle(r) {
 function isFailed(r) {
     return r.outcome?.status === 'failed';
 }
+function isSuccess(r) {
+    return r.outcome?.status === 'success';
+}
 /**
  * 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.
@@ -37,6 +40,8 @@ export function deriveCycleHistory(records) {
         emptyCycleCount: 0,
         consecutiveEmptyCycles: 0,
         consecutiveFailureCount: 0,
+        consecutiveSuccessCount: 0,
+        successCycleCount: 0,
         recentFailureRatio: 0,
         geneFreq: {},
     };
@@ -90,11 +95,32 @@ export function deriveCycleHistory(records) {
         if (isFailed(r))
             recentFailureCount++;
     }
+    // Consecutive successes at the tail (stable success plateau detection). Empty cycles are zero-blast
+    // no-ops: like the failure streak, they break the success streak instead of extending it.
+    let consecutiveSuccessCount = 0;
+    for (let i = recent.length - 1; i >= 0; i--) {
+        if (isEmptyCycle(recent[i]))
+            break;
+        if (isSuccess(recent[i]))
+            consecutiveSuccessCount++;
+        else
+            break;
+    }
+    // Successful cycles within the frequency window (non-empty successes, same caliber as recentFailureRatio).
+    let successCycleCount = 0;
+    for (const r of tail) {
+        if (isEmptyCycle(r))
+            continue;
+        if (isSuccess(r))
+            successCycleCount++;
+    }
     return {
         consecutiveRepairCount,
         emptyCycleCount,
         consecutiveEmptyCycles,
         consecutiveFailureCount,
+        consecutiveSuccessCount,
+        successCycleCount,
         recentFailureRatio: nonEmptyCycleCount > 0 ? recentFailureCount / nonEmptyCycleCount : 0,
         geneFreq,
     };
@@ -153,6 +179,22 @@ export function computeMetaSignals(history) {
         signals.push('high_failure_ratio');
         signals.push('force_innovation_after_repair_loop');
     }
+    // Stable success plateau: 5+ consecutive successes → system is in a stable success plateau.
+    // This is the SUCCESS counterpart of failure_loop_detected: instead of signaling "stuck failing",
+    // it signals "consistently succeeding" — the loop should distill WHAT WORKED into reusable genes.
+    if (history.consecutiveSuccessCount >= 5) {
+        signals.push('stable_success_plateau');
+    }
+    // Issue already resolved: 3+ consecutive successes after a prior failure context suggests
+    // the problem is solved — downstream can skip redundant repair attempts.
+    if (history.consecutiveSuccessCount >= 3 && history.recentFailureRatio > 0) {
+        signals.push('issue_already_resolved');
+    }
+    // Self-healed requires the current tail to be successful. Window totals alone would mislabel
+    // [success, success, failed] as recovered even though the latest outcome is a failure.
+    if (history.consecutiveSuccessCount > 0 && history.successCycleCount >= 2 && history.recentFailureRatio > 0 && history.recentFailureRatio < 0.5) {
+        signals.push('openclaw_self_healed');
+    }
     // De-dup while preserving first-seen order.
     return [...new Set(signals)];
 }

package/dist/signals/signalGate.js

@@ -1,6 +1,6 @@
 import { createHash } from 'node:crypto';
 import { normalizeText } from '../signatures/signatures.js';
-const STRENGTH_WEIGHT = { strong: 1.0, agent: 0.8, weak: 0.4 };
+const STRENGTH_WEIGHT = { strong: 1.0, agent: 0.8, success: 0.7, weak: 0.4 };
 function signatureOf(s) {
     return createHash('sha1').update(`${s.kind}\x1f${normalizeText(s.text)}`).digest('hex').slice(0, 16);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evomap/evolver-core",
-  "version": "2.0.0-beta.12",
+  "version": "2.0.0-beta.14",
   "private": false,
   "type": "module",
   "description": "hub-无关核心: 算法引擎/原材料/mailbox/资产库/workflow",