@evomap/evolver-core 2.0.0-beta.10 → 2.0.0-beta.12

package/dist/assetstore/assetStoreHealth.d.ts

@@ -15,6 +15,12 @@ export interface AssetStoreFileHealth {
     duplicateRows: number;
     corruptRows: number;
     hashMismatchRows: number;
+    /**
+     * Rows that fail content-hash verification but are provenance-marked as an unverified hub reuse
+     * (evolver-v2#570). These are EXPECTED — the hub rewrote the delivered bytes and reuse froze them untrusted —
+     * so they are a benign category, counted separately and never degrading the store.
+     */
+    unverifiedRows: number;
     schemaInvalidRows: number;
     unterminated: boolean;
     reason?: UnsafeAssetStorePathReason | 'base_directory' | 'lock_unavailable' | 'read_unavailable' | 'scan_limit_exceeded';
@@ -31,6 +37,7 @@ export interface AssetStoreHealthTotals {
     duplicateRows: number;
     corruptRows: number;
     hashMismatchRows: number;
+    unverifiedRows: number;
     schemaInvalidRows: number;
     unterminatedFiles: number;
 }

package/dist/assetstore/assetStoreHealth.js

@@ -31,6 +31,7 @@ function emptyFile(kind, file, status, reason) {
         duplicateRows: 0,
         corruptRows: 0,
         hashMismatchRows: 0,
+        unverifiedRows: 0,
         schemaInvalidRows: 0,
         unterminated: false,
         ...(reason ? { reason } : {}),
@@ -69,6 +70,7 @@ function summarize(files, sidecars) {
         duplicateRows: files.reduce((sum, file) => sum + file.duplicateRows, 0),
         corruptRows: files.reduce((sum, file) => sum + file.corruptRows, 0),
         hashMismatchRows: files.reduce((sum, file) => sum + file.hashMismatchRows, 0),
+        unverifiedRows: files.reduce((sum, file) => sum + file.unverifiedRows, 0),
         schemaInvalidRows: files.reduce((sum, file) => sum + file.schemaInvalidRows, 0),
         unterminatedFiles: files.filter((file) => file.unterminated).length,
     };
@@ -105,7 +107,7 @@ function summarize(files, sidecars) {
         sidecars: [...sidecars],
     };
 }
-function inspectFile(baseDir, kind, file, maxFileBytes) {
+function inspectFile(baseDir, kind, file, maxFileBytes, unverifiedIds) {
     try {
         const path = join(baseDir, file);
         const stat = assertOptionalRegularFile(path);
@@ -123,6 +125,7 @@ function inspectFile(baseDir, kind, file, maxFileBytes) {
         let duplicateRows = 0;
         let corruptRows = 0;
         let hashMismatchRows = 0;
+        let unverifiedRows = 0;
         let schemaInvalidRows = 0;
         for (const line of rows) {
             try {
@@ -142,7 +145,13 @@ function inspectFile(baseDir, kind, file, maxFileBytes) {
                 else
                     seen.add(assetId);
                 if (!verifyAssetId(record)) {
-                    hashMismatchRows += 1;
+                    // A hash mismatch is corruption UNLESS provenance says this id is an unverified hub reuse: the hub
+                    // rewrote the delivered bytes and reuse froze them untrusted on purpose (#570). That is expected, not
+                    // store rot, so it lands in the benign unverifiedRows bucket and never degrades the store.
+                    if (unverifiedIds.has(assetId))
+                        unverifiedRows += 1;
+                    else
+                        hashMismatchRows += 1;
                     continue;
                 }
                 if (kind !== 'AntiGene' && !validateWire(record).ok) {
@@ -174,6 +183,7 @@ function inspectFile(baseDir, kind, file, maxFileBytes) {
             duplicateRows,
             corruptRows,
             hashMismatchRows,
+            unverifiedRows,
             schemaInvalidRows,
             unterminated,
         };
@@ -184,6 +194,24 @@ function inspectFile(baseDir, kind, file, maxFileBytes) {
         return emptyFile(kind, file, 'unavailable', 'read_unavailable');
     }
 }
+/**
+ * Asset ids marked in the provenance sidecar as an unverified hub reuse (reason `unverified_*`, evolver-v2#570).
+ * Read directly from `<baseDir>/provenance.jsonl` — NOT via ProvenanceStore — because inspectLocalAssetStore
+ * already holds the shared `.assetstore.lock`, and ProvenanceStore would try to re-acquire it. A missing or
+ * unreadable sidecar yields an empty set: without provenance every mismatch stays classified as corruption.
+ */
+function readUnverifiedReuseIds(baseDir) {
+    const raw = readUtf8Regular(join(baseDir, 'provenance.jsonl'));
+    if (raw === null)
+        return new Set();
+    const ids = new Set();
+    for (const record of parseSidecarJsonl(raw, parseProvenanceRecord).records) {
+        if (record.trusted === false && typeof record.reason === 'string' && record.reason.startsWith('unverified_')) {
+            ids.add(record.assetId);
+        }
+    }
+    return ids;
+}
 function inspectSidecar(baseDir, definition, maxFileBytes) {
     const { kind, file, parseRecord } = definition;
     try {
@@ -256,10 +284,13 @@ export function inspectLocalAssetStore(baseDir, opts = {}, deps = {}) {
         return summarize(allFiles('unavailable', 'lock_unavailable'), allSidecars('unavailable', 'lock_unavailable'));
     }
     const maxFileBytes = healthScanLimit(opts.maxFileBytes);
+    // Read the unverified-reuse set once, under the lock we already hold, so every asset file classifies its
+    // hash mismatches consistently against the same provenance snapshot.
+    const unverifiedIds = readUnverifiedReuseIds(baseDir);
     let report;
     try {
         report = summarize(Object.entries(LOCAL_ASSET_FILES)
-            .map(([kind, file]) => inspectFile(baseDir, kind, file, maxFileBytes)), LOCAL_ASSET_SIDECARS.map((definition) => inspectSidecar(baseDir, definition, maxFileBytes)));
+            .map(([kind, file]) => inspectFile(baseDir, kind, file, maxFileBytes, unverifiedIds)), LOCAL_ASSET_SIDECARS.map((definition) => inspectSidecar(baseDir, definition, maxFileBytes)));
     }
     catch {
         report = summarize(allFiles('unavailable', 'read_unavailable'), allSidecars('unavailable', 'read_unavailable'));

package/dist/assetstore/provenance.d.ts

@@ -55,6 +55,18 @@ export declare class ProvenanceStore {
  * should bring hub-fetched assets into the local pool — trust-first from the first byte (#30.1).
  */
 export declare function ingestUntrusted(store: AssetStoreProvider, prov: ProvenanceStore, record: AssetRecord, source?: ProvenanceSource): Promise<PutResult>;
+/**
+ * Hub → local-pool landing for an asset whose content does NOT hash to its declared asset_id. The hub
+ * demonstrably rewrites delivered payloads (injected `validation`, wholesale `payload_backfill_reason`
+ * synthesis — evolver-v2#570), which breaks {@link ingestUntrusted}'s normalizeForPut self-consistency check
+ * even though the loop's own in-run reuse already consumes hub content without re-verifying it (adapter
+ * `hubReuse.ts`). Rather than hard-reject a save the operator explicitly asked for, freeze the asset under its
+ * declared (network) asset_id via `putFrozen` and mark it untrusted in the sidecar with an explicit reason.
+ * Trust-first still holds (#30.1): selection defaults to trusted-only, so an unverified asset never silently
+ * enters the reasoning pool — it lands where the operator put it and stays flagged until an explicit,
+ * audited promotion. `reason` records WHY verification was waived (e.g. hub rewrite vs synthesized payload).
+ */
+export declare function ingestUnverified(store: AssetStoreProvider, prov: ProvenanceStore, record: AssetRecord, reason: string, source?: ProvenanceSource): Promise<PutResult>;
 /**
  * Conditional variant used by Hub sync to reject a logical-id collision without ever allowing a Hub record
  * to become implicitly trusted. Providers that cannot make the condition atomically are rejected here.

package/dist/assetstore/provenance.js

@@ -4,7 +4,7 @@
 // must not enter the content hash (#30.2), or it would break content-addressing. Trust-first by construction:
 // selection defaults to trusted-only; an untrusted asset is promoted to trusted only by an explicit, logged act.
 import { join, dirname } from 'node:path';
-import { normalizeForPut, supportsAtomicConditionalPut, validateConditionalPutResult, } from './provider.js';
+import { assertCapsuleGeneBinding, normalizeForPut, supportsAtomicConditionalPut, validateConditionalPutResult, } from './provider.js';
 import { appendUtf8Durable, assertAssetStoreDirectory, ensureAssetStoreDirectory, readUtf8Regular, regularFileFingerprint, truncateUtf8SuffixDurable, withAssetStoreLock, } from './assetStoreStorage.js';
 import { assertTrustSidecarHealthy, parseProvenanceRecord, parseSidecarJsonl, } from './assetSidecarRecords.js';
 function immutableRecord(record) {
@@ -143,6 +143,34 @@ export async function ingestUntrusted(store, prov, record, source = 'hub') {
         prov.rollbackLast(mark);
     return result;
 }
+/**
+ * Hub → local-pool landing for an asset whose content does NOT hash to its declared asset_id. The hub
+ * demonstrably rewrites delivered payloads (injected `validation`, wholesale `payload_backfill_reason`
+ * synthesis — evolver-v2#570), which breaks {@link ingestUntrusted}'s normalizeForPut self-consistency check
+ * even though the loop's own in-run reuse already consumes hub content without re-verifying it (adapter
+ * `hubReuse.ts`). Rather than hard-reject a save the operator explicitly asked for, freeze the asset under its
+ * declared (network) asset_id via `putFrozen` and mark it untrusted in the sidecar with an explicit reason.
+ * Trust-first still holds (#30.1): selection defaults to trusted-only, so an unverified asset never silently
+ * enters the reasoning pool — it lands where the operator put it and stays flagged until an explicit,
+ * audited promotion. `reason` records WHY verification was waived (e.g. hub rewrite vs synthesized payload).
+ */
+export async function ingestUnverified(store, prov, record, reason, source = 'hub') {
+    if (typeof store.putFrozen !== 'function') {
+        // Only a content-addressed local pool receives hub reuse writes; a provider that cannot freeze a
+        // hash-inconsistent record cannot preserve the network id, so fail loudly rather than silently restamp it.
+        throw new Error('ingestUnverified requires a store that implements putFrozen');
+    }
+    // putFrozen bypasses normalizeForPut, so re-assert the M3-4 Capsule↔gene binding here — a hash-mismatched
+    // Capsule with an empty gene must still fail closed on the frozen path, exactly as it does on the verified one.
+    assertCapsuleGeneBinding(record);
+    const mark = prov.mark({ assetId: record.asset_id, source, trusted: false, reason });
+    const result = await store.putFrozen(record);
+    // Mirror ingestUntrusted: only an explicit no-write result (dedup) is safe to roll the marker back; a
+    // thrown write has an ambiguous on-disk outcome and must keep the untrusted marker.
+    if (!result.stored)
+        prov.rollbackLast(mark);
+    return result;
+}
 /**
  * Conditional variant used by Hub sync to reject a logical-id collision without ever allowing a Hub record
  * to become implicitly trusted. Providers that cannot make the condition atomically are rejected here.

package/dist/assetstore/provider.d.ts

@@ -47,6 +47,14 @@ export interface AssetStoreProvider {
     get(assetId: string): Promise<AssetRecord | null>;
     /** Optional direct lookup for non-content-addressed logical ids. Callers must handle 0, 1, or multiple matches. */
     findByLogicalId?(id: string, limit?: number): Promise<AssetRecord[]>;
+    /**
+     * Optional frozen write: store the record under its OWN declared asset_id without recomputing or
+     * normalizing it (bypasses {@link normalizeForPut}'s self-consistency check). Only providers backing a
+     * content-addressed local pool implement it. Callers that must preserve a hash-inconsistent asset —
+     * v1 migration import, and unverified hub reuse of a hub-rewritten payload (see `ingestUnverified`) —
+     * feature-detect it rather than assuming it exists.
+     */
+    putFrozen?(record: AssetRecord): Promise<PutResult>;
     search(query: SearchQuery): Promise<AssetRecord[]>;
     list(kind?: AssetKind, limit?: number): Promise<AssetRecord[]>;
 }
@@ -62,6 +70,12 @@ export declare class AssetIdMismatchError extends Error {
 export declare class CapsuleGeneBindingError extends Error {
     constructor();
 }
+/**
+ * M3-4 强绑定校验: Capsule.gene 必须非空(否则一条无来源基因的经验会污染选择池).
+ * 抽成独立 helper 以便 normalizeForPut(校验落库路径)与 ingestUnverified(冻结落库路径,
+ * 绕过 normalizeForPut)共用同一条不变量,不让降级路径把绑定校验漏掉.
+ */
+export declare function assertCapsuleGeneBinding(asset: AssetRecord): void;
 /**
  * 落库前规范化(共享给各 provider): 计算/校验 asset_id + 强绑定校验.
  * - 缺 asset_id → 计算填入(verified=false 表示非入参自带).

package/dist/assetstore/provider.js

@@ -62,6 +62,18 @@ export class AssetIdMismatchError extends Error {
 export class CapsuleGeneBindingError extends Error {
     constructor() { super('Capsule.gene 必须非空或显式 "ad-hoc" 哨兵 (批注#28/M3-4)'); this.name = 'CapsuleGeneBindingError'; }
 }
+/**
+ * M3-4 强绑定校验: Capsule.gene 必须非空(否则一条无来源基因的经验会污染选择池).
+ * 抽成独立 helper 以便 normalizeForPut(校验落库路径)与 ingestUnverified(冻结落库路径,
+ * 绕过 normalizeForPut)共用同一条不变量,不让降级路径把绑定校验漏掉.
+ */
+export function assertCapsuleGeneBinding(asset) {
+    if (asset.type !== 'Capsule')
+        return;
+    const gene = asset.gene;
+    if (typeof gene !== 'string' || gene.length === 0)
+        throw new CapsuleGeneBindingError();
+}
 /**
  * 落库前规范化(共享给各 provider): 计算/校验 asset_id + 强绑定校验.
  * - 缺 asset_id → 计算填入(verified=false 表示非入参自带).
@@ -69,11 +81,7 @@ export class CapsuleGeneBindingError extends Error {
  * - Capsule.gene 必须非空(M3-4 强绑定).
  */
 export function normalizeForPut(asset) {
-    if (asset.type === 'Capsule') {
-        const gene = asset.gene;
-        if (typeof gene !== 'string' || gene.length === 0)
-            throw new CapsuleGeneBindingError();
-    }
+    assertCapsuleGeneBinding(asset);
     const actual = computeAssetId(asset);
     if (actual === null)
         throw new Error('computeAssetId 失败: 资产非对象');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evomap/evolver-core",
-  "version": "2.0.0-beta.10",
+  "version": "2.0.0-beta.12",
   "private": false,
   "type": "module",
   "description": "hub-无关核心: 算法引擎/原材料/mailbox/资产库/workflow",