@evomap/evolver-core 2.0.0-beta.0

package/dist/algo/antiDistill.d.ts

@@ -0,0 +1,35 @@
+import type { AssetRecord } from '../assetstore/provider.js';
+export declare const ANTI_DISTILL_MIN_FAILURES = 2;
+export declare const ANTI_DISTILL_TRIGGER_OVERLAP_MIN = 0.6;
+export interface AntiDistillOptions {
+    /** Minimum distinct failed capsules before a failure pattern is treated as reusable evidence. */
+    minFailures?: number;
+    /** Minimum pairwise trigger Jaccard overlap for capsules to share one cluster. */
+    triggerOverlapMin?: number;
+    /** Optional cap for callers that only want the strongest clusters. */
+    maxClusters?: number;
+}
+export interface AntiDistillFailedCapsule {
+    capsuleId: string;
+    trigger: readonly string[];
+    gene?: string;
+    summary?: string;
+    outcome?: unknown;
+    proofOfWork?: unknown;
+}
+export interface AntiDistillFailureCluster {
+    clusterId: string;
+    trigger: readonly string[];
+    sharedTrigger: readonly string[];
+    capsuleIds: readonly string[];
+    genes: readonly string[];
+    failureCapsules: readonly AntiDistillFailedCapsule[];
+}
+export interface AntiDistillInput {
+    dataHash: string;
+    failedCapsuleCount: number;
+    clusterableFailureCount: number;
+    failureClusters: readonly AntiDistillFailureCluster[];
+}
+export declare function triggerOverlapScore(a: readonly string[], b: readonly string[]): number;
+export declare function collectAntiDistillInput(capsules: readonly AssetRecord[], opts?: AntiDistillOptions): AntiDistillInput;

package/dist/algo/antiDistill.js

@@ -0,0 +1,167 @@
+import { createHash } from 'node:crypto';
+export const ANTI_DISTILL_MIN_FAILURES = 2;
+export const ANTI_DISTILL_TRIGGER_OVERLAP_MIN = 0.6;
+function asStrings(value) {
+    if (!Array.isArray(value))
+        return [];
+    return [...new Set(value.map(String).map((item) => item.trim()).filter(Boolean))];
+}
+function stringField(record, key) {
+    const value = record[key];
+    return typeof value === 'string' && value.trim() ? value : undefined;
+}
+function isFailedCapsule(record) {
+    if (record.type !== 'Capsule')
+        return false;
+    const outcome = record['outcome'];
+    return Boolean(outcome && typeof outcome === 'object' && !Array.isArray(outcome)
+        && outcome.status === 'failed');
+}
+function capsuleId(record, index) {
+    return stringField(record, 'asset_id') ?? stringField(record, 'id') ?? `capsule:${index}`;
+}
+function capsuleDigest(record, index) {
+    if (!isFailedCapsule(record))
+        return null;
+    const trigger = asStrings(record['trigger']);
+    if (trigger.length === 0)
+        return null;
+    return {
+        capsuleId: capsuleId(record, index),
+        trigger,
+        ...(stringField(record, 'gene') ? { gene: stringField(record, 'gene') } : {}),
+        ...(stringField(record, 'summary') ? { summary: stringField(record, 'summary') } : {}),
+        ...(record['outcome'] !== undefined ? { outcome: record['outcome'] } : {}),
+        ...(record['proof_of_work'] !== undefined ? { proofOfWork: record['proof_of_work'] } : {}),
+    };
+}
+function stableCapsuleView(capsule) {
+    return {
+        capsuleId: capsule.capsuleId,
+        trigger: [...capsule.trigger].sort(),
+        ...(capsule.gene ? { gene: capsule.gene } : {}),
+        ...(capsule.summary ? { summary: capsule.summary } : {}),
+        ...(capsule.outcome !== undefined ? { outcome: capsule.outcome } : {}),
+        ...(capsule.proofOfWork !== undefined ? { proofOfWork: capsule.proofOfWork } : {}),
+    };
+}
+function canonicalHashValue(value) {
+    if (value === null || typeof value !== 'object')
+        return value;
+    if (Array.isArray(value))
+        return value.map(canonicalHashValue);
+    return Object.fromEntries(Object.entries(value)
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([key, item]) => [key, canonicalHashValue(item)]));
+}
+function hashStable(value) {
+    return createHash('sha256').update(JSON.stringify(canonicalHashValue(value))).digest('hex');
+}
+export function triggerOverlapScore(a, b) {
+    const left = new Set(a.map(String).filter(Boolean));
+    const right = new Set(b.map(String).filter(Boolean));
+    if (left.size === 0 || right.size === 0)
+        return 0;
+    let hit = 0;
+    for (const token of left)
+        if (right.has(token))
+            hit += 1;
+    return hit / new Set([...left, ...right]).size;
+}
+function compatibleWithCluster(capsule, cluster, overlapMin) {
+    let total = 0;
+    for (const existing of cluster.capsules) {
+        const overlap = triggerOverlapScore(capsule.trigger, existing.trigger);
+        if (overlap < overlapMin)
+            return { ok: false, avg: overlap };
+        total += overlap;
+    }
+    return { ok: true, avg: cluster.capsules.length > 0 ? total / cluster.capsules.length : 1 };
+}
+function recurringTrigger(capsules, minFailures) {
+    const counts = new Map();
+    for (const capsule of capsules) {
+        for (const token of capsule.trigger)
+            counts.set(token, (counts.get(token) ?? 0) + 1);
+    }
+    return [...counts.entries()]
+        .filter(([, count]) => count >= minFailures)
+        .map(([token]) => token)
+        .sort();
+}
+function sharedTrigger(capsules) {
+    return recurringTrigger(capsules, capsules.length);
+}
+function clusterId(capsules) {
+    return `anti_cluster_${hashStable(capsules.map(stableCapsuleView)).slice(0, 16)}`;
+}
+function toFailureCluster(cluster, minFailures) {
+    const capsules = [...cluster.capsules].sort((a, b) => a.capsuleId.localeCompare(b.capsuleId));
+    return {
+        clusterId: clusterId(capsules),
+        trigger: recurringTrigger(capsules, minFailures),
+        sharedTrigger: sharedTrigger(capsules),
+        capsuleIds: capsules.map((capsule) => capsule.capsuleId),
+        genes: [...new Set(capsules.map((capsule) => capsule.gene).filter((gene) => Boolean(gene)))].sort(),
+        failureCapsules: capsules,
+    };
+}
+function positiveInteger(value, fallback) {
+    return Number.isSafeInteger(value) && value !== undefined && value > 0 ? value : fallback;
+}
+function nonNegativeInteger(value, fallback) {
+    return Number.isSafeInteger(value) && value !== undefined && value >= 0 ? value : fallback;
+}
+function overlapThreshold(value) {
+    return typeof value === 'number' && Number.isFinite(value) && value >= 0 && value <= 1
+        ? value
+        : ANTI_DISTILL_TRIGGER_OVERLAP_MIN;
+}
+export function collectAntiDistillInput(capsules, opts = {}) {
+    const minFailures = positiveInteger(opts.minFailures, ANTI_DISTILL_MIN_FAILURES);
+    const overlapMin = overlapThreshold(opts.triggerOverlapMin);
+    const failedCapsuleCount = capsules.filter(isFailedCapsule).length;
+    const seen = new Set();
+    const failed = capsules
+        .map((record, index) => capsuleDigest(record, index))
+        .filter((capsule) => capsule !== null)
+        .filter((capsule) => {
+        if (seen.has(capsule.capsuleId))
+            return false;
+        seen.add(capsule.capsuleId);
+        return true;
+    })
+        .sort((a, b) => a.capsuleId.localeCompare(b.capsuleId));
+    const clusters = [];
+    for (const capsule of failed) {
+        let bestIndex = -1;
+        let bestScore = -1;
+        for (let i = 0; i < clusters.length; i += 1) {
+            const score = compatibleWithCluster(capsule, clusters[i], overlapMin);
+            if (score.ok && score.avg > bestScore) {
+                bestIndex = i;
+                bestScore = score.avg;
+            }
+        }
+        if (bestIndex >= 0)
+            clusters[bestIndex].capsules.push(capsule);
+        else
+            clusters.push({ capsules: [capsule] });
+    }
+    const failureClusters = clusters
+        .filter((cluster) => cluster.capsules.length >= minFailures)
+        .map((cluster) => toFailureCluster(cluster, minFailures))
+        .sort((a, b) => b.failureCapsules.length - a.failureCapsules.length
+        || a.trigger.join('\0').localeCompare(b.trigger.join('\0'))
+        || a.capsuleIds.join('\0').localeCompare(b.capsuleIds.join('\0')))
+        .slice(0, opts.maxClusters !== undefined ? nonNegativeInteger(opts.maxClusters, clusters.length) : clusters.length);
+    return {
+        dataHash: hashStable(failureClusters.map((cluster) => ({
+            trigger: cluster.trigger,
+            capsuleIds: cluster.capsuleIds,
+        }))),
+        failedCapsuleCount,
+        clusterableFailureCount: failed.length,
+        failureClusters,
+    };
+}

package/dist/algo/bans.d.ts

@@ -0,0 +1,6 @@
+export interface FailedCapsuleRef {
+    gene?: string;
+    trigger?: readonly string[];
+}
+/** Gene ids with >=2 failed capsules whose trigger covers >=60% of the current signals. */
+export declare function bannedGenesFromFailures(failures: readonly FailedCapsuleRef[], signals: readonly string[]): Set<string>;

package/dist/algo/bans.js

@@ -0,0 +1,33 @@
+// Ban genes that have repeatedly failed on the SAME signals (ported from v1 selector.js
+// banGenesFromFailedCapsules). Complements epigenetic suppression (which is per-environment): this is a
+// hard, signal-overlap-based exclusion — a gene with >=2 failed capsules whose trigger covers the current
+// signals is dropped from the candidate set, so a strategy that keeps failing here is not resurrected.
+const BAN_THRESHOLD = 2;
+const OVERLAP_MIN = 0.6;
+/** Fraction of the current signals covered by a failure's trigger (how much it is "the same problem"). */
+function signalCoverage(signals, trigger) {
+    if (signals.length === 0)
+        return 0;
+    const t = new Set(trigger.map((s) => String(s)));
+    let hit = 0;
+    for (const s of signals)
+        if (t.has(s))
+            hit += 1;
+    return hit / signals.length;
+}
+/** Gene ids with >=2 failed capsules whose trigger covers >=60% of the current signals. */
+export function bannedGenesFromFailures(failures, signals) {
+    const counts = new Map();
+    for (const fc of failures) {
+        if (!fc.gene)
+            continue;
+        if (signalCoverage(signals, fc.trigger ?? []) < OVERLAP_MIN)
+            continue;
+        counts.set(fc.gene, (counts.get(fc.gene) ?? 0) + 1);
+    }
+    const banned = new Set();
+    for (const [gene, c] of counts)
+        if (c >= BAN_THRESHOLD)
+            banned.add(gene);
+    return banned;
+}

package/dist/algo/candidateAssembly.d.ts

@@ -0,0 +1,65 @@
+import type { AssetStoreProvider } from '../assetstore/provider.js';
+import { type ReuseCounts } from '../ops/reuseOutcomes.js';
+import type { ProvenanceStore } from '../assetstore/provenance.js';
+import type { ReviewLedger } from '../assetstore/reviewLedger.js';
+import type { AntiWarning, GeneCandidateInput } from './geneSelection.js';
+export interface AssembleOptions {
+    limit?: number;
+    provenance?: ProvenanceStore;
+    includeUntrusted?: boolean;
+    review?: ReviewLedger;
+    /**
+     * Probation (gated, #306): when true, a quarantined auto-distilled gene is allowed into the candidate pool so it
+     * can be TRIED and earn outcome evidence (its empty learning history keeps it ranked below proven genes; the
+     * always-on safety gates + the 2-strike failure ban contain a bad one). An explicitly REJECTED gene is still
+     * never a candidate. Absent/false (default) = today's behavior: a quarantined draft waits for approval first.
+     */
+    includeProbation?: boolean;
+    /**
+     * Reuse-before-solve (#110): hub candidates already resolved by the adapter's two-phase
+     * search→score→fetch flow, injected to compete in the SAME pool as local genes. The
+     * orchestration that triggers the free hub search + paid fetch lives in the adapter (so core's
+     * assembly stays pure and hub-agnostic — it only MERGES the injected candidates here). These stay
+     * trust-first: a geneId that collides with a local (trusted) gene keeps the local one; provenance
+     * for the hub asset is tracked separately at the ingest layer (#30), this only shapes selection.
+     */
+    hubCandidates?: readonly GeneCandidateInput[];
+    /**
+     * Cross-runtime reuse COUNTS per id (#268 phase 1), from reuse-outcome events (ops.reuseCountsFromSummary). Keyed
+     * by whatever id the events recorded (logical geneId OR content asset_id); assembly SUMS a gene's ids and derives
+     * one sentiment, applied as a SOFT selection re-order (see geneSelection REUSE_WEIGHT). Absent → no effect
+     * (default-off). Never resurrects a hard-gated gene (the trust/review/ban filters above run first).
+     */
+    reuseCounts?: ReadonlyMap<string, ReuseCounts>;
+}
+/** The selection pool for one cycle: the normal scored candidates + the last-resort distilled fallback (#97). */
+export interface SelectionPool {
+    /** Genes relevant to the live signals (literal or semantic match) — the normal scored candidate set. */
+    candidates: GeneCandidateInput[];
+    /**
+     * Distilled genes that passed the trust/review/ban gates but do NOT match the live signals. Surfaced
+     * separately (NOT in `candidates`, so they never compete in normal scoring) for the v1 #97 fallback: when no
+     * candidate clears the floor, selection reuses one of these broadly-applicable distilled strategies instead of
+     * falling through to a blind innovate. Kept lightweight (no learning-history aggregation) — picked first-match.
+     */
+    distilledFallback: GeneCandidateInput[];
+    /**
+     * Matched AntiGene guardrails for the live signals. This list is advisory-only and is kept out of candidates and
+     * distilledFallback so negative memory cannot be selected as a strategy.
+     */
+    antiWarnings: AntiWarning[];
+}
+/**
+ * Assemble the full selection pool from the store for the given signals: the relevant scored candidates AND the
+ * distilled-gene fallback pool, in a single pass over the gene list (one store.list + one ban computation). A gene
+ * is a normal candidate if its signals_match literally intersects the signals OR semantically overlaps them (so a
+ * '429' signal can still reach a gene tagged for 'repair'); a trusted/approved/non-banned *distilled* gene that
+ * does NOT match goes to `distilledFallback` (v1 #97).
+ */
+export declare function assembleSelectionPool(store: AssetStoreProvider, signals: readonly string[], opts?: AssembleOptions): Promise<SelectionPool>;
+/**
+ * Assemble selection candidates from the store for the given signals (the relevant scored set only).
+ * Thin wrapper over {@link assembleSelectionPool} kept for back-compat with callers that don't use the
+ * distilled-gene fallback pool.
+ */
+export declare function assembleCandidates(store: AssetStoreProvider, signals: readonly string[], opts?: AssembleOptions): Promise<GeneCandidateInput[]>;

package/dist/algo/candidateAssembly.js

@@ -0,0 +1,196 @@
+import { aggregateLearningHistory } from '../assetstore/learningHistory.js';
+import { reuseSentiment } from '../ops/reuseOutcomes.js';
+import { tagOverlapScore } from '../signals/expand.js';
+import { bannedGenesFromFailures } from './bans.js';
+import { isDistilledGeneId } from './geneIntake.js';
+function asStrings(v) {
+    return Array.isArray(v) ? v.filter((x) => typeof x === 'string') : [];
+}
+function stringField(v) {
+    return typeof v === 'string' && v.trim().length > 0 ? v.trim() : undefined;
+}
+function severityOf(v) {
+    return v === 'low' || v === 'medium' || v === 'high' ? v : undefined;
+}
+function candidateIds(geneId, assetId) {
+    return [...new Set([geneId, assetId].filter((id) => typeof id === 'string' && id.length > 0))];
+}
+function isBannedCandidate(banned, geneId, assetId) {
+    return candidateIds(geneId, assetId).some((id) => banned.has(id));
+}
+function passesInjectedCandidateGates(candidate, opts) {
+    const assetId = candidate.assetId;
+    if (opts.provenance && !opts.includeUntrusted) {
+        if (!assetId || opts.provenance.get(assetId)?.trusted !== true)
+            return false;
+    }
+    if (opts.review) {
+        if (!assetId || !opts.review.isApproved(assetId))
+            return false;
+    }
+    return true;
+}
+/** A zero learning view for a gene with no capsules yet (used for lightweight distilled-fallback candidates). */
+function emptyLearningView(geneId) {
+    return { geneId, total: 0, success: 0, failed: 0, successRate: 0, avgScore: 0, recentCapsuleIds: [] };
+}
+/** Combined reuse sentiment across ALL of a candidate's ids (#268 Bugbot). Reuse events key by assetId — which
+ *  may be the content asset_id OR the logical id — while candidates key by geneId, AND one gene's events can SPLIT
+ *  across both forms. So we SUM the counts of every distinct id the candidate has, then compute sentiment once:
+ *  averaging two per-id sentiments (or taking the first) would let negatives stored under one id be ignored. */
+function combinedReuseSentiment(map, ...ids) {
+    if (!map)
+        return undefined;
+    let success = 0, negative = 0, found = false;
+    const seen = new Set();
+    for (const id of ids) {
+        if (id === undefined || seen.has(id))
+            continue;
+        seen.add(id);
+        const c = map.get(id);
+        if (c) {
+            success += c.success;
+            negative += c.negative;
+            found = true;
+        }
+    }
+    return found ? reuseSentiment({ success, negative }) : undefined;
+}
+/** Genes banned by repeated signal-matched failures (>=2 failed capsules covering the signals). */
+async function computeBans(store, signals, limit) {
+    const caps = await store.search({ kind: 'Capsule', signalsAny: [...signals], limit });
+    const failures = caps
+        .filter((c) => c['outcome']?.status === 'failed')
+        .map((c) => ({
+        gene: typeof c['gene'] === 'string' ? String(c['gene']) : undefined,
+        trigger: asStrings(c['trigger']),
+    }));
+    return bannedGenesFromFailures(failures, signals);
+}
+/**
+ * Assemble the full selection pool from the store for the given signals: the relevant scored candidates AND the
+ * distilled-gene fallback pool, in a single pass over the gene list (one store.list + one ban computation). A gene
+ * is a normal candidate if its signals_match literally intersects the signals OR semantically overlaps them (so a
+ * '429' signal can still reach a gene tagged for 'repair'); a trusted/approved/non-banned *distilled* gene that
+ * does NOT match goes to `distilledFallback` (v1 #97).
+ */
+export async function assembleSelectionPool(store, signals, opts = {}) {
+    const limit = opts.limit ?? 500;
+    const genes = await store.list('Gene', limit);
+    const banned = await computeBans(store, signals, limit);
+    const sigSet = new Set(signals);
+    const out = [];
+    const distilledFallback = [];
+    const antiWarnings = [];
+    for (const g of genes) {
+        // Trust-first (#30): untrusted (e.g. hub-ingested) genes are excluded from the candidate pool by default;
+        // they enter only with includeUntrusted or after an explicit promotion. Provenance is keyed by asset_id.
+        if (opts.provenance && !opts.includeUntrusted && !opts.provenance.isTrusted(String(g.asset_id)))
+            continue;
+        // Review-first (#89/#91): auto-distilled drafts land quarantined until a human approves; rejected drafts stay
+        // out too. No record → eligible (cycle/migrate genes). Symmetric to the provenance trust-first filter above.
+        // Probation (#306): includeProbation lets a quarantined draft be TRIED so it can earn evidence; a rejected
+        // draft is never tried. Off (default) keeps quarantined drafts out until approval.
+        if (opts.review && !opts.review.isApproved(String(g.asset_id))
+            && (!opts.includeProbation || opts.review.get(String(g.asset_id))?.state === 'rejected'))
+            continue;
+        const geneId = typeof g['id'] === 'string' ? String(g['id']) : String(g.asset_id);
+        const assetId = String(g.asset_id);
+        if (isBannedCandidate(banned, geneId, assetId))
+            continue; // repeated signal-matched failures → not a candidate (nor a fallback)
+        const signalsMatch = asStrings(g['signals_match']);
+        const category = typeof g['category'] === 'string' ? String(g['category']) : undefined;
+        const summary = typeof g['summary'] === 'string' ? String(g['summary']) : undefined;
+        const literal = signalsMatch.some((m) => sigSet.has(m));
+        const relevant = literal || tagOverlapScore(signals, { signalsMatch, geneId, category, summary }) > 0;
+        if (!relevant) {
+            // #97: a trusted, approved, non-banned distilled gene that doesn't match the live signals is not a normal
+            // candidate, but it IS eligible as a last-resort fallback (selection uses it only when nothing clears the
+            // floor). NB in v2 "distilled" = any intaken gene (intakeGene tags them all gene_distilled_), not just skill-
+            // derived as in v1 — eligibility here is gated by trust/review/ban, not by skill provenance.
+            // Lightweight: no learning-history aggregation — it is picked first-match, not ranked by health.
+            if (isDistilledGeneId(geneId)) {
+                distilledFallback.push({
+                    geneId,
+                    assetId,
+                    signalsMatch,
+                    view: emptyLearningView(geneId),
+                    reuseCount: 0,
+                    ...(category ? { category } : {}),
+                    ...(summary ? { summary } : {}),
+                });
+            }
+            continue;
+        }
+        const view = await aggregateLearningHistory(store, geneId);
+        // #268 Bugbot: reuse events key by assetId, which may be the content asset_id (sha256:…) OR the logical id —
+        // candidates key by the logical geneId. Look the sentiment up by BOTH so the soft re-order actually matches
+        // regardless of which form the reuse-result carried (recall's resolveGene accepts both for the same reason).
+        const reuseAdjustVal = combinedReuseSentiment(opts.reuseCounts, geneId, String(g.asset_id));
+        out.push({
+            geneId,
+            assetId: String(g.asset_id),
+            signalsMatch,
+            view,
+            // #195: inert (zero-work) cycles are not productive reuse — exclude them so a do-nothing gene can't earn
+            // the reuse bonus. success + failed === total when there are no inert cycles (back-compat).
+            reuseCount: view.success + view.failed,
+            ...(category ? { category } : {}),
+            ...(summary ? { summary } : {}),
+            ...(reuseAdjustVal !== undefined ? { reuseAdjust: reuseAdjustVal } : {}),
+        });
+    }
+    // #110: merge hub reuse candidates into the same pool, trust-first — local (trusted) genes win on a
+    // geneId collision, and a hub candidate banned by repeated signal-matched failures stays out too.
+    if (opts.hubCandidates && opts.hubCandidates.length > 0) {
+        const localIds = new Set(out.map((c) => c.geneId));
+        for (const h of opts.hubCandidates) {
+            if (!passesInjectedCandidateGates(h, opts))
+                continue;
+            if (localIds.has(h.geneId))
+                continue; // a trusted local gene already covers this id
+            if (isBannedCandidate(banned, h.geneId, h.assetId))
+                continue;
+            // Stamp the reuse sentiment onto a hub candidate too (only when it didn't carry one), matched by its geneId
+            // OR its asset_id — symmetric with local genes, so a map keyed like reuse events (often sha256:…) still hits
+            // (#268 Bugbot). A hub candidate that exposes neither matching id is simply left unstamped.
+            const hubAdj = h.reuseAdjust === undefined ? combinedReuseSentiment(opts.reuseCounts, h.geneId, h.assetId) : undefined;
+            out.push(hubAdj !== undefined ? { ...h, reuseAdjust: hubAdj } : h);
+            localIds.add(h.geneId);
+        }
+    }
+    for (const a of await store.list('AntiGene', limit)) {
+        if (opts.review && !opts.review.isApproved(String(a.asset_id)))
+            continue;
+        const trigger = asStrings(a['trigger']);
+        const avoid = asStrings(a['avoid']);
+        if (trigger.length === 0 || avoid.length === 0)
+            continue;
+        const antiGeneId = stringField(a['id']) ?? String(a.asset_id);
+        const summary = stringField(a['summary']);
+        const relevant = trigger.some((m) => sigSet.has(m))
+            || tagOverlapScore(signals, { signalsMatch: trigger, geneId: antiGeneId, summary }) > 0;
+        if (!relevant)
+            continue;
+        const severity = severityOf(a['severity']);
+        const rationale = stringField(a['rationale']);
+        antiWarnings.push({
+            antiGeneId,
+            assetId: String(a.asset_id),
+            trigger,
+            avoid,
+            ...(summary ? { summary } : {}),
+            ...(severity ? { severity } : {}),
+            ...(rationale ? { rationale } : {}),
+        });
+    }
+    return { candidates: out, distilledFallback, antiWarnings };
+}
+/**
+ * Assemble selection candidates from the store for the given signals (the relevant scored set only).
+ * Thin wrapper over {@link assembleSelectionPool} kept for back-compat with callers that don't use the
+ * distilled-gene fallback pool.
+ */
+export async function assembleCandidates(store, signals, opts = {}) {
+    return (await assembleSelectionPool(store, signals, opts)).candidates;
+}

package/dist/algo/capabilityCandidates.d.ts

@@ -0,0 +1,38 @@
+/** The "five-question shape" of a capability proposal (ported verbatim from v1). */
+export interface FiveQuestionShape {
+    title: string;
+    input: string;
+    output: string;
+    invariants: string;
+    params: string;
+    failure_points: string;
+    evidence: string;
+}
+export interface CapabilityCandidate {
+    type: 'CapabilityCandidate';
+    id: string;
+    title: string;
+    source: 'transcript' | 'signals' | 'failed_capsules';
+    signals: string[];
+    tags: string[];
+    shape: FiveQuestionShape;
+}
+export interface FailedCapsuleLike {
+    trigger?: readonly string[];
+    failure_reason?: string;
+    gene?: string;
+    outcome?: {
+        status?: string;
+    };
+}
+export interface ExtractCandidatesInput {
+    /** Tool-call names observed (e.g. extracted from the runtime transcript). A name repeated >=3 times becomes a candidate. */
+    toolCalls?: readonly string[];
+    signals?: readonly string[];
+    failedCapsules?: readonly FailedCapsuleLike[];
+}
+/**
+ * Mine capability candidates from three sources (ported v1): repeated tool calls (>=3), active opportunity
+ * signals, and clusters of failed capsules (>=2 in the same dominant-problem group). Deduped by stable id.
+ */
+export declare function extractCapabilityCandidates(inp: ExtractCandidatesInput): CapabilityCandidate[];