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

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,10 +18,10 @@ 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) {
     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) {
@@ -79,13 +79,14 @@ 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 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.
@@ -104,18 +105,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 +148,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))
                 continue;
             if (localIds.has(h.geneId))
                 continue; // a trusted local gene already covers this id
@@ -160,7 +163,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 (!opts.review?.isExplicitlyApproved(String(a.asset_id)))
             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.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).

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));

package/dist/algo/geneSelection.d.ts

@@ -4,6 +4,7 @@ import { type GeneHealth } from './geneHealth.js';
 import type { GeneLearningView } from '../assetstore/learningHistory.js';
 import type { AssetRecord } from '../assetstore/provider.js';
 import { type ExplorationInput } from './exploration.js';
+import type { GenerationSource } from '../wire/index.js';
 /** 一个候选 gene 的选择期素材. */
 export interface GeneCandidateInput {
     geneId: string;
@@ -43,6 +44,11 @@ export interface GeneCandidateInput {
      * effect, so the factor is dormant until a caller injects the signal (default-off).
      */
     reuseAdjust?: number;
+    /**
+     * Authoritative provenance tag from Gene.generation_meta.source. The legacy `gene_distilled_` prefix remains a
+     * fallback only for old candidates that do not carry this field.
+     */
+    generationSource?: GenerationSource;
 }
 export interface SelectionInput {
     signals: readonly string[];

package/dist/algo/geneSelection.js

@@ -88,6 +88,14 @@ function matchesScoredIdentity(a, b) {
 function withoutCandidateIdentity(scored, c) {
     return scored.filter((s) => !matchesCandidateIdentity(s, c));
 }
+function isReusableGenerationSource(source) {
+    return source === 'distilled' || source === 'evolved';
+}
+function isReusableFallbackCandidate(c) {
+    if (c.generationSource !== undefined)
+        return isReusableGenerationSource(c.generationSource);
+    return isDistilledGeneId(c.geneId);
+}
 function forcedSelection(input, scored, scoreForcedFallback, floor) {
     const forcedGeneId = input.forcedGeneId?.trim();
     if (!forcedGeneId)
@@ -116,7 +124,7 @@ function forcedSelection(input, scored, scoreForcedFallback, floor) {
         forcedFallback.reasons.push('forced gene rejected: epigenetic suppression');
         return { scoredForChoice: scoredCandidatesOnly, forceRejected: true };
     }
-    if (!isDistilledGeneId(fallback.geneId)) {
+    if (!isReusableFallbackCandidate(fallback)) {
         forcedFallback.reasons.push('forced gene rejected: suppressed fallback');
         return { scoredForChoice: scoredCandidatesOnly, forceRejected: true };
     }
@@ -141,15 +149,15 @@ export const engineHealthSelection = {
         let selectedAssetId = forced.selectedAssetId ?? chosen?.assetId;
         if (!selectedGeneId) {
             // Issue #97 (ported from v1 selector.js): no candidate matched any live signal (every gene scored <= 0). Rather
-            // than fall straight through to a blind innovate, reuse a *distilled* gene if one is available. NB the prefix
-            // does NOT mean "skill-derived" in v2 the way it did in v1: v1 tagged only skill genes gene_distilled_ (auto-
-            // evolved genes were gene_auto_), but v2's intakeGene tags EVERY intaken gene gene_distilled_ (autoExec even
-            // intakes task strategies that way) and has no gene_auto_. So this pool is "any trusted/approved/non-suppressed
-            // pooled gene that does not match", not specifically skill-derived — the safety rests on the upstream gates
-            // (trust #30 / review #89-91 / signal-ban / inert-ban #195) plus the epigenetic skip below, not on a skill-
-            // provenance low-blast-radius assumption. We skip any distilled fallback epigenetically suppressed in this env;
-            // v2's event-log-derived epigeneticPenalty is the analog of v1's asset-mark hard suppression (related band, not
-            // the identical predicate). No usable distilled fallback → stay null so the caller still innovates (the contract).
+            // than fall straight through to a blind innovate, reuse a *distilled* (or evolved) gene if one is available.
+            // The fallback pool is built by candidateAssembly, which now filters by generation_meta.source ∈ {distilled,
+            // evolved} (V1 #302), falling back to the `gene_distilled_` id namespace for legacy genes. The id-prefix check
+            // below is a defense-in-depth filter for callers that bypass candidateAssembly; the authoritative provenance
+            // lives on generation_meta (see geneGenerationSource). The safety rests on the upstream gates (trust #30 /
+            // review #89-91 / signal-ban / inert-ban #195) plus the epigenetic skip below, not on a skill-provenance
+            // low-blast-radius assumption. We skip any distilled fallback epigenetically suppressed in this env; v2's
+            // event-log-derived epigeneticPenalty is the analog of v1's asset-mark hard suppression (related band, not the
+            // identical predicate). No usable distilled fallback → stay null so the caller still innovates (the contract).
             //
             // v1 #97 parity: the distilled fallback is a *no-signal-match* last resort — it must fire only when NOTHING
             // scored above zero, NOT merely when nothing cleared a positive `floor`. Otherwise a real but weak signal match
@@ -157,7 +165,7 @@ export const engineHealthSelection = {
             // keeps such a match. When candidates scored > 0 but below floor, defer to V2's floor policy (innovate).
             const noSignalMatch = !forced.forceRejected && forced.scoredForChoice.every((s) => s.score <= 0);
             const fb = noSignalMatch
-                ? (input.distilledFallback ?? []).find((c) => isDistilledGeneId(c.geneId) && (c.epigeneticPenalty ?? 0) === 0)
+                ? (input.distilledFallback ?? []).find((c) => isReusableFallbackCandidate(c) && (c.epigeneticPenalty ?? 0) === 0)
                 : undefined;
             if (fb) {
                 const fbScored = scoreCandidate(input.signals, fb);

package/dist/algo/index.d.ts

@@ -3,6 +3,7 @@ export * from './exploration.js';
 export * from './epigenetics.js';
 export * from './confidence.js';
 export * from './capabilityCandidates.js';
+export * from './conversationSniffer.js';
 export * from './geneIntake.js';
 export * from './candidateAssembly.js';
 export * from './genePromotion.js';

package/dist/algo/index.js

@@ -3,6 +3,7 @@ export * from './exploration.js';
 export * from './epigenetics.js';
 export * from './confidence.js';
 export * from './capabilityCandidates.js';
+export * from './conversationSniffer.js';
 export * from './geneIntake.js';
 export * from './candidateAssembly.js';
 export * from './genePromotion.js';

package/dist/assetstore/assetSyncLedger.d.ts

@@ -0,0 +1,28 @@
+import type { AssetKind } from './provider.js';
+export type AssetSyncSource = 'hub';
+export type AssetSyncScope = 'purchased' | 'published';
+export interface AssetSyncRecord {
+    assetId: string;
+    type: Extract<AssetKind, 'Gene' | 'Capsule'>;
+    source: AssetSyncSource;
+    scope: AssetSyncScope;
+    syncedAt: string;
+    remoteAssetId: string;
+    logicalId?: string;
+    status?: string;
+    forced?: true;
+    collisionWithAssetId?: string;
+}
+export declare class AssetSyncLedger {
+    private readonly now;
+    private readonly path;
+    private readonly index;
+    private loaded;
+    constructor(baseDir: string, now?: () => number);
+    append(rec: Omit<AssetSyncRecord, 'syncedAt'> & {
+        syncedAt?: string;
+    }): AssetSyncRecord;
+    get(assetId: string): AssetSyncRecord | null;
+    list(): AssetSyncRecord[];
+    private load;
+}