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

package/dist/schema/material.d.ts

@@ -21,7 +21,7 @@ export type Watermark = z.infer<typeof watermark>;
 export declare const material: z.ZodEffects<z.ZodObject<{
     materialId: z.ZodString;
     /** Runtime agent that produced a session/tool source. Absent for agent-agnostic origins (proxy trace), #95. */
-    sourceAgent: z.ZodOptional<z.ZodEnum<["claude-code", "codex", "cursor", "gemini", "kimi", "kiro", "opencode", "generic-chat"]>>;
+    sourceAgent: z.ZodOptional<z.ZodEnum<["claude-code", "codex", "cursor", "gemini", "antigravity", "kimi", "kiro", "opencode", "generic-chat"]>>;
     /** Origin class: a runtime agent session, or the proxy gateway's LLM trace (agent-agnostic), #95.
      *  Defaults to runtime_session so pre-#95 records (which only ever held sessions) parse unchanged. */
     sourceKind: z.ZodDefault<z.ZodEnum<["runtime_session", "proxy_trace"]>>;
@@ -76,7 +76,7 @@ export declare const material: z.ZodEffects<z.ZodObject<{
     consumerGroup: string;
     feedsMaterial: boolean;
     extensions: Record<string, unknown>;
-    sourceAgent?: "claude-code" | "codex" | "cursor" | "gemini" | "kimi" | "kiro" | "opencode" | "generic-chat" | undefined;
+    sourceAgent?: "claude-code" | "codex" | "cursor" | "gemini" | "antigravity" | "kimi" | "kiro" | "opencode" | "generic-chat" | undefined;
     payloadRef?: {
         path: string;
         sha256: string;
@@ -95,7 +95,7 @@ export declare const material: z.ZodEffects<z.ZodObject<{
     };
     capturedAt: string;
     consumerGroup: string;
-    sourceAgent?: "claude-code" | "codex" | "cursor" | "gemini" | "kimi" | "kiro" | "opencode" | "generic-chat" | undefined;
+    sourceAgent?: "claude-code" | "codex" | "cursor" | "gemini" | "antigravity" | "kimi" | "kiro" | "opencode" | "generic-chat" | undefined;
     sourceKind?: "runtime_session" | "proxy_trace" | undefined;
     payloadRef?: {
         path: string;
@@ -120,7 +120,7 @@ export declare const material: z.ZodEffects<z.ZodObject<{
     consumerGroup: string;
     feedsMaterial: boolean;
     extensions: Record<string, unknown>;
-    sourceAgent?: "claude-code" | "codex" | "cursor" | "gemini" | "kimi" | "kiro" | "opencode" | "generic-chat" | undefined;
+    sourceAgent?: "claude-code" | "codex" | "cursor" | "gemini" | "antigravity" | "kimi" | "kiro" | "opencode" | "generic-chat" | undefined;
     payloadRef?: {
         path: string;
         sha256: string;
@@ -139,7 +139,7 @@ export declare const material: z.ZodEffects<z.ZodObject<{
     };
     capturedAt: string;
     consumerGroup: string;
-    sourceAgent?: "claude-code" | "codex" | "cursor" | "gemini" | "kimi" | "kiro" | "opencode" | "generic-chat" | undefined;
+    sourceAgent?: "claude-code" | "codex" | "cursor" | "gemini" | "antigravity" | "kimi" | "kiro" | "opencode" | "generic-chat" | undefined;
     sourceKind?: "runtime_session" | "proxy_trace" | undefined;
     payloadRef?: {
         path: string;

package/dist/trace/trajectoryExport.js

@@ -1558,7 +1558,7 @@ function runtimeSessionId(input) {
         return explicit;
     const sourcePath = stringValue(input.sourcePath);
     const base = sourcePath.split(/[\\/]/).filter(Boolean).pop() ?? '';
-    return base.replace(/\.jsonl?$/i, '') || 'unknown';
+    return redactString(base.replace(/\.jsonl?$/i, '')) || 'unknown';
 }
 function nativeCallHasField(call, key) {
     return Object.prototype.hasOwnProperty.call(call, key);
@@ -1704,7 +1704,7 @@ export function buildCodingTrajectoryFromSessionLog(input) {
         session_id: sessionId,
         source_kind: 'runtime_session',
         source_agent: sourceAgent,
-        source_path: sourcePath,
+        source_path: redactString(sourcePath),
         ...(sessionModel ? { session_model: sessionModel } : {}),
         ...(provider !== sourceAgent ? { session_provider: provider } : {}),
         ...(sessionTools !== undefined ? { session_tools: redactRuntimeStructuredValue(sessionTools) } : {}),

package/dist/util/fileLock.d.ts

@@ -1,8 +1,15 @@
 export declare function syncSleep(ms: number): void;
 export declare class LockTimeoutError extends Error {
     readonly code = "LOCK_TIMEOUT";
-    constructor(lockPath: string);
+    constructor(_lockPath?: string);
 }
+export type UnsafeLockPathReason = 'symlink' | 'not_regular_file' | 'owner_too_large' | 'path_changed' | 'permission_denied' | 'invalid_owner';
+export declare class UnsafeLockPathError extends Error {
+    readonly reason: UnsafeLockPathReason;
+    readonly code = "UNSAFE_LOCK_PATH";
+    constructor(reason: UnsafeLockPathReason);
+}
+export declare const MAX_LOCK_OWNER_BYTES = 4096;
 export interface AcquireLockOptions {
     maxTries?: number;
     waitMs?: number;
@@ -21,4 +28,14 @@ export interface AcquireLockOptions {
  * synchronous critical sections (append-only writes).
  */
 export declare function acquireLock(lockPath: string, opts?: AcquireLockOptions): void;
-export declare function releaseLock(lockPath: string): void;
+export type ReleaseLockReason = 'released' | 'missing' | 'ownership_changed' | 'not_owned' | 'released_with_cleanup_error' | UnsafeLockPathReason | 'release_failed';
+export interface ReleaseLockResult {
+    released: boolean;
+    reason: ReleaseLockReason;
+}
+export declare function releaseLock(lockPath: string): ReleaseLockResult;
+export declare class LockReleaseError extends Error {
+    readonly reason: ReleaseLockReason;
+    readonly code = "LOCK_RELEASE_FAILED";
+    constructor(reason: ReleaseLockReason);
+}

package/dist/util/fileLock.js

@@ -1,5 +1,5 @@
 import { randomUUID } from 'node:crypto';
-import { readFileSync, renameSync, unlinkSync, writeFileSync } from 'node:fs';
+import { closeSync, constants, fstatSync, lstatSync, openSync, readSync, renameSync, unlinkSync, writeFileSync, } from 'node:fs';
 import { basename, dirname, join, resolve } from 'node:path';
 export function syncSleep(ms) {
     Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
@@ -7,11 +7,21 @@ export function syncSleep(ms) {
 const ownedLocks = new Map();
 export class LockTimeoutError extends Error {
     code = 'LOCK_TIMEOUT';
-    constructor(lockPath) {
-        super(`获取文件锁超时: ${lockPath}`);
+    constructor(_lockPath) {
+        super('获取文件锁超时');
         this.name = 'LockTimeoutError';
     }
 }
+export class UnsafeLockPathError extends Error {
+    reason;
+    code = 'UNSAFE_LOCK_PATH';
+    constructor(reason) {
+        super(`不安全的文件锁路径: ${reason}`);
+        this.reason = reason;
+        this.name = 'UnsafeLockPathError';
+    }
+}
+export const MAX_LOCK_OWNER_BYTES = 4096;
 function lockKey(lockPath) {
     return resolve(lockPath);
 }
@@ -24,6 +34,73 @@ function serializeOwner(owner) {
 function isErrno(error, code) {
     return typeof error === 'object' && error !== null && error.code === code;
 }
+function noFollowFlag() {
+    return constants['O_NOFOLLOW'] ?? 0;
+}
+function assertRegularOwnerStat(stat) {
+    if (stat.isSymbolicLink())
+        throw new UnsafeLockPathError('symlink');
+    if (!stat.isFile())
+        throw new UnsafeLockPathError('not_regular_file');
+    if (stat.size > BigInt(MAX_LOCK_OWNER_BYTES))
+        throw new UnsafeLockPathError('owner_too_large');
+}
+function currentOwnerStat(path) {
+    try {
+        const stat = lstatSync(path, { bigint: true });
+        assertRegularOwnerStat(stat);
+        return stat;
+    }
+    catch (error) {
+        if (isErrno(error, 'ENOENT'))
+            return null;
+        if (isErrno(error, 'EACCES') || isErrno(error, 'EPERM')) {
+            throw new UnsafeLockPathError('permission_denied');
+        }
+        throw error;
+    }
+}
+function readOwnerBounded(path) {
+    const before = currentOwnerStat(path);
+    if (before === null)
+        return null;
+    let fd;
+    try {
+        fd = openSync(path, constants.O_RDONLY | noFollowFlag());
+    }
+    catch (error) {
+        if (isErrno(error, 'ENOENT'))
+            return null;
+        if (isErrno(error, 'ELOOP'))
+            throw new UnsafeLockPathError('symlink');
+        if (isErrno(error, 'EACCES') || isErrno(error, 'EPERM')) {
+            throw new UnsafeLockPathError('permission_denied');
+        }
+        throw error;
+    }
+    try {
+        const opened = fstatSync(fd, { bigint: true });
+        assertRegularOwnerStat(opened);
+        const current = currentOwnerStat(path);
+        if (current === null || current.dev !== opened.dev || current.ino !== opened.ino) {
+            throw new UnsafeLockPathError('path_changed');
+        }
+        const buffer = Buffer.alloc(MAX_LOCK_OWNER_BYTES + 1);
+        let total = 0;
+        while (total < buffer.length) {
+            const read = readSync(fd, buffer, total, buffer.length - total, total);
+            if (read === 0)
+                break;
+            total += read;
+        }
+        if (total > MAX_LOCK_OWNER_BYTES)
+            throw new UnsafeLockPathError('owner_too_large');
+        return buffer.subarray(0, total).toString('utf8');
+    }
+    finally {
+        closeSync(fd);
+    }
+}
 /** True if pid is a live process (cross-platform via signal 0; EPERM = exists but owned by another user). */
 function pidAlive(pid) {
     if (!Number.isInteger(pid) || pid <= 0)
@@ -73,10 +150,13 @@ function parseOwner(raw) {
 /** Owner recorded in the lock file; null if missing/unparseable. */
 function lockOwner(lockPath) {
     try {
-        return parseOwner(readFileSync(lockPath, 'utf8'));
+        const raw = readOwnerBounded(lockPath);
+        return raw === null ? null : parseOwner(raw);
     }
     catch (error) {
-        if (isErrno(error, 'ENOENT'))
+        // A valid owner can release and another waiter can acquire between lstat/open/fstat. Treat that snapshot as
+        // transiently unavailable: callers remain conservative (no steal/delete) and the acquire loop retries.
+        if (error instanceof UnsafeLockPathError && error.reason === 'path_changed')
             return null;
         throw error;
     }
@@ -100,17 +180,30 @@ function removeFileIfExists(path) {
     }
 }
 function createLockFile(lockPath, owner, trackOwnership) {
-    try {
-        writeFileSync(lockPath, serializeOwner(owner), { flag: 'wx', mode: 0o600 });
-        if (trackOwnership)
-            ownedLocks.set(lockKey(lockPath), owner);
-        return true;
-    }
-    catch (error) {
-        if (isErrno(error, 'EEXIST'))
-            return false;
-        throw error;
+    for (let permissionAttempt = 0; permissionAttempt < 2; permissionAttempt++) {
+        try {
+            writeFileSync(lockPath, serializeOwner(owner), { flag: 'wx', mode: 0o600 });
+            if (trackOwnership)
+                ownedLocks.set(lockKey(lockPath), { owner, releasePending: false });
+            return true;
+        }
+        catch (error) {
+            if (isErrno(error, 'EEXIST'))
+                return false;
+            if (isErrno(error, 'EACCES') || isErrno(error, 'EPERM')) {
+                // Windows can report EPERM instead of EEXIST during contention. A regular owner is busy; if the owner
+                // disappeared before lstat, retry create once to distinguish that release race from a persistent ACL
+                // failure. Unsafe/inaccessible paths still throw from currentOwnerStat and remain fail closed.
+                if (currentOwnerStat(lockPath) !== null)
+                    return false;
+                if (permissionAttempt === 0)
+                    continue;
+                throw new UnsafeLockPathError('permission_denied');
+            }
+            throw error;
+        }
     }
+    throw new UnsafeLockPathError('permission_denied');
 }
 function tryAcquireMutationGuard(lockPath) {
     const guardPath = mutationGuardPath(lockPath);
@@ -185,6 +278,12 @@ function reclaimStaleLock(lockPath) {
  * synchronous critical sections (append-only writes).
  */
 export function acquireLock(lockPath, opts = {}) {
+    const pending = ownedLocks.get(lockKey(lockPath));
+    if (pending?.releasePending) {
+        const released = releaseLock(lockPath);
+        if (!released.released)
+            throw new LockReleaseError(released.reason);
+    }
     const maxTries = opts.maxTries ?? 300;
     const waitMs = opts.waitMs ?? 10;
     for (let i = 0; i < maxTries; i++) {
@@ -200,28 +299,64 @@ export function acquireLock(lockPath, opts = {}) {
         }
         syncSleep(waitMs);
     }
-    throw new LockTimeoutError(lockPath);
+    throw new LockTimeoutError();
 }
 export function releaseLock(lockPath) {
     const key = lockKey(lockPath);
-    const owner = ownedLocks.get(key);
-    if (owner === undefined)
-        return;
+    const owned = ownedLocks.get(key);
+    if (owned === undefined)
+        return { released: true, reason: 'not_owned' };
+    const failed = (reason) => {
+        owned.releasePending = true;
+        return { released: false, reason };
+    };
+    // Release must not use lockOwner(): that helper intentionally folds path_changed into a conservative null
+    // for acquire retries. Here, an inconclusive read marks a pending release so the next acquire can retry or
+    // surface LOCK_RELEASE_FAILED instead of silently timing out behind this process's own PID.
+    let raw;
     try {
-        if (!sameOwner(lockOwner(lockPath), owner))
-            return;
-        const releasedPath = sidecarPath(lockPath, 'released');
-        try {
-            renameSync(lockPath, releasedPath);
-        }
-        catch (error) {
-            if (isErrno(error, 'ENOENT'))
-                return;
-            throw error;
+        raw = readOwnerBounded(lockPath);
+    }
+    catch (error) {
+        return failed(error instanceof UnsafeLockPathError ? error.reason : 'release_failed');
+    }
+    if (raw === null) {
+        ownedLocks.delete(key);
+        return { released: true, reason: 'missing' };
+    }
+    const current = parseOwner(raw);
+    if (current === null)
+        return failed('invalid_owner');
+    if (!sameOwner(current, owned.owner)) {
+        ownedLocks.delete(key);
+        return { released: true, reason: 'ownership_changed' };
+    }
+    const releasedPath = sidecarPath(lockPath, 'released');
+    try {
+        renameSync(lockPath, releasedPath);
+    }
+    catch (error) {
+        if (isErrno(error, 'ENOENT')) {
+            ownedLocks.delete(key);
+            return { released: true, reason: 'missing' };
         }
+        return failed('release_failed');
+    }
+    ownedLocks.delete(key);
+    try {
         removeFileIfExists(releasedPath);
     }
-    finally {
-        ownedLocks.delete(key);
+    catch {
+        return { released: true, reason: 'released_with_cleanup_error' };
+    }
+    return { released: true, reason: 'released' };
+}
+export class LockReleaseError extends Error {
+    reason;
+    code = 'LOCK_RELEASE_FAILED';
+    constructor(reason) {
+        super(`文件锁释放未完成: ${reason}`);
+        this.reason = reason;
+        this.name = 'LockReleaseError';
     }
 }

package/dist/wire/geneHints.d.ts

@@ -34,13 +34,45 @@ export interface GeneToolPolicy {
     deny?: string[];
     severity?: ToolPolicySeverity;
 }
+/**
+ * Provenance classification (V1 #302 classifyProvenance, aligned with TaskGenome Bench §3.1): a Gene's value
+ * depends on WHERE it came from, not on being short. The three tiers:
+ *   evolved   -- distilled from a real solve -> fail -> mutate -> pass trajectory; beats Skills (+8.7..+15.5pp)
+ *   distilled -- transcribed from reference/teacher text with no real failing trajectory; WORSE than Skills (-3.2..-11.2pp)
+ *   manual    -- pure human transcription, no execution evidence at all
+ * The high-value payload of an evolved Gene is the corrective_insight that flipped the outcome.
+ */
+export declare const GENERATION_SOURCES: readonly ["evolved", "distilled", "manual"];
+export type GenerationSource = (typeof GENERATION_SOURCES)[number];
+export interface GeneGenerationHeuristics {
+    strategy_steps?: number;
+    avoid_count?: number;
+    validation_declared_count?: number;
+    validation_runnable_count?: number;
+    signals_extracted?: number;
+    preconditions_extracted?: number;
+    trajectory_depth?: number;
+    has_corrective_insight?: boolean;
+}
+/**
+ * The full provenance + quality metadata block (V1 `gene._source`). Lives on Gene as the v2-delta field
+ * `generation_meta`. `source` is the only required key; the rest is descriptive for reviewers / future
+ * governance. `quality_score` is a coarse [0,1] tier-anchored score (evolved 0.7 / distilled 0.4 / manual 0.3
+ * baseline + bonuses); `overcame_errors` is the mutation_log copy that the trajectory overcame.
+ */
+export interface GenerationMeta {
+    source: GenerationSource;
+    quality_score?: number;
+    quality_heuristics?: GeneGenerationHeuristics;
+    overcame_errors?: string[];
+}
 /**
  * The v2-delta hint field names, in one place — the intake gate strips these before the gep-sdk schema check.
  * IMPORTANT: when a gep-sdk gene-schema bump makes one of these first-class, REMOVE it from this list in the
  * same change. Otherwise intakeGene keeps stripping a now-validated field before validateWire (fail-open — the
  * field's new schema constraints go unchecked at intake) while asset_id still commits it.
  */
-export declare const GENE_HINT_FIELDS: readonly ["routing_hint", "tool_policy"];
+export declare const GENE_HINT_FIELDS: readonly ["routing_hint", "tool_policy", "generation_meta"];
 /**
  * Normalize an arbitrary routing_hint fragment to a strict { tier?, reasoning_level? } object, or null.
  * Unknown enum values are dropped (a stray tier would fail the consumer's exhaustive match and route as if
@@ -60,5 +92,14 @@ export declare function normalizeRoutingHint(raw: unknown): GeneRoutingHint | nu
  * defaults to 'warn' when a list is present; the whole object collapses to null when neither list survives.
  */
 export declare function normalizeToolPolicy(raw: unknown): GeneToolPolicy | null;
+/**
+ * Normalize an arbitrary generation_meta fragment to a strict { source, quality_score?, quality_heuristics?,
+ * overcame_errors? } object, or null. Lossy (mirrors normalizeRoutingHint / normalizeToolPolicy): unknown source
+ * values are dropped (the whole block collapses to null — a generation_meta with no recognized source carries no
+ * usable provenance signal); quality_score is clamped to [0,1]; heuristics keeps only its numeric/boolean fields;
+ * overcame_errors keeps only non-empty strings. A block with a valid source but all-else-empty still survives (source
+ * alone is a meaningful provenance tag); only a missing/unknown source yields null.
+ */
+export declare function normalizeGenerationMeta(raw: unknown): GenerationMeta | null;
 /** Strip the v2-delta hint fields from a gene-shaped object (used to validate the gep-sdk-known core). */
 export declare function stripGeneHints(gene: Record<string, unknown>): Record<string, unknown>;

package/dist/wire/geneHints.js

@@ -22,13 +22,22 @@
 export const ROUTING_TIERS = ['cheap', 'mid', 'expensive'];
 export const REASONING_LEVELS = ['off', 'low', 'medium', 'high'];
 export const TOOL_POLICY_SEVERITIES = ['warn', 'block'];
+/**
+ * Provenance classification (V1 #302 classifyProvenance, aligned with TaskGenome Bench §3.1): a Gene's value
+ * depends on WHERE it came from, not on being short. The three tiers:
+ *   evolved   -- distilled from a real solve -> fail -> mutate -> pass trajectory; beats Skills (+8.7..+15.5pp)
+ *   distilled -- transcribed from reference/teacher text with no real failing trajectory; WORSE than Skills (-3.2..-11.2pp)
+ *   manual    -- pure human transcription, no execution evidence at all
+ * The high-value payload of an evolved Gene is the corrective_insight that flipped the outcome.
+ */
+export const GENERATION_SOURCES = ['evolved', 'distilled', 'manual'];
 /**
  * The v2-delta hint field names, in one place — the intake gate strips these before the gep-sdk schema check.
  * IMPORTANT: when a gep-sdk gene-schema bump makes one of these first-class, REMOVE it from this list in the
  * same change. Otherwise intakeGene keeps stripping a now-validated field before validateWire (fail-open — the
  * field's new schema constraints go unchecked at intake) while asset_id still commits it.
  */
-export const GENE_HINT_FIELDS = ['routing_hint', 'tool_policy'];
+export const GENE_HINT_FIELDS = ['routing_hint', 'tool_policy', 'generation_meta'];
 function includesEnum(set, v) {
     return typeof v === 'string' && set.includes(v);
 }
@@ -89,6 +98,48 @@ function cleanToolList(raw) {
     const cleaned = raw.filter((x) => typeof x === 'string' && x.length > 0);
     return cleaned.length > 0 ? cleaned : undefined;
 }
+/**
+ * Normalize an arbitrary generation_meta fragment to a strict { source, quality_score?, quality_heuristics?,
+ * overcame_errors? } object, or null. Lossy (mirrors normalizeRoutingHint / normalizeToolPolicy): unknown source
+ * values are dropped (the whole block collapses to null — a generation_meta with no recognized source carries no
+ * usable provenance signal); quality_score is clamped to [0,1]; heuristics keeps only its numeric/boolean fields;
+ * overcame_errors keeps only non-empty strings. A block with a valid source but all-else-empty still survives (source
+ * alone is a meaningful provenance tag); only a missing/unknown source yields null.
+ */
+export function normalizeGenerationMeta(raw) {
+    if (!raw || typeof raw !== 'object')
+        return null;
+    const r = raw;
+    const source = r['source'];
+    if (!includesEnum(GENERATION_SOURCES, source))
+        return null;
+    const out = { source };
+    const qs = r['quality_score'];
+    if (typeof qs === 'number' && Number.isFinite(qs))
+        out.quality_score = Math.max(0, Math.min(1, qs));
+    const eh = r['quality_heuristics'];
+    if (eh && typeof eh === 'object') {
+        const h = eh;
+        const heuristics = {};
+        const numFields = [
+            'strategy_steps', 'avoid_count', 'validation_declared_count', 'validation_runnable_count',
+            'signals_extracted', 'preconditions_extracted', 'trajectory_depth',
+        ];
+        for (const k of numFields) {
+            const v = h[k];
+            if (typeof v === 'number' && Number.isFinite(v))
+                heuristics[k] = v;
+        }
+        if (typeof h['has_corrective_insight'] === 'boolean')
+            heuristics.has_corrective_insight = h['has_corrective_insight'];
+        if (Object.keys(heuristics).length > 0)
+            out.quality_heuristics = heuristics;
+    }
+    const errs = cleanToolList(r['overcame_errors']);
+    if (errs)
+        out.overcame_errors = errs;
+    return out;
+}
 /** Strip the v2-delta hint fields from a gene-shaped object (used to validate the gep-sdk-known core). */
 export function stripGeneHints(gene) {
     const hidden = GENE_HINT_FIELDS;

package/dist/wire/index.d.ts

@@ -2,12 +2,18 @@
  * 资产 wire 层. SSOT = @evomap/gep-sdk/schemas/*.schema.json (D19).
  * 字段一律 snake_case 锁定 (asset_id 跨实现契约); 本仓不发明 wire 字段, 只镜像 + 重导出工具.
  */
-import type { GeneRoutingHint, GeneToolPolicy } from './geneHints.js';
+import type { GeneRoutingHint, GeneToolPolicy, GenerationMeta } from './geneHints.js';
 export { SCHEMA_VERSION, canonicalize, computeAssetId, verifyAssetId } from '@evomap/gep-sdk';
 export type GepCategory = typeof import('@evomap/gep-sdk').GEP_GENE_CATEGORIES[number];
 export type OutcomeStatus = typeof import('@evomap/gep-sdk').GEP_OUTCOME_STATUSES[number];
 export type SourceType = typeof import('@evomap/gep-sdk').GEP_SOURCE_TYPES[number];
 export type RiskLevel = typeof import('@evomap/gep-sdk').GEP_RISK_LEVELS[number];
+export type CapsuleVisibility = typeof import('@evomap/gep-sdk').GEP_CAPSULE_VISIBILITIES[number];
+export type CapsuleCostTier = typeof import('@evomap/gep-sdk').GEP_CAPSULE_COST_TIERS[number];
+export interface CapsuleAuthor {
+    handle: string;
+    evox_install_id: string;
+}
 /** Gene = 基因型/方法论 (gene.schema.json). */
 export interface Gene {
     type: 'Gene';
@@ -28,6 +34,7 @@ export interface Gene {
     anti_patterns?: unknown[];
     routing_hint?: GeneRoutingHint | null;
     tool_policy?: GeneToolPolicy | null;
+    generation_meta?: GenerationMeta | null;
     asset_id: string;
 }
 /** Capsule = 表现型/纯进化产物 (capsule.schema.json). */
@@ -49,6 +56,11 @@ export interface Capsule {
     };
     resolution_status?: 'pending' | 'suppressed_observationally' | 'resolved_by_evidence' | 'regressed' | 'inconclusive';
     proof_of_work?: unknown;
+    visibility?: CapsuleVisibility | null;
+    scope?: string[] | null;
+    cost_tier?: CapsuleCostTier | null;
+    pack_of?: string[] | null;
+    author?: CapsuleAuthor | null;
     execution_trace?: unknown[];
     trigger_context?: unknown;
     asset_id: string;
@@ -88,4 +100,4 @@ export interface Mutation {
     risk_level: RiskLevel;
 }
 export { validateWire, schemaProperties, type WireValidation } from './schemaGate.js';
-export { ROUTING_TIERS, REASONING_LEVELS, TOOL_POLICY_SEVERITIES, GENE_HINT_FIELDS, normalizeRoutingHint, normalizeToolPolicy, stripGeneHints, type RoutingTier, type ReasoningLevel, type ToolPolicySeverity, type GeneRoutingHint, type GeneToolPolicy, } from './geneHints.js';
+export { ROUTING_TIERS, REASONING_LEVELS, TOOL_POLICY_SEVERITIES, GENERATION_SOURCES, GENE_HINT_FIELDS, normalizeRoutingHint, normalizeToolPolicy, normalizeGenerationMeta, stripGeneHints, type RoutingTier, type ReasoningLevel, type ToolPolicySeverity, type GenerationSource, type GeneRoutingHint, type GeneToolPolicy, type GeneGenerationHeuristics, type GenerationMeta, } from './geneHints.js';

package/dist/wire/index.js

@@ -1,3 +1,3 @@
 export { SCHEMA_VERSION, canonicalize, computeAssetId, verifyAssetId } from '@evomap/gep-sdk';
 export { validateWire, schemaProperties } from './schemaGate.js';
-export { ROUTING_TIERS, REASONING_LEVELS, TOOL_POLICY_SEVERITIES, GENE_HINT_FIELDS, normalizeRoutingHint, normalizeToolPolicy, stripGeneHints, } from './geneHints.js';
+export { ROUTING_TIERS, REASONING_LEVELS, TOOL_POLICY_SEVERITIES, GENERATION_SOURCES, GENE_HINT_FIELDS, normalizeRoutingHint, normalizeToolPolicy, normalizeGenerationMeta, stripGeneHints, } from './geneHints.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evomap/evolver-core",
-  "version": "2.0.0-beta.1",
+  "version": "2.0.0-beta.3",
   "private": false,
   "type": "module",
   "description": "hub-无关核心: 算法引擎/原材料/mailbox/资产库/workflow",
@@ -17,12 +17,17 @@
     "zod": "^3.24.1",
     "ulid": "^2.3.0"
   },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/EvoMap/evolver.git"
+  },
   "publishConfig": {
     "access": "public",
     "tag": "v2-beta"
   },
   "files": [
     "dist/",
+    "assets/",
     "README.md",
     "package.json"
   ]