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

package/assets/gep/genes.jsonl

@@ -1,5 +1,5 @@
-{"type":"Gene","schema_version":"1.12.1","id":"gene_seed_publish_feishu_doc","category":"innovate","signals_match":["publish_markdown_to_feishu","create_feishu_doc","export_report_to_feishu","publish_results_to_lark_doc","feishu_doc","lark_doc"],"preconditions":["lark-cli is installed and available on PATH.","lark-cli auth status reports a ready user or bot identity."],"strategy":["Run lark-cli doctor and require an ok result before publishing.","Use the Docs v2 API and avoid deprecated Docs v1 flags.","Write long Markdown content to a temporary file and pass it as an @file input.","Create or update the document with the intended user or bot identity, then return the document URL.","Never overwrite local lark-cli credential files while preparing the document."],"constraints":{"max_files":2,"forbidden_paths":[".git","node_modules","~/.lark-cli/config.json"]},"validation":["node --version"],"summary":"Publish Markdown content as a Feishu/Lark document through the official CLI, using file-backed content and Docs v2.","asset_id":"sha256:4cdcf2b2a30bcb29a3310360c3cb16c7fc7d427d23a43c836ffa5076cfe3c041"}
-{"type":"Gene","schema_version":"1.12.1","id":"gene_seed_conventional_git_commit","category":"optimize","signals_match":["git_commit","create_commit","commit_changes","conventional_commit","stage_and_commit","write_commit_message"],"preconditions":["A git repository has staged or unstaged changes that should become one logical commit."],"strategy":["Inspect git status plus the staged or unstaged diff before choosing a commit shape.","Pick a Conventional Commits type and optional scope from the actual changed files.","Stage only the intended logical files and never stage credentials or unrelated changes.","Write a present-tense imperative subject under 72 characters, with body or footer when needed.","Do not amend, force-push, hard-reset, or bypass hooks without explicit operator approval."],"constraints":{"max_files":50,"forbidden_paths":[".git","node_modules"]},"validation":["node --version"],"summary":"Create a focused Conventional Commits-style git commit from the real diff while avoiding secrets and unrelated changes.","asset_id":"sha256:8f0acd8af3d0a94d6f50e7fe20d96ff39dc982022b851b204eddce47e177f467"}
-{"type":"Gene","schema_version":"1.12.1","id":"gene_seed_poll_bugbot_review","category":"optimize","signals_match":["poll_bugbot","bugbot_review","wait_for_ci_review","pr_review_gate","cursor_bugbot","pr_opened"],"preconditions":["An open GitHub PR exists and Cursor Bugbot is expected to review it."],"strategy":["Poll the Cursor Bugbot check by name until it reaches a terminal conclusion or the operator timeout is reached.","Treat SUCCESS as mergeable only when required checks are green and there are no unresolved Bugbot comments.","Treat NEUTRAL as not passed; fetch and summarize Cursor Bugbot inline comments for the operator.","On FAILURE or ACTION_REQUIRED, surface the findings and do not merge automatically.","Only squash-merge when the operator explicitly asked for merge and the review gate is clean."],"constraints":{"max_files":1,"forbidden_paths":[".git","node_modules"]},"validation":["node --version"],"summary":"Wait for Cursor Bugbot on a GitHub PR and gate merge decisions on the actual check conclusion and comments.","asset_id":"sha256:87737bf9d2702667c31e336fc79096f4da7f12a84baae25e827ad62b4a08d332"}
-{"type":"Gene","schema_version":"1.12.1","id":"gene_seed_gateway_timeout_recovery","category":"repair","signals_match":["gateway_timeout","upstream_timeout","http_524","http_504","request_timed_out","retry_on_timeout"],"preconditions":["A tool call, fetch, subagent request, or long command returned a gateway-class timeout."],"strategy":["Treat gateway timeout as transient or size-driven until one bounded recovery attempt proves otherwise.","Retry the exact same operation once, then stop retrying the monolithic call.","If the retry also times out, split the work by file, directory, endpoint, record, section, or time window.","Run independent slices in parallel when safe and merge the results.","Apply the same decomposition recursively only to the slice that still times out."],"constraints":{"max_files":1,"forbidden_paths":[".git","node_modules"]},"validation":["node --version"],"summary":"Recover from gateway or upstream timeouts by retrying once, then decomposing the work instead of looping the same large call.","asset_id":"sha256:fe6820477e47a8eb848ecfaa33cdb4242d9af77b78fac21fa1d716244984615c"}
-{"type":"Gene","schema_version":"1.12.1","id":"gene_seed_github_webhook_listener","category":"innovate","signals_match":["github_webhook_listener","bugbot_webhook","passive_pr_notifications","notify_when_bugbot_finishes","webhook_tunnel","github_pr_inbox"],"preconditions":["A developer machine can run a local listener and an outbound tunnel for GitHub webhook delivery."],"strategy":["Use an HMAC-validated local listener for GitHub webhook payloads and deduplicate delivery ids.","Expose the listener through an outbound-only tunnel rather than an inbound public port.","Write vetted notifications into a local inbox with restrictive permissions; never execute webhook payloads.","On session start, re-fetch PR state through GitHub before surfacing any inbox item.","Rotate webhook secrets periodically and immediately after suspected exposure."],"constraints":{"max_files":20,"forbidden_paths":[".git","node_modules"]},"validation":["node --version"],"summary":"Deploy a local HMAC-validated GitHub webhook listener that turns PR and Bugbot events into safe operator notifications.","asset_id":"sha256:a64e8d0a91cebd54290451527987230572d8a5bfe90b6ca73cd3368fd3d1f689"}
+{"type":"Gene","schema_version":"1.13.0","id":"gene_seed_publish_feishu_doc","category":"innovate","signals_match":["publish_markdown_to_feishu","create_feishu_doc","export_report_to_feishu","publish_results_to_lark_doc","feishu_doc","lark_doc"],"preconditions":["lark-cli is installed and available on PATH.","lark-cli auth status reports a ready user or bot identity."],"strategy":["Run lark-cli doctor and require an ok result before publishing.","Use the Docs v2 API and avoid deprecated Docs v1 flags.","Write long Markdown content to a temporary file and pass it as an @file input.","Create or update the document with the intended user or bot identity, then return the document URL.","Never overwrite local lark-cli credential files while preparing the document."],"constraints":{"max_files":2,"forbidden_paths":[".git","node_modules","~/.lark-cli/config.json"]},"validation":["node --version"],"summary":"Publish Markdown content as a Feishu/Lark document through the official CLI, using file-backed content and Docs v2.","asset_id":"sha256:7a8f6c4217ab2594b1412e4db1eccd4c3ac30d3a689054b956c0da6477c154bd"}
+{"type":"Gene","schema_version":"1.13.0","id":"gene_seed_conventional_git_commit","category":"optimize","signals_match":["git_commit","create_commit","commit_changes","conventional_commit","stage_and_commit","write_commit_message"],"preconditions":["A git repository has staged or unstaged changes that should become one logical commit."],"strategy":["Inspect git status plus the staged or unstaged diff before choosing a commit shape.","Pick a Conventional Commits type and optional scope from the actual changed files.","Stage only the intended logical files and never stage credentials or unrelated changes.","Write a present-tense imperative subject under 72 characters, with body or footer when needed.","Do not amend, force-push, hard-reset, or bypass hooks without explicit operator approval."],"constraints":{"max_files":50,"forbidden_paths":[".git","node_modules"]},"validation":["node --version"],"summary":"Create a focused Conventional Commits-style git commit from the real diff while avoiding secrets and unrelated changes.","asset_id":"sha256:46b34569c273b60d84501764ae20e15c6b7eb52a743db1a393e0d52272212574"}
+{"type":"Gene","schema_version":"1.13.0","id":"gene_seed_poll_bugbot_review","category":"optimize","signals_match":["poll_bugbot","bugbot_review","wait_for_ci_review","pr_review_gate","cursor_bugbot","pr_opened"],"preconditions":["An open GitHub PR exists and Cursor Bugbot is expected to review it."],"strategy":["Poll the Cursor Bugbot check by name until it reaches a terminal conclusion or the operator timeout is reached.","Treat SUCCESS as mergeable only when required checks are green and there are no unresolved Bugbot comments.","Treat NEUTRAL as not passed; fetch and summarize Cursor Bugbot inline comments for the operator.","On FAILURE or ACTION_REQUIRED, surface the findings and do not merge automatically.","Only squash-merge when the operator explicitly asked for merge and the review gate is clean."],"constraints":{"max_files":1,"forbidden_paths":[".git","node_modules"]},"validation":["node --version"],"summary":"Wait for Cursor Bugbot on a GitHub PR and gate merge decisions on the actual check conclusion and comments.","asset_id":"sha256:e137a220e84e08c784f438186c100d785c45bcc3d327082fc5661f5a76cb8de1"}
+{"type":"Gene","schema_version":"1.13.0","id":"gene_seed_gateway_timeout_recovery","category":"repair","signals_match":["gateway_timeout","upstream_timeout","http_524","http_504","request_timed_out","retry_on_timeout"],"preconditions":["A tool call, fetch, subagent request, or long command returned a gateway-class timeout."],"strategy":["Treat gateway timeout as transient or size-driven until one bounded recovery attempt proves otherwise.","Retry the exact same operation once, then stop retrying the monolithic call.","If the retry also times out, split the work by file, directory, endpoint, record, section, or time window.","Run independent slices in parallel when safe and merge the results.","Apply the same decomposition recursively only to the slice that still times out."],"constraints":{"max_files":1,"forbidden_paths":[".git","node_modules"]},"validation":["node --version"],"summary":"Recover from gateway or upstream timeouts by retrying once, then decomposing the work instead of looping the same large call.","asset_id":"sha256:72177d7186fe623de4d9fcc440e1e6d36055467e7f86b248a97318db04be26e5"}
+{"type":"Gene","schema_version":"1.13.0","id":"gene_seed_github_webhook_listener","category":"innovate","signals_match":["github_webhook_listener","bugbot_webhook","passive_pr_notifications","notify_when_bugbot_finishes","webhook_tunnel","github_pr_inbox"],"preconditions":["A developer machine can run a local listener and an outbound tunnel for GitHub webhook delivery."],"strategy":["Use an HMAC-validated local listener for GitHub webhook payloads and deduplicate delivery ids.","Expose the listener through an outbound-only tunnel rather than an inbound public port.","Write vetted notifications into a local inbox with restrictive permissions; never execute webhook payloads.","On session start, re-fetch PR state through GitHub before surfacing any inbox item.","Rotate webhook secrets periodically and immediately after suspected exposure."],"constraints":{"max_files":20,"forbidden_paths":[".git","node_modules"]},"validation":["node --version"],"summary":"Deploy a local HMAC-validated GitHub webhook listener that turns PR and Bugbot events into safe operator notifications.","asset_id":"sha256:dc6f0573c360e8e31b41142e3e4d782dcfb848a2256a4187079c3cea7edba584"}

package/dist/algo/bans.d.ts

@@ -1,6 +1,15 @@
 export interface FailedCapsuleRef {
     gene?: string;
     trigger?: readonly string[];
+    /** Stable logical FailureRecord id; duplicate deliveries of the same record count once. */
+    failureId?: string;
+    /** Root attempt shared by automatic retries; sharing this id makes retry fan-out count once. */
+    rootAttemptId?: string;
+    /** Execution/run id; duplicate deliveries of one execution count once even if other metadata diverges. */
+    executionId?: string;
+    /** Optional verifier+artifact digest pair refines legacy evidence when no direct failure/root/execution id exists. */
+    verifierDigest?: string;
+    artifactDigest?: string;
 }
-/** Gene ids with >=2 failed capsules whose trigger covers >=60% of the current signals. */
+/** Gene ids with >=2 independent 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

@@ -1,7 +1,7 @@
 // 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.
+// hard, signal-overlap-based exclusion — but only when the failures carry counted identity quality. Legacy raw
+// or partial-digest rows remain audit/advisory evidence and cannot satisfy the automatic tau=2 quarantine.
 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"). */
@@ -15,7 +15,52 @@ function signalCoverage(signals, trigger) {
             hit += 1;
     return hit / signals.length;
 }
-/** Gene ids with >=2 failed capsules whose trigger covers >=60% of the current signals. */
+function nonEmpty(s) {
+    return typeof s === 'string' && s.trim().length > 0 ? s.trim() : undefined;
+}
+function failureEvidenceIdentity(fc) {
+    const failure = nonEmpty(fc.failureId);
+    const root = nonEmpty(fc.rootAttemptId);
+    const execution = nonEmpty(fc.executionId);
+    const direct = [
+        failure ? `failure:${failure}` : undefined,
+        root ? `root:${root}` : undefined,
+        execution ? `execution:${execution}` : undefined,
+    ].filter((key) => key !== undefined);
+    if (direct.length > 0)
+        return { quality: 'strong_id', keys: direct };
+    const verifier = nonEmpty(fc.verifierDigest);
+    const artifact = nonEmpty(fc.artifactDigest);
+    if (verifier && artifact)
+        return { quality: 'complete_verifier_artifact_digest', keys: [`evidence:${verifier}:${artifact}`] };
+    if (verifier || artifact)
+        return { quality: 'legacy_partial', keys: [] };
+    return { quality: 'legacy_raw', keys: [] };
+}
+function isCountedIdentity(identity) {
+    return identity.quality === 'strong_id' || identity.quality === 'complete_verifier_artifact_digest';
+}
+function addFailureIdentity(clusters, keys) {
+    const matches = [];
+    for (let i = 0; i < clusters.length; i++) {
+        if (keys.some((key) => clusters[i].has(key)))
+            matches.push(i);
+    }
+    if (matches.length === 0) {
+        clusters.push(new Set(keys));
+        return;
+    }
+    const target = clusters[matches[0]];
+    for (const key of keys)
+        target.add(key);
+    for (let i = matches.length - 1; i > 0; i--) {
+        const index = matches[i];
+        for (const key of clusters[index])
+            target.add(key);
+        clusters.splice(index, 1);
+    }
+}
+/** Gene ids with >=2 independent failed capsules whose trigger covers >=60% of the current signals. */
 export function bannedGenesFromFailures(failures, signals) {
     const counts = new Map();
     for (const fc of failures) {
@@ -23,11 +68,16 @@ export function bannedGenesFromFailures(failures, signals) {
             continue;
         if (signalCoverage(signals, fc.trigger ?? []) < OVERLAP_MIN)
             continue;
-        counts.set(fc.gene, (counts.get(fc.gene) ?? 0) + 1);
+        const identity = failureEvidenceIdentity(fc);
+        if (!isCountedIdentity(identity))
+            continue;
+        const clusters = counts.get(fc.gene) ?? [];
+        addFailureIdentity(clusters, identity.keys);
+        counts.set(fc.gene, clusters);
     }
     const banned = new Set();
-    for (const [gene, c] of counts)
-        if (c >= BAN_THRESHOLD)
+    for (const [gene, clusters] of counts)
+        if (clusters.length >= BAN_THRESHOLD)
             banned.add(gene);
     return banned;
 }

package/dist/algo/candidateAssembly.d.ts

@@ -3,8 +3,12 @@ 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';
+import { type RuntimeRegistry } from './kautoValidator.js';
+import { type CompatibilityEvidenceIndex } from '../modelCompatibility.js';
 export interface AssembleOptions {
     limit?: number;
+    /** Build the bounded trusted pre-admission corpus used by semantic IDF. Default true. */
+    includeSemanticCorpus?: boolean;
     provenance?: ProvenanceStore;
     includeUntrusted?: boolean;
     review?: ReviewLedger;
@@ -31,6 +35,22 @@ export interface AssembleOptions {
      * (default-off). Never resurrects a hard-gated gene (the trust/review/ban filters above run first).
      */
     reuseCounts?: ReadonlyMap<string, ReuseCounts>;
+    /** Exact compatibility evidence; only quarantine decisions remove candidates. */
+    compatibility?: CompatibilityEvidenceIndex;
+    /**
+     * K_auto EvidenceProjection revocation guard (T1, default-OFF). When provided, a candidate whose five
+     * coordinates are all machine-decidable AND whose current projection touches a revoked (coordinate, value)
+     * pair is treated as NOT eligible — the fail-safe "a revoked projection is not eligible" rule, applied
+     * coordinate-locally (a sibling that differs on the revoked coordinate stays eligible). `revoked` is the set
+     * produced by `projectRevocations(rootEvents)` (algo/kautoProjection). Absent (default) = deployed T2 behavior
+     * unchanged: no projection guard runs, so signal-scoped `bannedGenesFromFailures` + the soft λ preference are
+     * the only K_auto-related effects. `runtimeRegistry` is forwarded to `decideKauto` so the runtime coordinate
+     * resolves against the same registry the caller uses elsewhere.
+     */
+    kautoProjection?: {
+        revoked: ReadonlySet<string>;
+        runtimeRegistry?: RuntimeRegistry;
+    };
 }
 /** The selection pool for one cycle: the normal scored candidates + the last-resort distilled fallback (#97). */
 export interface SelectionPool {
@@ -39,10 +59,13 @@ export interface SelectionPool {
     /**
      * 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.
+     * normal selection has no reusable positive choice, 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[];
+    /** Trust-filtered library documents captured before live-signal relevance admission. */
+    semanticCorpus: 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.

package/dist/algo/candidateAssembly.js

@@ -1,14 +1,50 @@
 import { aggregateLearningHistory } from '../assetstore/learningHistory.js';
 import { reuseSentiment } from '../ops/reuseOutcomes.js';
+import { decideKauto } from './kautoValidator.js';
+import { isProjectionRevoked } from './kautoProjection.js';
 import { expandSignals, geneTags, tagOverlapScore, } from '../signals/expand.js';
+import { resolveTaskDomainSignals, withoutTaskDomainSignals } from '../signals/taskDomain.js';
 import { bannedGenesFromFailures } from './bans.js';
 import { geneGenerationSource } from './geneIntake.js';
+import { isCompatibilityBlocked } from '../modelCompatibility.js';
+const SEMANTIC_CORPUS_LIMIT = 1_000;
 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 firstStringField(record, keys) {
+    for (const key of keys) {
+        const value = stringField(record[key]);
+        if (value)
+            return value;
+    }
+    return undefined;
+}
+function recordList(v) {
+    return Array.isArray(v) ? v.filter((x) => x !== null && typeof x === 'object' && !Array.isArray(x)) : [];
+}
+function failureIdentitySource(record) {
+    for (const trace of recordList(record['execution_trace'])) {
+        const stage = stringField(trace['stage']);
+        if (stage === 'validate' && firstStringField(trace, ['root_attempt_id', 'rootAttemptId', 'execution_id', 'executionId', 'failure_id', 'failureId', 'verifier_digest', 'verifierDigest', 'artifact_digest', 'artifactDigest']))
+            return trace;
+    }
+    return record;
+}
+function failureRefFromCapsule(record) {
+    const identity = failureIdentitySource(record);
+    return {
+        gene: stringField(record['gene']),
+        trigger: asStrings(record['trigger']),
+        failureId: firstStringField(identity, ['failure_id', 'failureId']),
+        rootAttemptId: firstStringField(identity, ['root_attempt_id', 'rootAttemptId', 'attempt_root_id', 'attemptRootId']),
+        executionId: firstStringField(identity, ['execution_id', 'executionId', 'run_id', 'runId', 'cycle_id', 'cycleId']),
+        verifierDigest: firstStringField(identity, ['verifier_digest', 'verifierDigest']),
+        artifactDigest: firstStringField(identity, ['artifact_digest', 'artifactDigest']),
+    };
+}
 function severityOf(v) {
     return v === 'low' || v === 'medium' || v === 'high' ? v : undefined;
 }
@@ -18,6 +54,25 @@ function candidateIds(geneId, assetId) {
 function isBannedCandidate(banned, geneId, assetId) {
     return candidateIds(geneId, assetId).some((id) => banned.has(id));
 }
+function requiredSignals(signalsMatch) {
+    return signalsMatch.flatMap((signal) => signal.startsWith('required:') ? [signal.slice('required:'.length).trim()] : []).filter(Boolean);
+}
+function matchSignals(signalsMatch) {
+    return signalsMatch.map((signal) => signal.startsWith('required:') ? signal.slice('required:'.length).trim() : signal).filter(Boolean);
+}
+function passesRequiredSignals(signalsMatch, liveSignals) {
+    const required = requiredSignals(signalsMatch);
+    return required.length === 0 || required.every((signal) => liveSignals.has(signal));
+}
+function passesFallbackTaskDomain(liveSignals, candidateSignals) {
+    const candidateDomain = resolveTaskDomainSignals(candidateSignals);
+    if (candidateDomain.status === 'absent')
+        return true;
+    if (candidateDomain.status !== 'resolved')
+        return false;
+    const liveDomain = resolveTaskDomainSignals(liveSignals);
+    return liveDomain.status === 'resolved' && liveDomain.slug === candidateDomain.slug;
+}
 function passesInjectedCandidateGates(candidate, opts, provenance, review) {
     const assetId = candidate.assetId;
     if (opts.provenance && !opts.includeUntrusted) {
@@ -59,13 +114,12 @@ function combinedReuseSentiment(map, ...ids) {
 }
 /** Genes banned by repeated signal-matched failures (>=2 failed capsules covering the signals). */
 async function computeBans(store, signals, limit) {
+    if (signals.length === 0)
+        return new Set();
     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']),
-    }));
+        .map((c) => failureRefFromCapsule(c));
     return bannedGenesFromFailures(failures, signals);
 }
 const GENERIC_NAMESPACE_TAGS = new Set(['action', 'area', 'problem', 'risk', 'signal']);
@@ -95,18 +149,36 @@ function hasSelectionAdmissionEvidence(liveSignals, gene) {
  */
 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 includeSemanticCorpus = opts.includeSemanticCorpus !== false;
+    const scanLimit = includeSemanticCorpus ? Math.max(limit, SEMANTIC_CORPUS_LIMIT) : limit;
+    const genes = await store.list('Gene', scanLimit);
+    const matchingSignals = withoutTaskDomainSignals(signals);
+    const banned = await computeBans(store, matchingSignals, limit);
+    const liveSignalSet = new Set(signals);
+    const sigSet = new Set(matchingSignals);
     const provenance = opts.provenance?.snapshot();
     const review = opts.review?.snapshot();
     const out = [];
     const distilledFallback = [];
+    const semanticCorpus = [];
+    const semanticIdentities = new Set();
+    const addSemanticCandidate = (candidate) => {
+        if (!includeSemanticCorpus || semanticCorpus.length >= SEMANTIC_CORPUS_LIMIT)
+            return;
+        const identity = candidate.assetId ?? candidate.geneId;
+        if (semanticIdentities.has(identity))
+            return;
+        semanticIdentities.add(identity);
+        semanticCorpus.push(candidate);
+    };
     const antiWarnings = [];
-    for (const g of genes) {
+    for (const [geneIndex, g] of genes.entries()) {
+        const provenanceRecord = provenance?.get(String(g.asset_id));
+        if (isCompatibilityBlocked({ assetType: 'Gene', assetId: String(g.asset_id), revision: stringField(g['revision']) ?? '' }, opts.compatibility))
+            continue;
         // 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 && provenance?.get(String(g.asset_id))?.trusted === false)
+        if (opts.provenance && !opts.includeUntrusted && provenanceRecord?.trusted === false)
             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.
@@ -120,12 +192,38 @@ export async function assembleSelectionPool(store, signals, opts = {}) {
         const assetId = String(g.asset_id);
         if (isBannedCandidate(banned, geneId, assetId))
             continue; // repeated signal-matched failures → not a candidate (nor a fallback)
+        // K_auto projection revocation (T1, opt-in). A decidable record whose current five-coordinate projection
+        // touches a revoked (coordinate, value) pair is not eligible — coordinate-locally, so a sibling differing on
+        // the revoked coordinate is unaffected. Runs AFTER trust/review/ban (those are the deployed hard gates) and
+        // before signal matching, so a revoked projection is dropped from both the candidate and #97 fallback pools.
+        // Default-off: without opts.kautoProjection the deployed T2 path is unchanged.
+        if (opts.kautoProjection
+            && isProjectionRevoked(decideKauto(g, opts.kautoProjection.runtimeRegistry ? { runtimeRegistry: opts.kautoProjection.runtimeRegistry } : undefined), opts.kautoProjection.revoked))
+            continue;
         const signalsMatch = asStrings(g['signals_match']);
+        const effectiveSignalsMatch = matchSignals(signalsMatch);
         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 tagInput = { signalsMatch, geneId, category, summary };
-        const relevant = literal || hasSelectionAdmissionEvidence(signals, tagInput);
+        // Experimental probation and explicitly untrusted records may be selectable by opt-in, but never shape global
+        // document frequency. Only trusted, approved/legacy-local records enter the pre-admission semantic corpus.
+        if (provenanceRecord?.trusted !== false && (reviewRecord === undefined || reviewRecord.state === 'approved')) {
+            addSemanticCandidate({
+                geneId,
+                assetId,
+                signalsMatch: effectiveSignalsMatch,
+                view: emptyLearningView(geneId),
+                ...(category ? { category } : {}),
+                ...(summary ? { summary } : {}),
+            });
+        }
+        if (geneIndex >= limit)
+            continue;
+        if (!passesRequiredSignals(signalsMatch, liveSignalSet))
+            continue;
+        const matchingSignalsForGene = withoutTaskDomainSignals(effectiveSignalsMatch);
+        const literal = matchingSignalsForGene.some((m) => sigSet.has(m));
+        const tagInput = { signalsMatch: matchingSignalsForGene, geneId, category, summary };
+        const relevant = literal || hasSelectionAdmissionEvidence(matchingSignals, tagInput);
         if (!relevant) {
             // #97: a trusted, approved, non-banned distilled (or evolved) 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
@@ -133,11 +231,12 @@ export async function assembleSelectionPool(store, signals, opts = {}) {
             // generation_meta (V1 #302); a legacy gene without it falls back to the `gene_distilled_` id namespace.
             // Lightweight: no learning-history aggregation — it is picked first-match, not ranked by health.
             const gsrc = geneGenerationSource(g, geneId);
-            if (gsrc === 'distilled' || gsrc === 'evolved') {
+            if ((gsrc === 'distilled' || gsrc === 'evolved')
+                && passesFallbackTaskDomain(signals, effectiveSignalsMatch)) {
                 distilledFallback.push({
                     geneId,
                     assetId,
-                    signalsMatch,
+                    signalsMatch: effectiveSignalsMatch,
                     view: emptyLearningView(geneId),
                     reuseCount: 0,
                     generationSource: gsrc,
@@ -148,14 +247,19 @@ export async function assembleSelectionPool(store, signals, opts = {}) {
             continue;
         }
         const view = await aggregateLearningHistory(store, geneId);
+        const explorationEligible = provenanceRecord?.trusted !== false
+            && (reviewRecord === undefined || reviewRecord.state === 'approved');
         // #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));
+        // Soft K_auto preference: stamp only when the source record clears the strict five-coordinate bar.
+        // Absent/false leaves score unchanged so the historical non-member catalogue is not zeroed.
+        const kautoMember = decideKauto(g).inKauto;
         out.push({
             geneId,
             assetId: String(g.asset_id),
-            signalsMatch,
+            signalsMatch: effectiveSignalsMatch,
             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).
@@ -163,25 +267,40 @@ export async function assembleSelectionPool(store, signals, opts = {}) {
             ...(category ? { category } : {}),
             ...(summary ? { summary } : {}),
             ...(reuseAdjustVal !== undefined ? { reuseAdjust: reuseAdjustVal } : {}),
+            ...(kautoMember ? { kautoMember: true } : {}),
+            explorationEligible,
         });
     }
     // #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));
+        const localAssetIds = new Set(out.map((c) => c.assetId).filter((id) => id !== undefined));
         for (const h of opts.hubCandidates) {
+            if (isCompatibilityBlocked({ assetType: 'Gene', assetId: h.assetId ?? h.geneId, revision: String(h.hubAsset?.['revision'] ?? '') }, opts.compatibility))
+                continue;
             if (!passesInjectedCandidateGates(h, opts, provenance, review))
                 continue;
+            if (!passesRequiredSignals(h.signalsMatch, sigSet))
+                continue;
             if (localIds.has(h.geneId))
                 continue; // a trusted local gene already covers this id
+            if (h.assetId && localAssetIds.has(h.assetId))
+                continue; // the same content identity is already local/trusted
             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 hubSignalsMatch = matchSignals(h.signalsMatch);
             const hubAdj = h.reuseAdjust === undefined ? combinedReuseSentiment(opts.reuseCounts, h.geneId, h.assetId) : undefined;
-            out.push(hubAdj !== undefined ? { ...h, reuseAdjust: hubAdj } : h);
+            // A transient Hub candidate must never self-assert active-bandit cold-start eligibility. It still competes
+            // under the existing base score and legacy drift; UCB1 fails safe for a mixed window.
+            const guarded = { ...h, signalsMatch: hubSignalsMatch, explorationEligible: false };
+            out.push(hubAdj !== undefined ? { ...guarded, reuseAdjust: hubAdj } : guarded);
             localIds.add(h.geneId);
+            if (h.assetId)
+                localAssetIds.add(h.assetId);
         }
     }
     for (const a of await store.list('AntiGene', limit)) {
@@ -196,8 +315,10 @@ export async function assembleSelectionPool(store, signals, opts = {}) {
             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;
+        const matchingTrigger = withoutTaskDomainSignals(trigger);
+        // This is a safety inclusion gate: ubiquitous evidence must still emit warnings.
+        const relevant = matchingTrigger.some((m) => sigSet.has(m))
+            || tagOverlapScore(matchingSignals, { signalsMatch: matchingTrigger, geneId: antiGeneId, summary }) > 0;
         if (!relevant)
             continue;
         const severity = severityOf(a['severity']);
@@ -212,7 +333,7 @@ export async function assembleSelectionPool(store, signals, opts = {}) {
             ...(rationale ? { rationale } : {}),
         });
     }
-    return { candidates: out, distilledFallback, antiWarnings };
+    return { candidates: out, distilledFallback, semanticCorpus, antiWarnings };
 }
 /**
  * Assemble selection candidates from the store for the given signals (the relevant scored set only).
@@ -220,5 +341,7 @@ export async function assembleSelectionPool(store, signals, opts = {}) {
  * distilled-gene fallback pool.
  */
 export async function assembleCandidates(store, signals, opts = {}) {
-    return (await assembleSelectionPool(store, signals, opts)).candidates;
+    // This compatibility wrapper discards semanticCorpus, so preserve its legacy I/O bound instead of scanning
+    // 1,000 records for data the caller cannot consume.
+    return (await assembleSelectionPool(store, signals, { ...opts, includeSemanticCorpus: false })).candidates;
 }

package/dist/algo/capabilityCandidates.js

@@ -20,6 +20,16 @@ const SIGNAL_CANDIDATES = [
     { signal: 'capability_gap', title: 'Fill capability gap' },
     { signal: 'stable_success_plateau', title: 'Explore new strategies during stability plateau' },
     { signal: 'external_opportunity', title: 'Evaluate external A2A asset for local adoption' },
+    // Harness context-budget family (v1 context-compression gene family port). v2 ships no seed-gene catalog, so
+    // the reusable strategies arrive as ADVISORY candidates the runtime may distill into genes — one per bloat
+    // source, because a single "shorten the prompt" proposal loses the distinction that decides what is safe to
+    // drop (an always-on tool schema is lazy-loadable; an approval gate is not).
+    { signal: 'prompt_budget_measurement', title: 'Measure the prompt budget per source before compressing context' },
+    { signal: 'context_explosion', title: 'Attribute a context-window overflow to its largest prompt source' },
+    { signal: 'tool_schema_bloat', title: 'Load exact tool/MCP schemas from the runtime loader instead of always-on prompt text' },
+    { signal: 'skill_list_bloat', title: 'Compress skill and agent-type descriptions into selectable route cards' },
+    { signal: 'transcript_context_bloat', title: 'Compress a pasted transcript into a session handoff packet' },
+    { signal: 'memory_index_budget', title: 'Keep the memory index lean and rely on relevance recall for detail' },
 ];
 /** Highest → lowest priority problem class used to pick a failure cluster's grouping key (ported v1). */
 const PROBLEM_PRIORITY = ['problem:performance', 'problem:protocol', 'problem:reliability', 'problem:stagnation', 'problem:capability'];

package/dist/algo/cycleEngine.d.ts

@@ -4,13 +4,15 @@ import type { GepCategory, Mutation, Capsule, EvolutionEvent } from '../wire/ind
 import type { AssetStoreProvider } from '../assetstore/provider.js';
 import type { StrategyPoint } from '../strategy/strategyPoint.js';
 import { type CycleStage } from '../cycle/stateMachine.js';
-import { type GeneDecision, type SelectionInput, type GeneCandidateInput, type AntiWarning } from './geneSelection.js';
+import { type GeneDecision, type SelectionInput, type GeneCandidateInput, type AntiWarning, type SelectionGuardMode } from './geneSelection.js';
 import { type EnvFingerprint } from '../bootstrap/envFingerprint.js';
 import type { PersonalityStore } from '../personality/store.js';
-import { type ResolutionStatus } from './solidify.js';
+import { type FailureEvidenceIdentityInput, type ResolutionStatus } from './solidify.js';
 import type { ProofOfWork } from '../schema/proofOfWork.js';
+import type { ExecutionTerminalDisposition, FrozenExecutionBinding, ImmutableExecutionProvenance } from '../exec/executionBinding.js';
 import { type ClassifyRecentEvent } from './cycleFailureClassifier.js';
 import type { MemoryGraphGeneEvidence } from './memoryGraph.js';
+import { type SelectionPolicy } from './ucb1.js';
 export interface TriggerEval {
     trigger: boolean;
     reasons: string[];
@@ -23,8 +25,23 @@ export interface ExecutionResult {
         score: number;
         reason?: string;
     };
+    bindingCorrelation?: {
+        bindingDigest: `sha256:${string}`;
+        runId: string;
+    };
+    executionTerminal?: {
+        status: 'success' | 'failed';
+        disposition: ExecutionTerminalDisposition;
+    };
+    provenance?: ImmutableExecutionProvenance;
+    hubLifecycle?: {
+        state: 'not_submitted';
+    };
+    nativeSessionId?: string;
     proofOfWork?: ProofOfWork;
     strongEvidence?: boolean;
+    /** Optional logical failure identity supplied by the runner; absent keeps the failure as legacy advisory evidence. */
+    failureIdentity?: FailureEvidenceIdentityInput;
     /** Structured runner failure metadata. Safe to persist; unlike sessionLog it contains no transcript text. */
     failureKind?: ExecutionFailureKind;
     exitCode?: number | null;
@@ -33,13 +50,17 @@ export interface ExecutionResult {
      * outcome. It is the host-side context classifyCycleFailure needs to reach the host_no_transcript /
      * host_provider_error buckets on the PRODUCTION path (#279): an empty transcript means the host gave evolver
      * nothing to evolve from; a provider-error string (429 / quota / context-length) means the host's LLM call
-     * failed, not the gene. Consumed only for failure triage and NEVER persisted to event payloads (the engine
-     * writes only the derived failure_class), so it adds no root_events bloat and leaks no transcript content.
+     * failed, not the gene. Consumed only for failure triage and NEVER persisted to event payloads; the engine
+     * writes only the derived failure_class, so it adds no root_events bloat and leaks no transcript content.
      */
     sessionLog?: string;
 }
 export interface SolidifyPermitContext {
     cycleId: string;
+    bindingDigest?: `sha256:${string}`;
+    runId?: string;
+    executionTerminal?: ExecutionResult['executionTerminal'];
+    provenance?: ImmutableExecutionProvenance;
     geneId: string;
     signals: readonly string[];
     mutation: Mutation;
@@ -90,6 +111,14 @@ export interface CycleInput {
     /** Optional explicit strategy preset name; when set, it wins over history-derived meta-signal auto-detection. */
     strategyName?: string;
     candidates: readonly GeneCandidateInput[];
+    /** Trust-filtered library corpus captured before relevance admission for stable semantic IDF. */
+    semanticCorpus?: readonly GeneCandidateInput[];
+    /** Emergency rollback: use the pre-IDF semantic scorer for this cycle. */
+    disableSemanticIdf?: boolean;
+    /** Experimental plateau selection policy. Default preserves engine-health + legacy random drift. */
+    selectionPolicy?: SelectionPolicy;
+    /** Versioned relevance-guard rollout. Omit for legacy direct-call behavior. */
+    selectionGuard?: SelectionGuardMode;
     selectionFloor?: number;
     /**
      * Explicit GEP/runtime-selected gene. Forwarded after candidate assembly and local hard filters, so it cannot
@@ -101,12 +130,14 @@ export interface CycleInput {
     summary: string;
     confidence: number;
     execute: (mutation: Mutation, decision: GeneDecision) => Promise<ExecutionResult> | ExecutionResult;
+    /** Immutable external execution binding; omitted for legacy local cycles. */
+    executionBinding?: FrozenExecutionBinding;
     /** Optional adapter/runtime permit gate. Runs after execute succeeds and before solidify writes assets. */
     solidifyPermit?: SolidifyPermitGate;
     /**
      * Distilled-gene fallback pool (ported from v1 #97): broadly-applicable distilled genes that do NOT match the
      * live signals, assembled (trust/review/ban-filtered) upstream. Forwarded to selection, which uses one only as a
-     * last resort when no candidate clears the floor — reusing a known distilled strategy instead of a blind innovate.
+     * last resort when normal selection has no reusable positive choice — reusing a known distilled strategy instead of a blind innovate.
      */
     distilledFallback?: readonly GeneCandidateInput[];
     /** Advisory-only AntiGene warnings matched upstream for this cycle's base signals. */
@@ -134,6 +165,10 @@ export interface CycleInput {
 }
 export interface CycleResult {
     cycleId: string;
+    bindingDigest?: `sha256:${string}`;
+    runId?: string;
+    terminalDisposition?: ExecutionTerminalDisposition;
+    execution?: ExecutionResult;
     triggered: boolean;
     finalStage: CycleStage;
     /** Real CycleEngine returns this on every path; optional keeps injected legacy engines source-compatible. */