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

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,6 @@ 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';

package/dist/signals/index.js

@@ -3,4 +3,6 @@ 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';

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/dist/signals/taskDomain.d.ts

@@ -0,0 +1,22 @@
+export declare const TASK_DOMAIN_SIGNAL_PREFIX: "task_domain:";
+export type TaskDomainResolution = {
+    status: 'absent';
+} | {
+    status: 'resolved';
+    slug: string;
+} | {
+    status: 'ambiguous';
+} | {
+    status: 'invalid';
+};
+/** Identify the namespace even when the value is malformed, so it cannot leak into generic matching. */
+export declare function isTaskDomainSignal(raw: string): boolean;
+/** Remove task-domain tokens from generic matching while preserving their original wire representation elsewhere. */
+export declare function withoutTaskDomainSignals(signals: readonly string[]): string[];
+/**
+ * Resolve one canonical task domain from signal tokens. Parsing is order-independent and fail-closed:
+ * malformed tokens invalidate the whole dimension, and distinct valid slugs are ambiguous.
+ */
+export declare function resolveTaskDomainSignals(signals: readonly string[]): TaskDomainResolution;
+/** Emit a canonical wire token. Callers must supply an already-normalized lowercase slug. */
+export declare function taskDomainSignal(slug: string): string;

package/dist/signals/taskDomain.js

@@ -0,0 +1,43 @@
+export const TASK_DOMAIN_SIGNAL_PREFIX = 'task_domain:';
+const TASK_DOMAIN_SLUG_RE = /^[a-z0-9][a-z0-9-]{0,63}$/;
+/** Identify the namespace even when the value is malformed, so it cannot leak into generic matching. */
+export function isTaskDomainSignal(raw) {
+    return raw.trim().toLowerCase().startsWith(TASK_DOMAIN_SIGNAL_PREFIX);
+}
+/** Remove task-domain tokens from generic matching while preserving their original wire representation elsewhere. */
+export function withoutTaskDomainSignals(signals) {
+    return signals.filter((signal) => !isTaskDomainSignal(signal));
+}
+/**
+ * Resolve one canonical task domain from signal tokens. Parsing is order-independent and fail-closed:
+ * malformed tokens invalidate the whole dimension, and distinct valid slugs are ambiguous.
+ */
+export function resolveTaskDomainSignals(signals) {
+    const slugs = new Set();
+    let found = false;
+    for (const raw of signals) {
+        const signal = raw.trim();
+        const lower = signal.toLowerCase();
+        if (!lower.startsWith(TASK_DOMAIN_SIGNAL_PREFIX))
+            continue;
+        found = true;
+        if (signal !== raw)
+            return { status: 'invalid' };
+        const slug = lower.slice(TASK_DOMAIN_SIGNAL_PREFIX.length);
+        if (!TASK_DOMAIN_SLUG_RE.test(slug))
+            return { status: 'invalid' };
+        slugs.add(slug);
+    }
+    if (!found)
+        return { status: 'absent' };
+    if (slugs.size !== 1)
+        return { status: 'ambiguous' };
+    return { status: 'resolved', slug: slugs.values().next().value };
+}
+/** Emit a canonical wire token. Callers must supply an already-normalized lowercase slug. */
+export function taskDomainSignal(slug) {
+    if (!TASK_DOMAIN_SLUG_RE.test(slug)) {
+        throw new Error(`invalid task_domain slug: ${slug}`);
+    }
+    return `${TASK_DOMAIN_SIGNAL_PREFIX}${slug}`;
+}

package/dist/strategy/constraintAblation.d.ts

@@ -0,0 +1,64 @@
+export type ConstraintKind = 'must' | 'must_not';
+export type ConstraintTraceSource = 'plan' | 'task' | 'trace';
+export type ConstraintSeverity = 'low' | 'medium' | 'high';
+export type SensitiveClass = 'credential' | 'email' | 'filesystem_path';
+export type TaskSuccessStatus = 'success' | 'failure' | 'unknown';
+export type TaskSuccessSource = 'oracle' | 'task_status' | 'manual' | 'trace';
+export type SensitivitySuccessComparison = 'success_constraint_sensitive' | 'success_constraint_insensitive' | 'failure_constraint_sensitive' | 'failure_constraint_insensitive' | 'unknown_success';
+export interface ConstraintTrace {
+    source: ConstraintTraceSource;
+    text: string;
+    traceId?: string;
+}
+export interface ExtractedConstraint {
+    id: string;
+    kind: ConstraintKind;
+    textHash: string;
+    redactedText: string;
+    source: ConstraintTraceSource;
+    traceId?: string;
+    sensitiveClasses: SensitiveClass[];
+}
+export interface ConstraintAblatedPrompt {
+    originalPromptHash: string;
+    ablatedPromptHash: string;
+    removedConstraintIds: string[];
+    redactedPreview?: string;
+}
+export interface ConstraintViolation {
+    constraintId: string;
+    kind: ConstraintKind;
+    severity: ConstraintSeverity;
+    evidenceHash: string;
+    matchedTerms: string[];
+}
+export interface TaskSuccessLabel {
+    status: TaskSuccessStatus;
+    source: TaskSuccessSource;
+}
+export interface ConstraintAblationScore {
+    source: 'constraint_ablation_replay';
+    sensitivity: number;
+    ablationCount: number;
+    baselineViolationCount: number;
+    ablatedViolationCount: number;
+    mustViolationCount: number;
+    mustNotViolationCount: number;
+    taskSuccess: TaskSuccessLabel;
+    comparison: SensitivitySuccessComparison;
+}
+export interface ConstraintAblationScoreInput {
+    baselineViolations: readonly ConstraintViolation[];
+    ablatedViolations: readonly ConstraintViolation[];
+    removedConstraintIds: readonly string[];
+    ablationCount: number;
+    taskSuccess: TaskSuccessLabel;
+    sensitivityThreshold?: number;
+}
+export declare function redactConstraintText(text: string): string;
+export declare function extractConstraints(traces: readonly ConstraintTrace[]): ExtractedConstraint[];
+export declare function buildConstraintAblatedPrompts(prompt: string, constraints: readonly ExtractedConstraint[], opts?: {
+    includeRedactedPreview?: boolean;
+}): ConstraintAblatedPrompt[];
+export declare function detectConstraintViolations(output: string, constraints: readonly ExtractedConstraint[]): ConstraintViolation[];
+export declare function computeConstraintAblationScore(input: ConstraintAblationScoreInput): ConstraintAblationScore;