@evomap/evolver-core 2.0.0-beta.1 → 2.0.0-beta.3

package/assets/gep/genes.jsonl

@@ -0,0 +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"}

package/dist/algo/candidateAssembly.js

@@ -2,7 +2,7 @@ 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';
+import { geneGenerationSource } from './geneIntake.js';
 function asStrings(v) {
     return Array.isArray(v) ? v.filter((x) => typeof x === 'string') : [];
 }
@@ -18,14 +18,15 @@ function candidateIds(geneId, assetId) {
 function isBannedCandidate(banned, geneId, assetId) {
     return candidateIds(geneId, assetId).some((id) => banned.has(id));
 }
-function passesInjectedCandidateGates(candidate, opts) {
+function passesInjectedCandidateGates(candidate, opts, provenance, review) {
     const assetId = candidate.assetId;
     if (opts.provenance && !opts.includeUntrusted) {
-        if (!assetId || opts.provenance.get(assetId)?.trusted !== true)
+        if (!assetId || provenance?.get(assetId)?.trusted !== true)
             return false;
     }
     if (opts.review) {
-        if (!assetId || !opts.review.isApproved(assetId))
+        const reviewRecord = assetId ? review?.get(assetId) : undefined;
+        if (!assetId || (reviewRecord !== undefined && reviewRecord.state !== 'approved'))
             return false;
     }
     return true;
@@ -79,20 +80,23 @@ export async function assembleSelectionPool(store, signals, opts = {}) {
     const genes = await store.list('Gene', limit);
     const banned = await computeBans(store, signals, limit);
     const sigSet = new Set(signals);
+    const provenance = opts.provenance?.snapshot();
+    const review = opts.review?.snapshot();
     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)))
+        if (opts.provenance && !opts.includeUntrusted && provenance?.get(String(g.asset_id))?.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.
         // 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'))
+        const reviewRecord = review?.get(String(g.asset_id));
+        if (opts.review && reviewRecord !== undefined && reviewRecord.state !== 'approved'
+            && (!opts.includeProbation || reviewRecord.state === 'rejected'))
             continue;
         const geneId = typeof g['id'] === 'string' ? String(g['id']) : String(g.asset_id);
         const assetId = String(g.asset_id);
@@ -104,18 +108,20 @@ export async function assembleSelectionPool(store, signals, opts = {}) {
         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.
+            // #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
+            // the floor). Eligibility here is gated by trust/review/ban, not by skill provenance. Provenance is read from
+            // 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.
-            if (isDistilledGeneId(geneId)) {
+            const gsrc = geneGenerationSource(g, geneId);
+            if (gsrc === 'distilled' || gsrc === 'evolved') {
                 distilledFallback.push({
                     geneId,
                     assetId,
                     signalsMatch,
                     view: emptyLearningView(geneId),
                     reuseCount: 0,
+                    generationSource: gsrc,
                     ...(category ? { category } : {}),
                     ...(summary ? { summary } : {}),
                 });
@@ -145,7 +151,7 @@ export async function assembleSelectionPool(store, signals, opts = {}) {
     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))
+            if (!passesInjectedCandidateGates(h, opts, provenance, review))
                 continue;
             if (localIds.has(h.geneId))
                 continue; // a trusted local gene already covers this id
@@ -160,7 +166,10 @@ export async function assembleSelectionPool(store, signals, opts = {}) {
         }
     }
     for (const a of await store.list('AntiGene', limit)) {
-        if (opts.review && !opts.review.isApproved(String(a.asset_id)))
+        // AntiGene is negative memory that changes an autonomous prompt. Unlike legacy/cycle-authored Genes, it must
+        // never inherit ReviewLedger's backward-compatible "no record = approved" default: no ledger, no record,
+        // quarantined, and rejected all fail closed. Only an explicit human approval can enable warning injection.
+        if (review?.get(String(a.asset_id))?.state !== 'approved')
             continue;
         const trigger = asStrings(a['trigger']);
         const avoid = asStrings(a['avoid']);

package/dist/algo/capabilityCandidates.d.ts

@@ -1,3 +1,4 @@
+import type { ConversationCapabilityHit } from './conversationSniffer.js';
 /** The "five-question shape" of a capability proposal (ported verbatim from v1). */
 export interface FiveQuestionShape {
     title: string;
@@ -30,6 +31,7 @@ export interface ExtractCandidatesInput {
     toolCalls?: readonly string[];
     signals?: readonly string[];
     failedCapsules?: readonly FailedCapsuleLike[];
+    conversationHits?: readonly ConversationCapabilityHit[];
 }
 /**
  * Mine capability candidates from three sources (ported v1): repeated tool calls (>=3), active opportunity

package/dist/algo/capabilityCandidates.js

@@ -80,6 +80,11 @@ export function extractCapabilityCandidates(inp) {
         const title = `Repeated tool usage: ${tool}`;
         out.push(candidate('transcript', stableHash(title), title, signals, `Observed ${count} occurrences of tool call ${tool}.`, signalTags));
     }
+    // A2. Conversation sniffer hits: a transcript explicitly proved a reusable capability.
+    for (const hit of inp.conversationHits ?? []) {
+        const hitSignals = [...new Set([...(hit.signals ?? []), ...signals].map((s) => String(s)).filter(Boolean))];
+        out.push(candidate('transcript', stableHash('conversation:' + hit.id), hit.title || 'Verified reusable conversation capability', hitSignals, hit.evidence.length > 0 ? hit.evidence.slice(0, 2).join('; ') : hit.summary, [...new Set([...signalTags, ...expandSignals(hitSignals)])]));
+    }
     // B. Signal-mapped candidates: predefined defensive/opportunity signals.
     for (const sc of SIGNAL_CANDIDATES) {
         if (!signals.some((s) => s === sc.signal || s.startsWith(sc.signal + ':')))

package/dist/algo/conversationSniffer.d.ts

@@ -0,0 +1,18 @@
+import type { SignalSourceTurn } from '../signals/extractor.js';
+export interface ConversationSnifferTurn extends SignalSourceTurn {
+    role?: string;
+}
+export interface ConversationCapabilityHit {
+    id: string;
+    title: string;
+    summary: string;
+    signals: string[];
+    evidence: string[];
+    score: number;
+    reasons: string[];
+    toolCalls: string[];
+}
+export interface ConversationSnifferOptions {
+    maxHits?: number;
+}
+export declare function sniffConversationCapabilities(turns: readonly ConversationSnifferTurn[], opts?: ConversationSnifferOptions): ConversationCapabilityHit[];

package/dist/algo/conversationSniffer.js

@@ -0,0 +1,132 @@
+import { createHash } from 'node:crypto';
+import { redactString } from '../hub/sanitize.js';
+const REUSABLE_RE = /\b(reusable|repeatable|workflow|playbook|runbook|capability|procedure|pattern|recipe|documented|future runs?|next time|can reuse|reuse this)\b|可复用|复用|能力|流程|工作流/i;
+const PROOF_RE = /\b(validated|verified|passed|green|success(?:ful|fully)?|succeeded|works?|completed|published|uploaded|recorded:true|exit code:?\s*0|all tests passed)\b|验证|通过|成功|已发布|可用/i;
+const FAILURE_RE = /\b(failed|failure|error|exception|traceback|exit code:?\s*[1-9]|not working|unable to)\b|失败|错误|报错/i;
+const EXIT_ZERO_RE = /\bexit code:?\s*0\b/i;
+const EXIT_NON_ZERO_RE = /\bexit code:?\s*[1-9]\d*\b/i;
+const DOMAIN_TOKENS = [
+    [/\b(lark|feishu|飞书)\b/i, 'lark'],
+    [/\b(github|gh|pull request|bugbot)\b/i, 'github'],
+    [/\b(playwright|screenshot|visual)\b/i, 'playwright'],
+    [/\b(vitest|jest|test)\b/i, 'test'],
+    [/\b(pnpm|npm|yarn)\b/i, 'package-manager'],
+    [/\b(hub|publish|marketplace)\b/i, 'hub-publish'],
+    [/\b(release|checksum|sha256)\b/i, 'release'],
+    [/\b(api|http|endpoint)\b/i, 'api'],
+    [/\b(document|docs?|markdown)\b/i, 'docs'],
+];
+function cleanText(value, max = 220) {
+    const text = redactString(String(value ?? '').replace(/\s+/g, ' ').trim());
+    return text.length > max ? `${text.slice(0, max - 3)}...` : text;
+}
+function turnText(turn) {
+    return cleanText([turn.text, turn.toolResult, turn.errorMessage].filter(Boolean).join('\n'), 500);
+}
+function stableId(parts) {
+    return `conversation_capability_${createHash('sha1').update(JSON.stringify(parts), 'utf8').digest('hex').slice(0, 12)}`;
+}
+function normalizeSignal(value) {
+    return value.toLowerCase().replace(/[^a-z0-9]+/g, '_').replace(/^_+|_+$/g, '').slice(0, 48);
+}
+function collectToolCalls(turns) {
+    const seen = new Set();
+    for (const turn of turns) {
+        const tool = cleanText(turn.toolName ?? '', 80);
+        if (tool)
+            seen.add(tool);
+    }
+    return [...seen].slice(0, 8);
+}
+function domainSignals(text, toolCalls) {
+    const out = new Set();
+    for (const [re, signal] of DOMAIN_TOKENS) {
+        if (re.test(text))
+            out.add(signal);
+    }
+    for (const tool of toolCalls) {
+        const normalized = normalizeSignal(tool);
+        if (normalized)
+            out.add(normalized);
+    }
+    return [...out].slice(0, 6);
+}
+function isToolTurn(turn) {
+    return turn.role === 'tool' || Boolean(turn.toolName);
+}
+function classifyToolOutcome(turn) {
+    const text = turnText(turn);
+    if (EXIT_NON_ZERO_RE.test(text))
+        return 'failure';
+    if (EXIT_ZERO_RE.test(text))
+        return 'success';
+    if (PROOF_RE.test(text) && !FAILURE_RE.test(text))
+        return 'success';
+    if (FAILURE_RE.test(text))
+        return 'failure';
+    return 'unknown';
+}
+function hasTerminalSuccessfulToolRun(turns) {
+    let lastDecisive = 'unknown';
+    for (const turn of turns) {
+        if (!isToolTurn(turn))
+            continue;
+        const outcome = classifyToolOutcome(turn);
+        if (outcome !== 'unknown')
+            lastDecisive = outcome;
+    }
+    return lastDecisive === 'success';
+}
+function pickEvidence(turns, matcher, max = 3) {
+    const evidence = [];
+    for (const turn of turns) {
+        const text = turnText(turn);
+        if (!text || !matcher.test(text))
+            continue;
+        evidence.push(cleanText(text, 180));
+        if (evidence.length >= max)
+            break;
+    }
+    return evidence;
+}
+function pickSummary(turns, reusableEvidence, proofEvidence) {
+    const assistant = turns
+        .filter((turn) => turn.role === 'assistant' && !turn.isMeta)
+        .map(turnText)
+        .find((text) => text.length >= 40 && (REUSABLE_RE.test(text) || PROOF_RE.test(text)));
+    return cleanText(assistant ?? reusableEvidence[0] ?? proofEvidence[0] ?? 'Verified reusable conversation capability.', 180);
+}
+export function sniffConversationCapabilities(turns, opts = {}) {
+    const usableTurns = turns.filter((turn) => !turn.isMeta);
+    if (usableTurns.length === 0)
+        return [];
+    const allText = usableTurns.map(turnText).filter(Boolean).join('\n');
+    if (!allText.trim())
+        return [];
+    const reusableEvidence = pickEvidence(usableTurns, REUSABLE_RE);
+    const proofEvidence = pickEvidence(usableTurns, PROOF_RE);
+    if (reusableEvidence.length === 0 || proofEvidence.length === 0)
+        return [];
+    const failureOnly = FAILURE_RE.test(allText) && !PROOF_RE.test(allText);
+    if (failureOnly)
+        return [];
+    if (!hasTerminalSuccessfulToolRun(usableTurns))
+        return [];
+    const toolCalls = collectToolCalls(usableTurns);
+    const domain = domainSignals(allText, toolCalls);
+    const signals = [...new Set(['reusable_capability', 'verified_workflow', ...domain])].slice(0, 8);
+    const score = 4 + Math.min(2, reusableEvidence.length) + Math.min(2, proofEvidence.length) + Math.min(2, toolCalls.length);
+    const summary = pickSummary(usableTurns, reusableEvidence, proofEvidence);
+    const titleSignal = domain[0] ?? 'verified workflow';
+    const hit = {
+        id: stableId({ summary, signals, evidence: [...reusableEvidence, ...proofEvidence].slice(0, 4) }),
+        title: `Verified reusable capability: ${titleSignal}`,
+        summary,
+        signals,
+        evidence: [...reusableEvidence, ...proofEvidence].slice(0, 4),
+        score,
+        reasons: ['reusable_marker', 'proof_marker', ...(toolCalls.length > 0 ? ['tool_evidence'] : [])],
+        toolCalls,
+    };
+    return [hit].slice(0, opts.maxHits ?? 1);
+}

package/dist/algo/cycleEngine.d.ts

@@ -10,11 +10,13 @@ import type { PersonalityStore } from '../personality/store.js';
 import { type ResolutionStatus } from './solidify.js';
 import type { ProofOfWork } from '../schema/proofOfWork.js';
 import { type ClassifyRecentEvent } from './cycleFailureClassifier.js';
+import type { MemoryGraphGeneEvidence } from './memoryGraph.js';
 export interface TriggerEval {
     trigger: boolean;
     reasons: string[];
     valueScore: number;
 }
+export type ExecutionFailureKind = 'spawn_failed' | 'timeout' | 'cancelled' | 'permission_denied' | 'non_zero_exit' | 'invalid_output' | 'runtime_error';
 export interface ExecutionResult {
     outcome: {
         status: 'success' | 'failed';
@@ -23,6 +25,9 @@ export interface ExecutionResult {
     };
     proofOfWork?: ProofOfWork;
     strongEvidence?: boolean;
+    /** Structured runner failure metadata. Safe to persist; unlike sessionLog it contains no transcript text. */
+    failureKind?: ExecutionFailureKind;
+    exitCode?: number | null;
     /**
      * The agent run's transcript (stdout, plus stderr when present), attached by the execution layer on a FAILED
      * outcome. It is the host-side context classifyCycleFailure needs to reach the host_no_transcript /
@@ -102,6 +107,8 @@ export interface CycleInput {
     distilledFallback?: readonly GeneCandidateInput[];
     /** Advisory-only AntiGene warnings matched upstream for this cycle's base signals. */
     antiWarnings?: readonly AntiWarning[];
+    /** Bounded structured outcome evidence for explainability and prompt enrichment. */
+    memoryEvidence?: readonly MemoryGraphGeneEvidence[];
     /**
      * Optional triage context for the cycle.failed event (PORT v1 #279 issue-reporter half). When the caller can
      * supply a session transcript or a list of recent failed cycles, classifyCycleFailure runs and the resulting
@@ -125,11 +132,15 @@ export interface CycleResult {
     cycleId: string;
     triggered: boolean;
     finalStage: CycleStage;
+    /** Real CycleEngine returns this on every path; optional keeps injected legacy engines source-compatible. */
+    producedValue?: boolean;
     decision?: GeneDecision;
     mutation?: Mutation;
     capsule?: Capsule;
     event?: EvolutionEvent;
     resolutionStatus?: ResolutionStatus;
+    failureKind?: ExecutionFailureKind;
+    exitCode?: number | null;
     reasons: string[];
 }
 /**

package/dist/algo/cycleEngine.js

@@ -183,6 +183,8 @@ export class CycleEngine {
             // Locality must recognise V2's real gene prefix `gene_distilled_` (isDistilledGeneId), not just the
             // V1-only `gene_auto_` / content-hash `sha256:` forms — otherwise this gate stays shut for every real V2
             // gene and classifyCycleFailure never runs (mirror of isLocalGeneratedGene in cycleFailureClassifier.ts).
+            // NB the prefix is now a NAMESPACE marker, not a provenance tag (the authoritative source is generation_meta,
+            // V1 #302); this call site only has a gene id, so it falls back to the prefix.
             const localCurrentGene = current?.geneId !== undefined && (isDistilledGeneId(current.geneId) || /^sha256:/.test(current.geneId) || /^gene_auto_/.test(current.geneId));
             // Run classification when we have ANY host context (an exec transcript or an injected failureContext) OR a
             // local-gene blast to judge; otherwise stay default-open (unclassified, no payload).
@@ -198,6 +200,10 @@ export class CycleEngine {
             });
             return r.reason ? { failure_class: r.failureClass, failure_class_reason: r.reason } : { failure_class: r.failureClass };
         };
+        const executionMetadata = (exec) => ({
+            ...(exec.failureKind !== undefined ? { failureKind: exec.failureKind } : {}),
+            ...(exec.exitCode !== undefined ? { exitCode: exec.exitCode } : {}),
+        });
         const strategy = resolveStrategy({ name: input.strategyName, signals: cycleSignals, cycleCount: historyCycleCount(ingestor, 1000, input.cycleId) });
         const cycleCategory = categoryForStrategy(input.category, strategy);
         let stage = 'none';
@@ -224,7 +230,7 @@ export class CycleEngine {
         if (!trig.trigger) {
             await ingestor.ingest({ type: 'cycle.aborted', human: { title: `cycle ${input.cycleId} 抑制` }, payload: { cycleId: input.cycleId, reasons: trig.reasons } });
             advance('aborted');
-            return { cycleId: input.cycleId, triggered: false, finalStage: stage, reasons: trig.reasons };
+            return { cycleId: input.cycleId, triggered: false, finalStage: stage, producedValue: false, reasons: trig.reasons };
         }
         // 选 gene(可解释决策). Exploration: when recent cycles plateau, enable drift to escape local optima.
         const recentOutcomes = recentCycleOutcomes(ingestor, 100);
@@ -295,11 +301,11 @@ export class CycleEngine {
             const epi = epigeneticPenaltyForIds(candidateIds(c), envKey, geneOutcomes);
             return epi > 0 ? { ...c, epigeneticPenalty: epi } : c;
         });
-        const decision = (await this.deps.selection.run({ signals: baseSignals, candidates, floor: input.selectionFloor, ...(input.forcedGeneId !== undefined ? { forcedGeneId: input.forcedGeneId } : {}), ...(exploration ? { exploration } : {}), ...(distilledFallback.length > 0 ? { distilledFallback } : {}), ...(input.antiWarnings && input.antiWarnings.length > 0 ? { antiWarnings: input.antiWarnings } : {}) }, { now, cycleId: input.cycleId, ...(this.deps.rng ? { rng: this.deps.rng } : {}) }));
+        const decision = (await this.deps.selection.run({ signals: baseSignals, candidates, floor: input.selectionFloor, ...(input.forcedGeneId !== undefined ? { forcedGeneId: input.forcedGeneId } : {}), ...(exploration ? { exploration } : {}), ...(distilledFallback.length > 0 ? { distilledFallback } : {}), ...(input.antiWarnings && input.antiWarnings.length > 0 ? { antiWarnings: input.antiWarnings } : {}), ...(input.memoryEvidence && input.memoryEvidence.length > 0 ? { memoryEvidence: input.memoryEvidence } : {}) }, { now, cycleId: input.cycleId, ...(this.deps.rng ? { rng: this.deps.rng } : {}) }));
         await ingestor.ingest({
             type: 'decision.gene_selected',
             human: { title: `选 gene ${decision.selectedGeneId ?? '(innovate)'}`, why: decision.candidates.map((c) => `${c.geneId}:${c.score.toFixed(3)}`).join(', ') || '无候选→innovate' },
-            payload: { cycleId: input.cycleId, selectedGeneId: decision.selectedGeneId, ...(decision.selectedAssetId ? { selectedAssetId: decision.selectedAssetId } : {}), candidates: decision.candidates, ...(decision.antiWarnings && decision.antiWarnings.length > 0 ? { antiWarnings: decision.antiWarnings } : {}), weightsVersion: decision.weightsVersion, strategy: decision.strategyName, strategyPreset: strategy.name, ...(plateau.active ? { plateau } : {}), ...(inertBanned.size > 0 ? { inertBanned: [...inertBanned] } : {}) },
+            payload: { cycleId: input.cycleId, selectedGeneId: decision.selectedGeneId, ...(decision.selectedAssetId ? { selectedAssetId: decision.selectedAssetId } : {}), ...(decision.selectedReason ? { selectedReason: decision.selectedReason } : {}), candidates: decision.candidates, ...(decision.antiWarnings && decision.antiWarnings.length > 0 ? { antiWarnings: decision.antiWarnings } : {}), ...(decision.memoryEvidence && decision.memoryEvidence.length > 0 ? { memoryEvidence: decision.memoryEvidence } : {}), weightsVersion: decision.weightsVersion, strategy: decision.strategyName, strategyPreset: strategy.name, ...(plateau.active ? { plateau } : {}), ...(inertBanned.size > 0 ? { inertBanned: [...inertBanned] } : {}) },
         });
         advance('gene_selected');
         const geneId = decision.selectedGeneId ?? 'ad-hoc';
@@ -329,7 +335,7 @@ export class CycleEngine {
             await ingestor.ingest({ type: 'cycle.failed', human: { title: `cycle ${input.cycleId} 执行抛错` }, payload: { cycleId: input.cycleId, error: msg, gene: geneId, env: envKey, ...failureClassPayload({ geneId }, msg) } });
             advance('failed');
             await recordPersonalityOutcome('failed', null);
-            return { cycleId: input.cycleId, triggered: true, finalStage: stage, decision, mutation, reasons: [...reasons, `执行异常: ${msg}`] };
+            return { cycleId: input.cycleId, triggered: true, finalStage: stage, producedValue: false, decision, mutation, reasons: [...reasons, `执行异常: ${msg}`] };
         }
         if (input.solidifyPermit) {
             let permit;
@@ -358,12 +364,13 @@ export class CycleEngine {
                         reason: permit.reason,
                         gene: geneId,
                         env: envKey,
+                        ...executionMetadata(exec),
                         ...failureClassPayload({ geneId }),
                     },
                 });
                 advance('failed');
                 await recordPersonalityOutcome('failed', null);
-                return { cycleId: input.cycleId, triggered: true, finalStage: stage, decision, mutation, reasons: [...reasons, reason] };
+                return { cycleId: input.cycleId, triggered: true, finalStage: stage, producedValue: false, decision, mutation, ...executionMetadata(exec), reasons: [...reasons, reason] };
             }
         }
         // solidify → Capsule
@@ -392,6 +399,7 @@ export class CycleEngine {
                     outcome: exec.outcome,
                     gene: geneId,
                     env: envKey,
+                    ...executionMetadata(exec),
                     // Only forward blast radius as a no-op signal when it was measured from a git_diff proof. solidify.ts
                     // forces blast to {0,0} for non-git_diff proofs (artifact_hash/external_receipt/tool_call_trace),
                     // where {0,0} means "blast unknown", NOT "no change" — forwarding it would mis-classify a productive
@@ -412,6 +420,6 @@ export class CycleEngine {
         }
         // 人格统计回写(用途②): 用本轮真实 outcome/score 回写当轮人格桶, 供下一轮自然选择靠拢. 未注入 ⇒ no-op.
         await recordPersonalityOutcome(exec.outcome.status, exec.outcome.score);
-        return { cycleId: input.cycleId, triggered: true, finalStage: stage, decision, mutation, capsule: sol.capsule, event, resolutionStatus: sol.resolutionStatus, reasons };
+        return { cycleId: input.cycleId, triggered: true, finalStage: stage, producedValue: sol.producedValue, decision, mutation, capsule: sol.capsule, event, resolutionStatus: sol.resolutionStatus, ...executionMetadata(exec), reasons };
     }
 }

package/dist/algo/cycleFailureClassifier.d.ts

@@ -1,5 +1,5 @@
 /** Bucket the failure falls into. unclassified = default-open (treat as a real evolver bug worth filing).
- *  Bucket string matches V1 (EvoMap/evolver-private-dev#279 commit a89e123e) byte-for-byte so wire / UI
+ *  Bucket string matches V1 byte-for-byte so wire / UI
  *  consumers can branch on the same value regardless of producer. */
 export type CycleFailureClass = 'host_no_transcript' | 'host_provider_error' | 'local_gene_no_blast' | 'unclassified';
 /** Shape of a recent cycle event the classifier reads. Loose so callers can pass partial DTOs. */

package/dist/algo/cycleFailureClassifier.js

@@ -12,13 +12,17 @@
 import { isDistilledGeneId } from './geneIntake.js';
 // "[NO SESSION LOGS FOUND]" et al. — the host gave evolver nothing to evolve from.
 const HOST_NO_TRANSCRIPT_RE = /\[no session logs? found\]|no session log|no transcript/i;
+// Interactive runner gates can stop execution before the provider is invoked. They still belong to the
+// host_provider_error compatibility bucket because the local gene never had a chance to run.
+const HOST_RUNNER_ERR_RE = /Workspace Trust Required/i;
 // Host LLM-provider errors. None of these strings are emitted by evolver core (v1 #279 verified the same;
 // keeping the regex byte-for-byte equivalent), so their presence means the host Agent's provider call failed.
-const HOST_PROVIDER_ERR_RE = /\bLLM ERROR\b|\bMaxTokens\b|field MaxTokens|max_tokens[^\n]{0,24}invalid|insufficient_quota|invalid_api_key|\brate limit(?:ed| exceeded)?\b|quota exceeded|context length exceeded|maximum context length/i;
+const HOST_PROVIDER_ERR_RE = /\bLLM ERROR\b|\bMaxTokens\b|field MaxTokens|max_tokens[^\n]{0,24}invalid|insufficient_quota|invalid_api_key|\brate limit(?:ed| exceeded)?\b|quota exceeded|context length exceeded|maximum context length|disabled Claude subscription access|Use an Anthropic API key|not authenticated|authentication required|login required|not logged in/i;
 // Locality prefixes a "locally-generated" gene id can carry:
-//  - `gene_distilled_` — the ONLY prefix V2 actually mints (geneIntake.DISTILLED_ID_PREFIX,
-//    surfaced via isDistilledGeneId). Without this the whole `local_gene_no_blast` bucket never
-//    fired for real V2 genes (they all carry this prefix). Reuse the single-source-of-truth helper.
+//  - `gene_distilled_` — the namespace V2 mints for every intaken gene (geneIntake.DISTILLED_ID_PREFIX,
+//    surfaced via isDistilledGeneId). NB this is a NAMESPACE marker now, not a provenance tag: the authoritative
+//    source is generation_meta (V1 #302, read via geneGenerationSource), but this call site only has a gene id, so
+//    it falls back to the prefix. Without this the whole `local_gene_no_blast` bucket never fired for real V2 genes.
 //  - `gene_auto_` — V1-only legacy form (V2 never produces it); kept so V1-shaped inputs still match.
 //  - `sha256:` — a content asset_id (not a logical gene id); kept for back-compat / loose callers.
 function isLocalGeneratedGene(geneId) {
@@ -60,7 +64,11 @@ export function classifyCycleFailure(opts) {
     if (hasSessionLog && (!log.trim() || HOST_NO_TRANSCRIPT_RE.test(log))) {
         return { failureClass: 'host_no_transcript', reason: 'no session transcript to evolve from' };
     }
-    // (b) Host LLM-provider error surfaced in the transcript.
+    // (b) Host runner preflight or LLM-provider error surfaced in the transcript.
+    const runner = hasSessionLog ? log.match(HOST_RUNNER_ERR_RE) : null;
+    if (runner) {
+        return { failureClass: 'host_provider_error', reason: `host runner error: ${String(runner[0]).slice(0, 60)}` };
+    }
     const prov = hasSessionLog ? log.match(HOST_PROVIDER_ERR_RE) : null;
     if (prov) {
         return { failureClass: 'host_provider_error', reason: `host LLM-provider error: ${String(prov[0]).slice(0, 60)}` };

package/dist/algo/geneIntake.d.ts

@@ -1,10 +1,19 @@
-import { type Gene } from '../wire/index.js';
+import { type Gene, type GenerationSource } from '../wire/index.js';
 /**
- * True when a gene id is a distilled (skill-derived) gene. Single source of truth for the prefix check — also
- * consumed by candidate assembly / selection to recognise the broadly-applicable distilled genes that may be
- * reused as a last-resort fallback when no gene matches the live signals (ported from v1 #97).
+ * True when a gene id is in the `gene_distilled_` namespace. NB this prefix is now a NAMESPACE marker, NOT a
+ * provenance tag: v1 used it to mean "skill-derived" (auto-evolved genes were `gene_auto_`), but v2's intakeGene
+ * tags EVERY intaken gene this way regardless of origin. The authoritative provenance is {@link geneGenerationSource};
+ * this prefix check remains as a back-compat fallback for legacy pooled genes that predate generation_meta, and for
+ * call sites that only have a gene id (not the full record).
  */
 export declare function isDistilledGeneId(id: string | undefined | null): boolean;
+/**
+ * The authoritative gene-generation source: read `generation_meta.source` from a gene-shaped record (V1 #302). Falls
+ * back to the id-prefix namespace when the record carries no generation_meta (legacy pooled genes predate the field),
+ * returning 'distilled' for a `gene_distilled_` id and 'manual' otherwise — so the fallback never claims a higher
+ * provenance tier than the prefix can vouch for. `null` means "undetermined" (no record, no recognizable id).
+ */
+export declare function geneGenerationSource(gene: Record<string, unknown> | null | undefined, geneId?: string | null): GenerationSource | null;
 export interface GeneCandidate {
     id?: string;
     category?: string;
@@ -19,6 +28,7 @@ export interface GeneCandidate {
     validation?: readonly string[];
     routing_hint?: unknown;
     tool_policy?: unknown;
+    generation_meta?: unknown;
 }
 /** Minimal shape of an existing gene needed for dedup. */
 export interface ExistingGeneRef {

package/dist/algo/geneIntake.js

@@ -5,20 +5,44 @@
 // signals fully overlap an existing one (dedup, so the pool does not grow redundant). The gene's CONTENT
 // is generated upstream (the agent runtime / a distillation prompt — generative, out of core scope); this
 // slice is the structural gate. Pairs with capabilityCandidates (which proposes what to distill).
-import { computeAssetId, validateWire, SCHEMA_VERSION, normalizeRoutingHint, normalizeToolPolicy, stripGeneHints, } from '../wire/index.js';
+import { computeAssetId, validateWire, SCHEMA_VERSION, normalizeRoutingHint, normalizeToolPolicy, normalizeGenerationMeta, stripGeneHints, } from '../wire/index.js';
 const VALID_CATEGORIES = ['repair', 'optimize', 'innovate', 'explore'];
 const DEFAULT_FORBIDDEN_PATHS = ['.git', 'node_modules'];
 const DEFAULT_MAX_FILES = 12;
 /** Id prefix every distilled (skill-derived) gene carries. Recognised via {@link isDistilledGeneId}. */
 const DISTILLED_ID_PREFIX = 'gene_distilled_';
 /**
- * True when a gene id is a distilled (skill-derived) gene. Single source of truth for the prefix check — also
- * consumed by candidate assembly / selection to recognise the broadly-applicable distilled genes that may be
- * reused as a last-resort fallback when no gene matches the live signals (ported from v1 #97).
+ * True when a gene id is in the `gene_distilled_` namespace. NB this prefix is now a NAMESPACE marker, NOT a
+ * provenance tag: v1 used it to mean "skill-derived" (auto-evolved genes were `gene_auto_`), but v2's intakeGene
+ * tags EVERY intaken gene this way regardless of origin. The authoritative provenance is {@link geneGenerationSource};
+ * this prefix check remains as a back-compat fallback for legacy pooled genes that predate generation_meta, and for
+ * call sites that only have a gene id (not the full record).
  */
 export function isDistilledGeneId(id) {
     return typeof id === 'string' && id.startsWith(DISTILLED_ID_PREFIX);
 }
+/**
+ * The authoritative gene-generation source: read `generation_meta.source` from a gene-shaped record (V1 #302). Falls
+ * back to the id-prefix namespace when the record carries no generation_meta (legacy pooled genes predate the field),
+ * returning 'distilled' for a `gene_distilled_` id and 'manual' otherwise — so the fallback never claims a higher
+ * provenance tier than the prefix can vouch for. `null` means "undetermined" (no record, no recognizable id).
+ */
+export function geneGenerationSource(gene, geneId) {
+    const meta = gene?.['generation_meta'];
+    if (meta && typeof meta === 'object') {
+        const src = meta['source'];
+        if (typeof src === 'string' && (src === 'evolved' || src === 'distilled' || src === 'manual'))
+            return src;
+    }
+    // Legacy fallback: a `gene_distilled_` id is at best a distilled gene (v2 minted it for ALL intake sources, so it
+    // cannot be trusted as "evolved"); any other id is treated as manual (human-authored / externally seeded).
+    const id = geneId ?? (typeof gene?.['id'] === 'string' ? String(gene['id']) : null);
+    if (id && isDistilledGeneId(id))
+        return 'distilled';
+    if (id)
+        return 'manual';
+    return null;
+}
 function fnv1a(s) {
     let h = 2166136261;
     for (let i = 0; i < s.length; i++) {
@@ -65,6 +89,9 @@ export function intakeGene(candidate, existing = []) {
     // absent when malformed/empty. The router / tool-gate reads absent === "no opinion".
     const routingHint = normalizeRoutingHint(candidate.routing_hint);
     const toolPolicy = normalizeToolPolicy(candidate.tool_policy);
+    // v2-delta provenance + quality metadata (v1 #302): normalized so a candidate carrying it lands canonical,
+    // dropped to absent when malformed/no-recognized-source.
+    const generationMeta = normalizeGenerationMeta(candidate.generation_meta);
     const gene = {
         type: 'Gene',
         schema_version: SCHEMA_VERSION,
@@ -81,16 +108,17 @@ export function intakeGene(candidate, existing = []) {
         ...(candidate.preconditions ? { preconditions: [...candidate.preconditions] } : {}),
         ...(routingHint ? { routing_hint: routingHint } : {}),
         ...(toolPolicy ? { tool_policy: toolPolicy } : {}),
+        ...(generationMeta ? { generation_meta: generationMeta } : {}),
         asset_id: '',
     };
-    // asset_id folds in the hints (intake's own canonical shape — gep-sdk canonicalize hashes every own key).
-    // NB: this is NOT byte-equal to what v1's createGene would hash for the same logical gene — v1 always emits
+    // asset_id folds in the hints + generation_meta (intake's own canonical shape — gep-sdk canonicalize hashes every
+    // own key). NB: this is NOT byte-equal to what v1's createGene would hash for the same logical gene — v1 always emits
     // routing_hint/tool_policy:null plus empty epigenetic_marks/learning_history/anti_patterns/preconditions that
     // v2 intake omits, so the canonical shapes differ. Self-consistent here; not a cross-impl parity guarantee.
     gene.asset_id = computeAssetId(gene) ?? '';
-    // Structural gate validates the gep-sdk-known CORE. routing_hint / tool_policy are v2-delta (pending a
-    // gene-schema bump), so strip them before the check — else additionalProperties:false rejects the gene at
-    // intake. The full hinted gene stays schema-invalid until the SDK catches up — surfaced by the advisory
+    // Structural gate validates the gep-sdk-known CORE. routing_hint / tool_policy / generation_meta are v2-delta
+    // (pending a gene-schema bump), so strip them before the check — else additionalProperties:false rejects the
+    // gene at intake. The full hinted gene stays schema-invalid until the SDK catches up — surfaced by the advisory
     // validateWire preview (evolver_gep_build) and enforced by the hub on receipt, NOT by a local egress gate
     // (the publish/egress path is sanitize-only). Same v2-delta contract Capsule's proof_of_work had pre-1.11.0.
     const v = validateWire(stripGeneHints(gene));