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

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/scopeVocabulary.d.ts

@@ -0,0 +1,75 @@
+import type { AssetStoreProvider, AssetRecord } from '../assetstore/provider.js';
+/** A signal observed in the store, with how many assets declare it. */
+export interface ScopeVocabularyEntry {
+    signal: string;
+    /** Number of Gene assets whose signals_match declares this signal (hard facets counted by their bare tag). */
+    assetCount: number;
+}
+export interface ScopeVocabulary {
+    /** Observed signals, most-declared first. */
+    entries: ScopeVocabularyEntry[];
+    /** Convenience set of the bare signal strings. */
+    signals: Set<string>;
+}
+/** Strip a `required:` facet prefix to get the bare signal a facet gates on. */
+export declare function bareSignal(tag: string): string;
+/**
+ * Build the scope vocabulary from a set of Gene asset records already in hand. Hard facets contribute their BARE
+ * signal, because `required:rounding-v2` and `rounding-v2` refer to the same scope dimension — one gates on it,
+ * one hints at it. Factored out of {@link deriveScopeVocabulary} so a caller that ALREADY holds the gene records
+ * (e.g. the distiller, which lists existing genes for dedup anyway) can build the same vocabulary without a second
+ * store round-trip, and so the prompt-injection path and the post-hoc resolve path share ONE derivation.
+ */
+export declare function scopeVocabularyFromRecords(records: readonly AssetRecord[]): ScopeVocabulary;
+/**
+ * Derive the scope vocabulary from the Gene assets in a store. Thin async wrapper over
+ * {@link scopeVocabularyFromRecords} that fetches the records first.
+ */
+export declare function deriveScopeVocabulary(store: AssetStoreProvider, limit?: number): Promise<ScopeVocabulary>;
+export type ScopeResolution = 
+/** The proposed tag names a signal that exists; usable as-is. */
+{
+    status: 'exact';
+    proposed: string;
+    resolved: string;
+}
+/**
+ * The proposed tag does not exist, but exactly ONE observed signal is an unambiguous refinement of it — the
+ * autonomous-scope failure mode, where `v2` was proposed and `rounding-v2` is what exists. `resolved` is the
+ * real signal; a caller may adopt it, or surface it for review.
+ */
+ | {
+    status: 'resolved';
+    proposed: string;
+    resolved: string;
+    reason: string;
+}
+/** Several observed signals match equally well; resolving would be a guess, so we refuse to pick. */
+ | {
+    status: 'ambiguous';
+    proposed: string;
+    candidates: string[];
+}
+/** Nothing in the store resembles the tag. Not an error: a genuinely new scope looks like this. */
+ | {
+    status: 'unknown';
+    proposed: string;
+};
+/**
+ * Resolve a proposed scope tag against an observed vocabulary.
+ *
+ * Matching is deliberately conservative. Beyond an exact hit we accept only ONE relation: an observed signal that
+ * ends with `-<proposed>` or `_<proposed>` (or begins with `<proposed>-`/`<proposed>_`), i.e. the proposal is a
+ * bare qualifier and the real signal is that qualifier scoped to a domain. That is exactly the `v2` →
+ * `rounding-v2` shape. We do NOT do fuzzy/edit-distance matching: silently rewriting a scope key on a weak
+ * similarity signal would be a governance hazard far worse than an unresolved tag, since scope decides what gets
+ * injected into an agent's context. Multiple candidates yield `ambiguous` rather than an arbitrary pick.
+ */
+export declare function resolveScopeTag(proposed: string, vocab: ScopeVocabulary): ScopeResolution;
+/**
+ * Render the vocabulary as a compact, promptable list. This is what makes the vocabulary \emph{discoverable} to a
+ * distiller: it can be shown the signals that exist before being asked to choose a facet, instead of guessing.
+ * Bounded by `max` so a large store cannot blow a prompt budget; the most-declared signals come first, and the
+ * count is reported so a reader can tell a load-bearing scope from a one-off tag.
+ */
+export declare function renderScopeVocabulary(vocab: ScopeVocabulary, max?: number): string;

package/dist/signals/scopeVocabulary.js

@@ -0,0 +1,91 @@
+const REQUIRED_PREFIX = 'required:';
+/** Strip a `required:` facet prefix to get the bare signal a facet gates on. */
+export function bareSignal(tag) {
+    const t = String(tag).trim();
+    return t.startsWith(REQUIRED_PREFIX) ? t.slice(REQUIRED_PREFIX.length).trim() : t;
+}
+function asStrings(v) {
+    return Array.isArray(v) ? v.filter((x) => typeof x === 'string') : [];
+}
+/**
+ * Build the scope vocabulary from a set of Gene asset records already in hand. Hard facets contribute their BARE
+ * signal, because `required:rounding-v2` and `rounding-v2` refer to the same scope dimension — one gates on it,
+ * one hints at it. Factored out of {@link deriveScopeVocabulary} so a caller that ALREADY holds the gene records
+ * (e.g. the distiller, which lists existing genes for dedup anyway) can build the same vocabulary without a second
+ * store round-trip, and so the prompt-injection path and the post-hoc resolve path share ONE derivation.
+ */
+export function scopeVocabularyFromRecords(records) {
+    const counts = new Map();
+    for (const g of records) {
+        // One asset counts once per distinct signal, so a repeated tag within one asset cannot inflate the count.
+        const seen = new Set();
+        for (const raw of asStrings(g['signals_match'])) {
+            const s = bareSignal(raw);
+            if (!s || seen.has(s))
+                continue;
+            seen.add(s);
+            counts.set(s, (counts.get(s) ?? 0) + 1);
+        }
+    }
+    const entries = [...counts.entries()]
+        .map(([signal, assetCount]) => ({ signal, assetCount }))
+        .sort((a, b) => b.assetCount - a.assetCount || a.signal.localeCompare(b.signal));
+    return { entries, signals: new Set(entries.map((e) => e.signal)) };
+}
+/**
+ * Derive the scope vocabulary from the Gene assets in a store. Thin async wrapper over
+ * {@link scopeVocabularyFromRecords} that fetches the records first.
+ */
+export async function deriveScopeVocabulary(store, limit = 500) {
+    return scopeVocabularyFromRecords(await store.list('Gene', limit));
+}
+/**
+ * Resolve a proposed scope tag against an observed vocabulary.
+ *
+ * Matching is deliberately conservative. Beyond an exact hit we accept only ONE relation: an observed signal that
+ * ends with `-<proposed>` or `_<proposed>` (or begins with `<proposed>-`/`<proposed>_`), i.e. the proposal is a
+ * bare qualifier and the real signal is that qualifier scoped to a domain. That is exactly the `v2` →
+ * `rounding-v2` shape. We do NOT do fuzzy/edit-distance matching: silently rewriting a scope key on a weak
+ * similarity signal would be a governance hazard far worse than an unresolved tag, since scope decides what gets
+ * injected into an agent's context. Multiple candidates yield `ambiguous` rather than an arbitrary pick.
+ */
+export function resolveScopeTag(proposed, vocab) {
+    const bare = bareSignal(proposed);
+    if (!bare)
+        return { status: 'unknown', proposed };
+    if (vocab.signals.has(bare))
+        return { status: 'exact', proposed, resolved: bare };
+    const lower = bare.toLowerCase();
+    const candidates = [...vocab.signals].filter((s) => {
+        const sl = s.toLowerCase();
+        if (sl === lower)
+            return true;
+        return sl.endsWith(`-${lower}`) || sl.endsWith(`_${lower}`)
+            || sl.startsWith(`${lower}-`) || sl.startsWith(`${lower}_`);
+    });
+    if (candidates.length === 1) {
+        return {
+            status: 'resolved',
+            proposed,
+            resolved: candidates[0],
+            reason: `proposed '${bare}' is a bare qualifier; the store's vocabulary declares '${candidates[0]}'`,
+        };
+    }
+    if (candidates.length > 1)
+        return { status: 'ambiguous', proposed, candidates: candidates.sort() };
+    return { status: 'unknown', proposed };
+}
+/**
+ * Render the vocabulary as a compact, promptable list. This is what makes the vocabulary \emph{discoverable} to a
+ * distiller: it can be shown the signals that exist before being asked to choose a facet, instead of guessing.
+ * Bounded by `max` so a large store cannot blow a prompt budget; the most-declared signals come first, and the
+ * count is reported so a reader can tell a load-bearing scope from a one-off tag.
+ */
+export function renderScopeVocabulary(vocab, max = 40) {
+    if (vocab.entries.length === 0)
+        return '(no signals observed in this store yet)';
+    const shown = vocab.entries.slice(0, max);
+    const body = shown.map((e) => `${e.signal} (${e.assetCount})`).join(', ');
+    const omitted = vocab.entries.length - shown.length;
+    return omitted > 0 ? `${body}, ... and ${omitted} more` : body;
+}

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;