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

package/dist/assetstore/assetSyncLedger.js

@@ -0,0 +1,86 @@
+import { appendFileSync, existsSync, mkdirSync, readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+export class AssetSyncLedger {
+    now;
+    path;
+    index = new Map();
+    loaded = false;
+    constructor(baseDir, now = Date.now) {
+        this.now = now;
+        this.path = join(baseDir, 'asset-sync.jsonl');
+    }
+    append(rec) {
+        this.load();
+        const full = {
+            ...rec,
+            syncedAt: rec.syncedAt ?? new Date(this.now()).toISOString(),
+        };
+        mkdirSync(dirname(this.path), { recursive: true });
+        appendFileSync(this.path, `${JSON.stringify(full)}\n`);
+        this.index.set(full.assetId, full);
+        return full;
+    }
+    get(assetId) {
+        this.load();
+        return this.index.get(assetId) ?? null;
+    }
+    list() {
+        this.load();
+        return [...this.index.values()];
+    }
+    load() {
+        if (this.loaded)
+            return;
+        if (existsSync(this.path)) {
+            for (const line of readFileSync(this.path, 'utf8').split('\n')) {
+                if (!line.trim())
+                    continue;
+                try {
+                    const rec = parseRecord(JSON.parse(line));
+                    if (rec)
+                        this.index.set(rec.assetId, rec);
+                }
+                catch {
+                    // Skip corrupt audit lines; the asset store remains the source of content truth.
+                }
+            }
+        }
+        this.loaded = true;
+    }
+}
+function parseRecord(value) {
+    const assetId = stringField(value, 'assetId');
+    const type = stringField(value, 'type');
+    const source = stringField(value, 'source');
+    const scope = stringField(value, 'scope');
+    const syncedAt = stringField(value, 'syncedAt');
+    const remoteAssetId = stringField(value, 'remoteAssetId');
+    if (!assetId ||
+        (type !== 'Gene' && type !== 'Capsule') ||
+        source !== 'hub' ||
+        (scope !== 'purchased' && scope !== 'published') ||
+        !syncedAt ||
+        !remoteAssetId) {
+        return null;
+    }
+    const logicalId = stringField(value, 'logicalId');
+    const status = stringField(value, 'status');
+    const forced = value['forced'] === true;
+    const collisionWithAssetId = stringField(value, 'collisionWithAssetId');
+    return {
+        assetId,
+        type,
+        source,
+        scope,
+        syncedAt,
+        remoteAssetId,
+        ...(logicalId ? { logicalId } : {}),
+        ...(status ? { status } : {}),
+        ...(forced ? { forced: true } : {}),
+        ...(collisionWithAssetId ? { collisionWithAssetId } : {}),
+    };
+}
+function stringField(value, key) {
+    const raw = value[key];
+    return typeof raw === 'string' && raw.trim() ? raw.trim() : undefined;
+}

package/dist/assetstore/index.d.ts

@@ -3,6 +3,8 @@ export * from './localJsonl.js';
 export * from './remoteStub.js';
 export * from './learningHistory.js';
 export * from './provenance.js';
+export * from './assetSyncLedger.js';
 export * from './reviewLedger.js';
 export * from './reviewFilter.js';
-export * from './pendingSignals.js';
+export * from './pendingSignals.js';
+export * from './seedGenes.js';

package/dist/assetstore/index.js

@@ -3,6 +3,8 @@ export * from './localJsonl.js';
 export * from './remoteStub.js';
 export * from './learningHistory.js';
 export * from './provenance.js';
+export * from './assetSyncLedger.js';
 export * from './reviewLedger.js';
 export * from './reviewFilter.js';
-export * from './pendingSignals.js';
+export * from './pendingSignals.js';
+export * from './seedGenes.js';

package/dist/assetstore/localJsonl.d.ts

@@ -2,15 +2,22 @@ import { type AssetKind, type AssetRecord, type AssetStoreProvider, type PutResu
 /**
  * 本地 jsonl 资产库(M3-2, 移植 v1 src/gep/assetStore.js 单写锁).
  * 每 kind 一文件(genes/capsules/events.jsonl); append-only; O_EXCL 文件锁防并发写撕裂;
- * 内存索引(asset_id→record)供 get/search; 同 asset_id 去重(内容寻址天然幂等).
+ * 内存索引(asset_id→record)供 get/search; 文件指纹变化时在共享锁内重建索引，保证多个
+ * CLI/daemon 进程之间可见; 写入也在锁内刷新后再按 asset_id 去重(内容寻址天然幂等).
  */
 export declare class LocalJsonlProvider implements AssetStoreProvider {
     readonly baseDir: string;
     private readonly index;
     private readonly lockPath;
+    private fileState;
     private loaded;
     constructor(baseDir: string);
-    private ensureLoaded;
+    private captureFileState;
+    private stateChanged;
+    private rebuildIndex;
+    private refreshUnderLock;
+    private ensureFresh;
+    private updateFileStateAfterWrite;
     put(asset: AssetRecord): Promise<PutResult>;
     /**
      * 迁移专用(M8-2): 以**冻结 asset_id** 原样写入, 不经 normalizeForPut 重算/校验.

package/dist/assetstore/localJsonl.js

@@ -1,8 +1,22 @@
-import { appendFileSync, existsSync, readFileSync, writeFileSync, renameSync, mkdirSync } from 'node:fs';
+import { appendFileSync, existsSync, readFileSync, writeFileSync, renameSync, mkdirSync, statSync } from 'node:fs';
 import { join } from 'node:path';
 import { acquireLock, releaseLock } from '../util/fileLock.js';
 import { normalizeForPut, } from './provider.js';
 const FILES = { Gene: 'genes.jsonl', Capsule: 'capsules.jsonl', EvolutionEvent: 'events.jsonl', AntiGene: 'anti-genes.jsonl' };
+function isErrno(error, code) {
+    return typeof error === 'object' && error !== null && error.code === code;
+}
+function fileFingerprint(path) {
+    try {
+        const stat = statSync(path, { bigint: true });
+        return `${stat.dev}:${stat.ino}:${stat.mode}:${stat.size}:${stat.mtimeNs}:${stat.ctimeNs}`;
+    }
+    catch (error) {
+        if (isErrno(error, 'ENOENT'))
+            return 'missing';
+        throw error;
+    }
+}
 function signalsOf(a) {
     const out = [];
     for (const key of ['signals_match', 'signals', 'trigger', 'trigger_signals']) {
@@ -17,12 +31,14 @@ function signalsOf(a) {
 /**
  * 本地 jsonl 资产库(M3-2, 移植 v1 src/gep/assetStore.js 单写锁).
  * 每 kind 一文件(genes/capsules/events.jsonl); append-only; O_EXCL 文件锁防并发写撕裂;
- * 内存索引(asset_id→record)供 get/search; 同 asset_id 去重(内容寻址天然幂等).
+ * 内存索引(asset_id→record)供 get/search; 文件指纹变化时在共享锁内重建索引，保证多个
+ * CLI/daemon 进程之间可见; 写入也在锁内刷新后再按 asset_id 去重(内容寻址天然幂等).
  */
 export class LocalJsonlProvider {
     baseDir;
     index = new Map();
     lockPath;
+    fileState = new Map();
     loaded = false;
     // `baseDir` is public-readonly so callers that inject a store (e.g. the CLI under test) can co-locate sidecars
     // — the ReviewLedger/ProvenanceStore — in the SAME directory, instead of defaulting to the real ~/.evomap.
@@ -31,9 +47,24 @@ export class LocalJsonlProvider {
         mkdirSync(baseDir, { recursive: true });
         this.lockPath = join(baseDir, '.assetstore.lock');
     }
-    ensureLoaded() {
-        if (this.loaded)
-            return;
+    captureFileState() {
+        const state = new Map();
+        for (const [kind, file] of Object.entries(FILES)) {
+            state.set(kind, fileFingerprint(join(this.baseDir, file)));
+        }
+        return state;
+    }
+    stateChanged(next) {
+        if (!this.loaded || next.size !== this.fileState.size)
+            return true;
+        for (const [kind, fingerprint] of next) {
+            if (this.fileState.get(kind) !== fingerprint)
+                return true;
+        }
+        return false;
+    }
+    rebuildIndex(state) {
+        const next = new Map();
         for (const file of Object.values(FILES)) {
             const p = join(this.baseDir, file);
             if (!existsSync(p))
@@ -44,29 +75,50 @@ export class LocalJsonlProvider {
                 try {
                     const r = JSON.parse(line);
                     if (r.asset_id)
-                        this.index.set(r.asset_id, r);
+                        next.set(r.asset_id, r);
                 }
                 catch { /* skip 坏行 */ }
             }
         }
+        this.index.clear();
+        for (const [assetId, record] of next)
+            this.index.set(assetId, record);
+        this.fileState = state;
+        this.loaded = true;
+    }
+    refreshUnderLock() {
+        const state = this.captureFileState();
+        if (this.stateChanged(state))
+            this.rebuildIndex(state);
+    }
+    ensureFresh() {
+        const state = this.captureFileState();
+        if (!this.stateChanged(state))
+            return;
+        acquireLock(this.lockPath);
+        try {
+            this.refreshUnderLock();
+        }
+        finally {
+            releaseLock(this.lockPath);
+        }
+    }
+    updateFileStateAfterWrite() {
+        this.fileState = this.captureFileState();
         this.loaded = true;
     }
     async put(asset) {
-        this.ensureLoaded();
         const { record, verified } = normalizeForPut(asset);
-        if (this.index.has(record.asset_id))
-            return { asset_id: record.asset_id, stored: false, verified };
         const file = join(this.baseDir, FILES[record.type]);
         acquireLock(this.lockPath);
         try {
-            // 锁内复检(另一进程可能刚写)
-            if (!this.index.has(record.asset_id)) {
-                appendFileSync(file, `${JSON.stringify(record)}\n`);
-                this.index.set(record.asset_id, record);
-            }
-            else {
+            // Refresh under the shared lock so another process cannot append between reload and dedupe.
+            this.refreshUnderLock();
+            if (this.index.has(record.asset_id))
                 return { asset_id: record.asset_id, stored: false, verified };
-            }
+            appendFileSync(file, `${JSON.stringify(record)}\n`);
+            this.index.set(record.asset_id, record);
+            this.updateFileStateAfterWrite();
         }
         finally {
             releaseLock(this.lockPath);
@@ -78,18 +130,17 @@ export class LocalJsonlProvider {
      * 仅 v1→v2 导入用(硬化 A6 存量冻结); 普通写一律走 put(). record 必须自带 asset_id.
      */
     async putFrozen(record) {
-        this.ensureLoaded();
         if (!record.asset_id)
             throw new Error('putFrozen 需 record 自带冻结 asset_id');
-        if (this.index.has(record.asset_id))
-            return { asset_id: record.asset_id, stored: false, verified: false };
         const file = join(this.baseDir, FILES[record.type]);
         acquireLock(this.lockPath);
         try {
+            this.refreshUnderLock();
             if (this.index.has(record.asset_id))
                 return { asset_id: record.asset_id, stored: false, verified: false };
             appendFileSync(file, `${JSON.stringify(record)}\n`);
             this.index.set(record.asset_id, record);
+            this.updateFileStateAfterWrite();
         }
         finally {
             releaseLock(this.lockPath);
@@ -97,11 +148,11 @@ export class LocalJsonlProvider {
         return { asset_id: record.asset_id, stored: true, verified: false };
     }
     async get(assetId) {
-        this.ensureLoaded();
+        this.ensureFresh();
         return this.index.get(assetId) ?? null;
     }
     async list(kind, limit = 1000) {
-        this.ensureLoaded();
+        this.ensureFresh();
         const out = [];
         for (const r of this.index.values()) {
             if (!kind || r.type === kind)
@@ -112,7 +163,7 @@ export class LocalJsonlProvider {
         return out;
     }
     async search(q) {
-        this.ensureLoaded();
+        this.ensureFresh();
         const out = [];
         for (const r of this.index.values()) {
             if (q.kind && r.type !== q.kind)
@@ -148,9 +199,9 @@ export class LocalJsonlProvider {
      * the write lock. Returns kept/removed line counts.
      */
     async compact() {
-        this.ensureLoaded();
         acquireLock(this.lockPath);
         try {
+            this.refreshUnderLock();
             let kept = 0, removed = 0;
             for (const [kind, file] of Object.entries(FILES)) {
                 const p = join(this.baseDir, file);
@@ -173,6 +224,7 @@ export class LocalJsonlProvider {
                 kept += byId.size;
                 removed += lines.length - byId.size;
             }
+            this.rebuildIndex(this.captureFileState());
             return { kept, removed };
         }
         finally {

package/dist/assetstore/pendingSignals.js

@@ -1,5 +1,5 @@
 import { existsSync, mkdirSync, readFileSync, renameSync, statSync, writeFileSync } from 'node:fs';
-import { dirname, join, resolve } from 'node:path';
+import { basename, dirname, join, resolve } from 'node:path';
 import { acquireLock, releaseLock } from '../util/fileLock.js';
 import { LocalJsonlProvider } from './localJsonl.js';
 const MAX_SIGNAL_LENGTH = 200;
@@ -33,6 +33,8 @@ function findRepoRoot(start) {
     while (current) {
         if (existsSync(join(current, '.git')))
             return current;
+        if (basename(current) === 'node_modules')
+            return null;
         const parent = dirname(current);
         if (parent === current)
             return null;

package/dist/assetstore/provenance.d.ts

@@ -16,10 +16,13 @@ export interface ProvenanceRecord {
 export declare class ProvenanceStore {
     private readonly now;
     private readonly path;
+    private readonly lockPath;
     private readonly index;
-    private loaded;
+    private fileState;
     constructor(baseDir: string, now?: () => number);
-    private load;
+    private rebuildIndex;
+    private refreshUnderLock;
+    private withFreshRead;
     /** Record provenance for an asset_id (append-only; the JSONL history is the audit trail). */
     mark(rec: Omit<ProvenanceRecord, 'at'> & {
         at?: string;
@@ -28,6 +31,8 @@ export declare class ProvenanceStore {
     get(assetId: string): ProvenanceRecord | null;
     /** No record → trusted (local default); a record → its trusted flag. */
     isTrusted(assetId: string): boolean;
+    /** One linearizable trust snapshot for bounded batch readers. */
+    snapshot(): ReadonlyMap<string, ProvenanceRecord>;
     /** Explicit, audited untrusted→trusted promotion. Appends a new trusted record carrying who/why. */
     promote(assetId: string, by: string, reason: string): ProvenanceRecord;
 }

package/dist/assetstore/provenance.js

@@ -5,7 +5,22 @@
 // selection defaults to trusted-only; an untrusted asset is promoted to trusted only by an explicit, logged act.
 import { appendFileSync, closeSync, existsSync, openSync, readFileSync, readSync, mkdirSync, statSync, truncateSync } from 'node:fs';
 import { join, dirname } from 'node:path';
+import { acquireLock, releaseLock } from '../util/fileLock.js';
 import { normalizeForPut } from './provider.js';
+function isErrno(error, code) {
+    return typeof error === 'object' && error !== null && error.code === code;
+}
+function fileFingerprint(path) {
+    try {
+        const stat = statSync(path, { bigint: true });
+        return `${stat.dev}:${stat.ino}:${stat.mode}:${stat.size}:${stat.mtimeNs}:${stat.ctimeNs}`;
+    }
+    catch (error) {
+        if (isErrno(error, 'ENOENT'))
+            return 'missing';
+        throw error;
+    }
+}
 /**
  * Append-only JSONL sidecar (last-write-wins) at <baseDir>/provenance.jsonl. Default for an asset with NO
  * record = trusted: the only local writers (cycleEngine self-produce, v1 migration) are trusted and never
@@ -14,42 +29,73 @@ import { normalizeForPut } from './provider.js';
 export class ProvenanceStore {
     now;
     path;
+    lockPath;
     index = new Map();
-    loaded = false;
+    fileState = null;
     constructor(baseDir, now = Date.now) {
         this.now = now;
         this.path = join(baseDir, 'provenance.jsonl');
+        this.lockPath = join(baseDir, '.assetstore.lock');
     }
-    load() {
-        if (this.loaded)
-            return;
-        if (existsSync(this.path)) {
+    rebuildIndex(state) {
+        const next = new Map();
+        if (state !== 'missing') {
             for (const line of readFileSync(this.path, 'utf8').split('\n')) {
                 if (!line.trim())
                     continue;
                 try {
                     const r = JSON.parse(line);
                     if (r.assetId)
-                        this.index.set(r.assetId, r);
+                        next.set(r.assetId, r);
                 }
                 catch { /* skip corrupt line */ }
             }
         }
-        this.loaded = true;
+        this.index.clear();
+        for (const [assetId, record] of next)
+            this.index.set(assetId, record);
+        this.fileState = state;
+    }
+    refreshUnderLock() {
+        const state = fileFingerprint(this.path);
+        if (state !== this.fileState)
+            this.rebuildIndex(state);
+    }
+    withFreshRead(read) {
+        mkdirSync(dirname(this.path), { recursive: true });
+        acquireLock(this.lockPath);
+        try {
+            this.refreshUnderLock();
+            return read(this.index);
+        }
+        finally {
+            releaseLock(this.lockPath);
+        }
     }
     /** Record provenance for an asset_id (append-only; the JSONL history is the audit trail). */
     mark(rec) {
-        this.load();
         const full = { ...rec, at: rec.at ?? new Date(this.now()).toISOString() };
         mkdirSync(dirname(this.path), { recursive: true });
-        appendFileSync(this.path, `${JSON.stringify(full)}\n`);
-        this.index.set(full.assetId, full);
+        acquireLock(this.lockPath);
+        try {
+            this.refreshUnderLock();
+            appendFileSync(this.path, `${JSON.stringify(full)}\n`);
+            this.index.set(full.assetId, full);
+            this.fileState = fileFingerprint(this.path);
+        }
+        finally {
+            releaseLock(this.lockPath);
+        }
         return full;
     }
     rollbackLast(rec) {
         const line = `${JSON.stringify(rec)}\n`;
         const lineBytes = Buffer.byteLength(line, 'utf8');
+        let locked = false;
         try {
+            mkdirSync(dirname(this.path), { recursive: true });
+            acquireLock(this.lockPath);
+            locked = true;
             if (!existsSync(this.path))
                 return;
             const stat = statSync(this.path);
@@ -64,26 +110,40 @@ export class ProvenanceStore {
             finally {
                 closeSync(fd);
             }
-            if (buf.toString('utf8') !== line)
+            if (buf.toString('utf8') !== line) {
+                this.refreshUnderLock();
                 return;
+            }
             truncateSync(this.path, offset);
-            this.index.clear();
-            this.loaded = false;
+            this.rebuildIndex(fileFingerprint(this.path));
         }
         catch {
             this.index.clear();
-            this.loaded = false;
+            this.fileState = null;
+        }
+        finally {
+            if (locked) {
+                try {
+                    releaseLock(this.lockPath);
+                }
+                catch {
+                    // Rollback is best-effort and must not mask the store failure that triggered it.
+                    this.index.clear();
+                    this.fileState = null;
+                }
+            }
         }
     }
     get(assetId) {
-        this.load();
-        return this.index.get(assetId) ?? null;
+        return this.withFreshRead((index) => index.get(assetId) ?? null);
     }
     /** No record → trusted (local default); a record → its trusted flag. */
     isTrusted(assetId) {
-        this.load();
-        const r = this.index.get(assetId);
-        return r ? r.trusted : true;
+        return this.withFreshRead((index) => index.get(assetId)?.trusted ?? true);
+    }
+    /** One linearizable trust snapshot for bounded batch readers. */
+    snapshot() {
+        return this.withFreshRead((index) => new Map(index));
     }
     /** Explicit, audited untrusted→trusted promotion. Appends a new trusted record carrying who/why. */
     promote(assetId, by, reason) {
@@ -99,11 +159,11 @@ export class ProvenanceStore {
 export async function ingestUntrusted(store, prov, record, source = 'hub') {
     const normalized = normalizeForPut(record);
     const mark = prov.mark({ assetId: normalized.record.asset_id, source, trusted: false });
-    try {
-        return await store.put(record);
-    }
-    catch (err) {
+    const result = await store.put(record);
+    // A thrown write has an ambiguous outcome: the asset may have reached disk before the acknowledgement was
+    // lost. Keep the untrusted marker in that case so a persisted Hub asset can never fall through the default
+    // no-record => trusted policy. Only an explicit no-write result is safe to roll back.
+    if (!result.stored)
         prov.rollbackLast(mark);
-        throw err;
-    }
+    return result;
 }

package/dist/assetstore/reviewFilter.js

@@ -30,9 +30,10 @@ export function provenanceStoreForStore(store) {
  */
 export async function listApprovedGenes(store, review, maxGenes, provenance = provenanceStoreForStore(store)) {
     const all = await store.list('Gene', GENE_SCAN_LIMIT);
+    const trust = provenance.snapshot();
     const approved = [];
     for (const g of all) {
-        if (!provenance.isTrusted(String(g.asset_id)))
+        if (trust.get(String(g.asset_id))?.trusted === false)
             continue; // hub-untrusted → withhold until promoted
         if (!review.isApproved(String(g.asset_id)))
             continue; // quarantined/rejected draft → withhold

package/dist/assetstore/reviewLedger.d.ts

@@ -52,4 +52,10 @@ export declare class ReviewLedger {
     records(): ReviewRecord[];
     /** No record → approved (default eligible); a record → approved only when its state is 'approved'. */
     isApproved(assetId: string): boolean;
+    /**
+     * True only when a human approval record exists. Safety-sensitive consumers such as AntiGene warning
+     * injection must fail closed when review state is absent; unlike cycle/migrate-authored Genes, an unreviewed
+     * negative-memory asset must never inherit the ledger's backward-compatible "no record = eligible" default.
+     */
+    isExplicitlyApproved(assetId: string): boolean;
 }

package/dist/assetstore/reviewLedger.js

@@ -118,4 +118,13 @@ export class ReviewLedger {
         const r = this.index.get(assetId);
         return r ? r.state === 'approved' : true;
     }
+    /**
+     * True only when a human approval record exists. Safety-sensitive consumers such as AntiGene warning
+     * injection must fail closed when review state is absent; unlike cycle/migrate-authored Genes, an unreviewed
+     * negative-memory asset must never inherit the ledger's backward-compatible "no record = eligible" default.
+     */
+    isExplicitlyApproved(assetId) {
+        this.load();
+        return this.index.get(assetId)?.state === 'approved';
+    }
 }

package/dist/assetstore/seedGenes.d.ts

@@ -0,0 +1,3 @@
+import { type Gene } from '../wire/index.js';
+export declare const BUNDLED_HARNESS_SEED_GENES: readonly Gene[];
+export declare function bundledHarnessSeedGenesJsonl(): string;