@evomap/evolver-core 2.0.0-beta.17 → 2.0.0-beta.19

package/dist/algo/candidateAssembly.js

@@ -1,6 +1,6 @@
 import { aggregateLearningHistory } from '../assetstore/learningHistory.js';
 import { reuseSentiment } from '../ops/reuseOutcomes.js';
-import { tagOverlapScore } from '../signals/expand.js';
+import { expandSignals, geneTags, tagOverlapScore, } from '../signals/expand.js';
 import { bannedGenesFromFailures } from './bans.js';
 import { geneGenerationSource } from './geneIntake.js';
 function asStrings(v) {
@@ -68,6 +68,24 @@ async function computeBans(store, signals, limit) {
     }));
     return bannedGenesFromFailures(failures, signals);
 }
+const GENERIC_NAMESPACE_TAGS = new Set(['action', 'area', 'problem', 'risk', 'signal']);
+// Generic namespace tags and inferred action/signal subtypes are too broad to admit a candidate by themselves.
+function hasSelectionAdmissionEvidence(liveSignals, gene) {
+    const tags = new Set(geneTags(gene));
+    const triggerTags = new Set(expandSignals(gene.signalsMatch ?? []));
+    const categoryActionTag = gene.category ? `action:${gene.category.toLowerCase()}` : undefined;
+    if (liveSignals.some((signal) => ((triggerTags.has(signal) || signal === categoryActionTag)
+        && !GENERIC_NAMESPACE_TAGS.has(signal)))) {
+        return true;
+    }
+    const liveTags = expandSignals(liveSignals);
+    if (liveTags.some((tag) => (tags.has(tag)
+        && (tag.startsWith('problem:')
+            || tag.startsWith('area:')
+            || tag.startsWith('risk:')))))
+        return true;
+    return liveTags.some((tag) => tag.startsWith('signal:') && triggerTags.has(tag));
+}
 /**
  * Assemble the full selection pool from the store for the given signals: the relevant scored candidates AND the
  * distilled-gene fallback pool, in a single pass over the gene list (one store.list + one ban computation). A gene
@@ -106,7 +124,8 @@ export async function assembleSelectionPool(store, signals, opts = {}) {
         const category = typeof g['category'] === 'string' ? String(g['category']) : undefined;
         const summary = typeof g['summary'] === 'string' ? String(g['summary']) : undefined;
         const literal = signalsMatch.some((m) => sigSet.has(m));
-        const relevant = literal || tagOverlapScore(signals, { signalsMatch, geneId, category, summary }) > 0;
+        const tagInput = { signalsMatch, geneId, category, summary };
+        const relevant = literal || hasSelectionAdmissionEvidence(signals, tagInput);
         if (!relevant) {
             // #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

package/dist/algo/cycleEngine.d.ts

@@ -66,6 +66,8 @@ export interface CycleEngineDeps {
     rng?: () => number;
     /** Injected environment fingerprint (deterministic tests). Defaults to capturing the real runtime env. */
     envFingerprint?: () => EnvFingerprint;
+    /** Latest external capability gaps. Composition owns persistence/wire details; core reads one bounded snapshot. */
+    capabilityGaps?: () => readonly string[];
     /** 触发评估(常注入 TriggerEngine.evaluate 的包装; 缺省=直接触发). */
     trigger?: (p: ProblemPattern, now: number) => Promise<TriggerEval> | TriggerEval;
     /** 可进化人格(可选). 注入后, 每轮:
@@ -82,6 +84,8 @@ export interface CycleInput {
     cycleId: string;
     problem: ProblemPattern;
     signals: readonly string[];
+    /** Curriculum targets already prepared before candidate assembly. Omit for direct runCycle callers. */
+    curriculumSignals?: readonly string[];
     category: GepCategory;
     /** Optional explicit strategy preset name; when set, it wins over history-derived meta-signal auto-detection. */
     strategyName?: string;
@@ -150,5 +154,13 @@ export interface CycleResult {
 export declare class CycleEngine {
     private readonly deps;
     constructor(deps: CycleEngineDeps);
+    /**
+     * Add V1-compatible curriculum targets from V2's replayable event history. Public so the orchestrator can run
+     * it before candidate assembly; runCycle calls it again for direct callers. Set merging makes that idempotent.
+     */
+    prepareCurriculumSignals(signals: readonly string[]): {
+        signals: string[];
+        curriculumSignals: string[];
+    };
     runCycle(input: CycleInput): Promise<CycleResult>;
 }

package/dist/algo/cycleEngine.js

@@ -12,6 +12,7 @@ import { solidify } from './solidify.js';
 import { buildEvolutionEvent } from './evolutionEvent.js';
 import { cycleRecordsFromEvents } from '../signals/cycleHistoryFromEvents.js';
 import { computeMetaSignals, deriveCycleHistory } from '../signals/metaSignals.js';
+import { capabilityGapsFromSignals, curriculumOutcomesFromEvents, generateCurriculumSignals, normalizeCapabilityGaps, } from '../signals/curriculum.js';
 import { resolveStrategy } from './strategyPresets.js';
 import { classifyCycleFailure, } from './cycleFailureClassifier.js';
 import { isDistilledGeneId } from './geneIntake.js';
@@ -164,14 +165,44 @@ export class CycleEngine {
     constructor(deps) {
         this.deps = deps;
     }
+    /**
+     * Add V1-compatible curriculum targets from V2's replayable event history. Public so the orchestrator can run
+     * it before candidate assembly; runCycle calls it again for direct callers. Set merging makes that idempotent.
+     */
+    prepareCurriculumSignals(signals) {
+        let externalCapabilityGaps = [];
+        try {
+            externalCapabilityGaps = normalizeCapabilityGaps(this.deps.capabilityGaps?.() ?? []);
+        }
+        catch {
+            // An optional lifecycle-state reader must never suppress local curriculum generation.
+        }
+        try {
+            const localCapabilityGaps = capabilityGapsFromSignals(signals);
+            const curriculumSignals = generateCurriculumSignals({
+                outcomes: curriculumOutcomesFromEvents(this.deps.ingestor.readAll()),
+                // Preserve existing explicit local-signal precedence; Hub gaps fill the otherwise-missing V1 source.
+                capabilityGaps: normalizeCapabilityGaps([...localCapabilityGaps, ...externalCapabilityGaps]),
+            });
+            return { signals: mergeSignals(signals, curriculumSignals), curriculumSignals };
+        }
+        catch {
+            return { signals: [...signals], curriculumSignals: [] };
+        }
+    }
     async runCycle(input) {
         const { ingestor, store } = this.deps;
         const now = this.deps.now();
         const envKey = envFingerprintKey((this.deps.envFingerprint ?? captureEnvFingerprint)());
         const reasons = [];
-        const baseSignals = input.signals;
+        const baseSignals = [...input.signals];
+        const preparedSignals = input.curriculumSignals === undefined
+            ? this.prepareCurriculumSignals(input.signals)
+            : { signals: mergeSignals(input.signals, input.curriculumSignals), curriculumSignals: [...input.curriculumSignals] };
+        const selectionSignals = preparedSignals.signals;
+        const curriculumSignals = preparedSignals.curriculumSignals;
         const metaSignals = historyMetaSignals(ingestor, 100);
-        const cycleSignals = mergeSignals(baseSignals, metaSignals);
+        const cycleSignals = mergeSignals(selectionSignals, metaSignals);
         // PORT v1 #279 issue-reporter: classify cycle.failed payloads when the caller supplies host context. The
         // post-solidify failed path adds V2-local context (current gene + blast radius) so hard-filtered local no-op
         // genes are reachable without re-emitting the old ban_gene soft signal.
@@ -221,6 +252,7 @@ export class CycleEngine {
                 cycleId: input.cycleId,
                 signals: cycleSignals,
                 baseSignals,
+                ...(curriculumSignals.length > 0 ? { curriculumSignals } : {}),
                 ...(metaSignals.length > 0 ? { metaSignals, strategy: strategy.name } : {}),
             },
         });
@@ -250,7 +282,7 @@ export class CycleEngine {
             //    recentEvents 由事件日志的近期 outcome 派生, 让"失败连击触发变异"在环内真正生效.
             const sel = await applySelectForRun(personalityDeps, {
                 driftEnabled: plateau.active,
-                signals: baseSignals,
+                signals: selectionSignals,
                 recentEvents: recentOutcomes.map((status) => ({ outcome: { status } })),
             });
             personalityForRun = sel.state;
@@ -301,7 +333,7 @@ export class CycleEngine {
             const epi = epigeneticPenaltyForIds(candidateIds(c), envKey, geneOutcomes);
             return epi > 0 ? { ...c, epigeneticPenalty: epi } : c;
         });
-        const decision = (await this.deps.selection.run({ signals: baseSignals, candidates, floor: input.selectionFloor, ...(input.forcedGeneId !== undefined ? { forcedGeneId: input.forcedGeneId } : {}), ...(exploration ? { exploration } : {}), ...(distilledFallback.length > 0 ? { distilledFallback } : {}), ...(input.antiWarnings && input.antiWarnings.length > 0 ? { antiWarnings: input.antiWarnings } : {}), ...(input.memoryEvidence && input.memoryEvidence.length > 0 ? { memoryEvidence: input.memoryEvidence } : {}) }, { now, cycleId: input.cycleId, ...(this.deps.rng ? { rng: this.deps.rng } : {}) }));
+        const decision = (await this.deps.selection.run({ signals: selectionSignals, candidates, floor: input.selectionFloor, ...(input.forcedGeneId !== undefined ? { forcedGeneId: input.forcedGeneId } : {}), ...(exploration ? { exploration } : {}), ...(distilledFallback.length > 0 ? { distilledFallback } : {}), ...(input.antiWarnings && input.antiWarnings.length > 0 ? { antiWarnings: input.antiWarnings } : {}), ...(input.memoryEvidence && input.memoryEvidence.length > 0 ? { memoryEvidence: input.memoryEvidence } : {}) }, { now, cycleId: input.cycleId, ...(this.deps.rng ? { rng: this.deps.rng } : {}) }));
         await ingestor.ingest({
             type: 'decision.gene_selected',
             human: { title: `选 gene ${decision.selectedGeneId ?? '(innovate)'}`, why: decision.candidates.map((c) => `${c.geneId}:${c.score.toFixed(3)}`).join(', ') || '无候选→innovate' },

package/dist/algo/geneHealth.d.ts

@@ -12,10 +12,10 @@ export interface GeneHealthWeights {
     reuse: number;
     antiPattern: number;
 }
-export declare const HEALTH_WEIGHTS_VERSION = "gh-1";
+export declare const HEALTH_WEIGHTS_VERSION = "gh-2";
 export declare const DEFAULT_HEALTH_WEIGHTS: GeneHealthWeights;
 /**
- * gene 健康分 = w1·successRate + w2·reuse归一 − w3·antiPattern密度.
+ * gene 健康分 = successRate·(w1 + w2·reuse归一) − w3·antiPattern密度.
  * 输入 = M3-6 聚合视图(不内联 learning_history) + anti_patterns 数 + 复用计数.
  */
 export declare function geneHealthScore(view: GeneLearningView, opts?: {

package/dist/algo/geneHealth.js

@@ -1,16 +1,17 @@
-export const HEALTH_WEIGHTS_VERSION = 'gh-1';
-export const DEFAULT_HEALTH_WEIGHTS = { successRate: 0.6, reuse: 0.3, antiPattern: 0.4 };
+export const HEALTH_WEIGHTS_VERSION = 'gh-2';
+export const DEFAULT_HEALTH_WEIGHTS = { successRate: 0.6, reuse: 0.1, antiPattern: 0.4 };
 /** reuseCount 归一(对数压缩, 复用越多分越高但边际递减). */
 function reuseScore(count) {
     return count <= 0 ? 0 : Math.min(1, Math.log10(count + 1) / 2); // 100 次≈封顶
 }
 /**
- * gene 健康分 = w1·successRate + w2·reuse归一 − w3·antiPattern密度.
+ * gene 健康分 = successRate·(w1 + w2·reuse归一) − w3·antiPattern密度.
  * 输入 = M3-6 聚合视图(不内联 learning_history) + anti_patterns 数 + 复用计数.
  */
 export function geneHealthScore(view, opts = {}, w = DEFAULT_HEALTH_WEIGHTS) {
     const reuseCount = opts.reuseCount ?? view.total;
     const antiPatternPenalty = Math.min(1, (opts.antiPatternCount ?? 0) / 5); // 5+ anti-pattern 封顶惩罚
-    const score = w.successRate * view.successRate + w.reuse * reuseScore(reuseCount) - w.antiPattern * antiPatternPenalty;
+    const confidenceAdjustedSuccess = view.successRate * (w.successRate + w.reuse * reuseScore(reuseCount));
+    const score = confidenceAdjustedSuccess - w.antiPattern * antiPatternPenalty;
     return { geneId: view.geneId, successRate: view.successRate, reuseCount, antiPatternPenalty, score };
 }

package/dist/algo/geneSelection.d.ts

@@ -134,7 +134,7 @@ export declare const MEMORY_GRAPH_WEIGHT = 0.12;
  * + CONFIDENCE_WEIGHT × confidence + REUSE_WEIGHT × reuse-sentiment). Bumped whenever a factor is added so golden
  * weight snapshots track the change. Composed from the health-weights version so a change to either layer shows.
  */
-export declare const SELECTION_WEIGHTS_VERSION = "sel-4(gh-1,conf=0.15,memory=0.12,reuse=0.1)";
+export declare const SELECTION_WEIGHTS_VERSION = "sel-4(gh-2,conf=0.15,memory=0.12,reuse=0.1)";
 /** 实现1: engine 健康分主导(health 0.6 + 信号匹配 0.4). */
 export declare const engineHealthSelection: Strategy<SelectionInput, GeneDecision>;
 /** 实现2: 纯信号匹配采样(忽略 health, 对照基线 — 经验主义要可对比). */

package/dist/algo/orchestrator.js

@@ -18,6 +18,12 @@ export async function runEvolutionCycle(engine, store, opts) {
             console.warn(`[ExplicitSignals] Failed to consume pending signals (non-fatal): ${message}`);
         }
     }
+    // Curriculum targets must be present before candidate assembly; injecting them only inside CycleEngine would
+    // be too late to recall a gene whose signals_match is curriculum_target:*. The engine repeats this enrichment
+    // for direct runCycle callers; the operation is deterministic and set-idempotent.
+    const baseSignals = signals;
+    const preparedCurriculum = engine.prepareCurriculumSignals(baseSignals);
+    const selectionSignals = preparedCurriculum.signals;
     // #268 phase 1 + #274 slice 3: fold cross-runtime reuse counts AND observed recall into the pool (soft re-order).
     // Absent both → no map → default-off. Recall is folded at a lower weight (RECALL_WEIGHT). Assembly sums a gene's
     // ids → sentiment; bounded + clamped in geneSelection; the hard trust/review/ban gates in assembly run first.
@@ -38,7 +44,7 @@ export async function runEvolutionCycle(engine, store, opts) {
         ...(opts.hubCandidates && opts.hubCandidates.length > 0 ? { hubCandidates: opts.hubCandidates } : {}),
         ...(reuseCounts.size > 0 ? { reuseCounts } : {}),
     };
-    const { candidates: assembledCandidates, distilledFallback, antiWarnings } = await assembleSelectionPool(store, signals, asmOpts);
+    const { candidates: assembledCandidates, distilledFallback, antiWarnings } = await assembleSelectionPool(store, selectionSignals, asmOpts);
     const memoryByGene = new Map((opts.memoryGraphAdvice?.genes ?? []).map((evidence) => [evidence.geneId, evidence]));
     const candidates = assembledCandidates.map((candidate) => {
         const evidence = memoryByGene.get(candidate.geneId) ?? (candidate.assetId ? memoryByGene.get(candidate.assetId) : undefined);
@@ -53,7 +59,8 @@ export async function runEvolutionCycle(engine, store, opts) {
     return engine.runCycle({
         cycleId: opts.cycleId,
         problem: opts.problem,
-        signals,
+        signals: baseSignals,
+        curriculumSignals: preparedCurriculum.curriculumSignals,
         category: opts.category,
         ...(opts.strategyName !== undefined ? { strategyName: opts.strategyName } : {}),
         candidates,

package/dist/assetstore/assetSidecarRecords.js

@@ -62,6 +62,9 @@ export function parseProvenanceRecord(value) {
     const decidedBy = stringField(record, 'decidedBy');
     const promotedBy = stringField(record, 'promotedBy');
     const reason = stringField(record, 'reason');
+    const frozenContentId = stringField(record, 'frozenContentId');
+    if (frozenContentId !== undefined && !/^sha256:[0-9a-f]{64}$/.test(frozenContentId))
+        return null;
     return {
         assetId,
         source,
@@ -71,6 +74,7 @@ export function parseProvenanceRecord(value) {
         ...(decidedBy ? { decidedBy } : {}),
         ...(promotedBy ? { promotedBy } : {}),
         ...(reason ? { reason } : {}),
+        ...(frozenContentId ? { frozenContentId } : {}),
     };
 }
 export function parseReviewRecord(value) {

package/dist/assetstore/assetStoreHealth.js

@@ -1,7 +1,7 @@
 import { lstatSync } from 'node:fs';
 import { join } from 'node:path';
 import { acquireLock, releaseLock } from '../util/fileLock.js';
-import { validateWire, verifyAssetId } from '../wire/index.js';
+import { computeAssetId, validateWire, verifyAssetId } from '../wire/index.js';
 import { LOCAL_ASSET_FILES } from './assetStoreLayout.js';
 import { assertOptionalRegularFile, isReliableAssetStoreLockRelease, readUtf8Regular, UnsafeAssetStorePathError, } from './assetStoreStorage.js';
 import { parseAssetSyncSidecarRecord, parseProvenanceRecord, parseReviewRecord, parseSidecarJsonl, } from './assetSidecarRecords.js';
@@ -107,7 +107,7 @@ function summarize(files, sidecars) {
         sidecars: [...sidecars],
     };
 }
-function inspectFile(baseDir, kind, file, maxFileBytes, unverifiedIds) {
+function inspectFile(baseDir, kind, file, maxFileBytes, unverifiedContentIds) {
     try {
         const path = join(baseDir, file);
         const stat = assertOptionalRegularFile(path);
@@ -116,7 +116,7 @@ function inspectFile(baseDir, kind, file, maxFileBytes, unverifiedIds) {
         if (stat.size > maxFileBytes) {
             return { ...emptyFile(kind, file, 'unavailable', 'scan_limit_exceeded'), bytes: stat.size };
         }
-        const raw = readUtf8Regular(path);
+        const raw = readUtf8Regular(path, maxFileBytes);
         if (raw === null)
             return emptyFile(kind, file, 'unavailable', 'read_unavailable');
         const rows = raw.split('\n').filter((line) => line.trim().length > 0);
@@ -144,21 +144,22 @@ function inspectFile(baseDir, kind, file, maxFileBytes, unverifiedIds) {
                     duplicateRows += 1;
                 else
                     seen.add(assetId);
-                if (!verifyAssetId(record)) {
+                const hashMatches = verifyAssetId(record);
+                if (!hashMatches) {
                     // 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))
+                    if (unverifiedContentIds.get(assetId) === computeAssetId(record))
                         unverifiedRows += 1;
                     else
                         hashMismatchRows += 1;
-                    continue;
                 }
-                if (kind !== 'AntiGene' && !validateWire(record).ok) {
+                const schemaValid = kind === 'AntiGene' || validateWire(record).ok;
+                if (!schemaValid) {
                     schemaInvalidRows += 1;
-                    continue;
                 }
-                validRows += 1;
+                if (hashMatches && schemaValid)
+                    validRows += 1;
             }
             catch {
                 corruptRows += 1;
@@ -195,20 +196,36 @@ function inspectFile(baseDir, kind, file, maxFileBytes, unverifiedIds) {
     }
 }
 /**
- * Asset ids marked in the provenance sidecar as an unverified hub reuse (reason `unverified_*`, evolver-v2#570).
+ * Asset ids whose latest provenance decision marks an unverified hub reuse (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.
+ * unreadable sidecar yields an empty map: without provenance every mismatch stays classified as corruption.
  */
-function readUnverifiedReuseIds(baseDir) {
-    const raw = readUtf8Regular(join(baseDir, 'provenance.jsonl'));
+function readUnverifiedReuseContentIds(baseDir, maxFileBytes) {
+    let raw;
+    try {
+        raw = readUtf8Regular(join(baseDir, 'provenance.jsonl'), maxFileBytes);
+    }
+    catch {
+        return new Map();
+    }
     if (raw === null)
-        return new Set();
-    const ids = new Set();
+        return new Map();
+    const ids = new Map();
     for (const record of parseSidecarJsonl(raw, parseProvenanceRecord).records) {
-        if (record.trusted === false && typeof record.reason === 'string' && record.reason.startsWith('unverified_')) {
-            ids.add(record.assetId);
-        }
+        const frozenContentId = record.frozenContentId;
+        const supportedReason = (record.source === 'hub'
+            && (record.reason === 'unverified_hub_rewrite' || record.reason === 'unverified_hub_synthesized')) || (record.source === 'migrated' && record.reason === 'unverified_gepx_import');
+        const qualifies = supportedReason
+            && record.trusted === false
+            && record.decision === undefined
+            && record.decidedBy === undefined
+            && record.promotedBy === undefined
+            && frozenContentId !== undefined;
+        if (qualifies)
+            ids.set(record.assetId, frozenContentId);
+        else
+            ids.delete(record.assetId);
     }
     return ids;
 }
@@ -222,7 +239,7 @@ function inspectSidecar(baseDir, definition, maxFileBytes) {
         if (stat.size > maxFileBytes) {
             return { ...emptySidecar(kind, file, 'unavailable', 'scan_limit_exceeded'), bytes: stat.size };
         }
-        const raw = readUtf8Regular(path);
+        const raw = readUtf8Regular(path, maxFileBytes);
         if (raw === null)
             return emptySidecar(kind, file, 'unavailable', 'read_unavailable');
         const parsed = parseSidecarJsonl(raw, parseRecord);
@@ -283,14 +300,14 @@ export function inspectLocalAssetStore(baseDir, opts = {}, deps = {}) {
     catch {
         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 {
+        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 bounded provenance snapshot.
+        const unverifiedContentIds = readUnverifiedReuseContentIds(baseDir, maxFileBytes);
         report = summarize(Object.entries(LOCAL_ASSET_FILES)
-            .map(([kind, file]) => inspectFile(baseDir, kind, file, maxFileBytes, unverifiedIds)), LOCAL_ASSET_SIDECARS.map((definition) => inspectSidecar(baseDir, definition, maxFileBytes)));
+            .map(([kind, file]) => inspectFile(baseDir, kind, file, maxFileBytes, unverifiedContentIds)), LOCAL_ASSET_SIDECARS.map((definition) => inspectSidecar(baseDir, definition, maxFileBytes)));
     }
     catch {
         report = summarize(allFiles('unavailable', 'read_unavailable'), allSidecars('unavailable', 'read_unavailable'));

package/dist/assetstore/assetStoreStorage.d.ts

@@ -33,7 +33,7 @@ export declare function withAssetStoreLock<T>(lockPath: string, operation: () =>
 export declare function assertOptionalRegularFile(path: string, role?: AssetStorePathRole): Stats | null;
 export declare function regularFileFingerprint(path: string): string;
 export declare function readRegularBuffer(path: string, maxBytes?: number): Buffer | null;
-export declare function readUtf8Regular(path: string): string | null;
+export declare function readUtf8Regular(path: string, maxBytes?: number): string | null;
 export declare function createBufferDurableExclusive(path: string, value: Buffer, opts?: DurableWriteOptions): void;
 export declare function fsyncDirectoryBestEffort(path: string): void;
 export declare function appendUtf8Durable(path: string, value: string, opts?: DurableWriteOptions): void;

package/dist/assetstore/assetStoreStorage.js

@@ -1,5 +1,5 @@
 import { randomUUID } from 'node:crypto';
-import { closeSync, constants, fstatSync, fsyncSync, ftruncateSync, lstatSync, mkdirSync, openSync, readFileSync, readSync, renameSync, unlinkSync, writeSync, } from 'node:fs';
+import { closeSync, constants, fstatSync, fsyncSync, ftruncateSync, lstatSync, mkdirSync, openSync, readSync, renameSync, unlinkSync, writeSync, } from 'node:fs';
 import { basename, dirname, join } from 'node:path';
 import { acquireLock, LockReleaseError, releaseLock, } from '../util/fileLock.js';
 export class UnsafeAssetStorePathError extends Error {
@@ -152,17 +152,26 @@ export function readRegularBuffer(path, maxBytes = Number.MAX_SAFE_INTEGER) {
         assertOpenedPathMatches(fd, path, 'asset_file');
         if (fstatSync(fd).size > maxBytes)
             throw new AssetStoreReadLimitError();
-        const value = readFileSync(fd);
-        if (value.byteLength > maxBytes)
-            throw new AssetStoreReadLimitError();
-        return value;
+        const chunks = [];
+        let total = 0;
+        while (total <= maxBytes) {
+            const chunk = Buffer.allocUnsafe(Math.min(64 * 1024, maxBytes - total + 1));
+            const bytesRead = readSync(fd, chunk, 0, chunk.byteLength, null);
+            if (bytesRead === 0)
+                break;
+            total += bytesRead;
+            if (total > maxBytes)
+                throw new AssetStoreReadLimitError();
+            chunks.push(bytesRead === chunk.byteLength ? chunk : chunk.subarray(0, bytesRead));
+        }
+        return Buffer.concat(chunks, total);
     }
     finally {
         closeSync(fd);
     }
 }
-export function readUtf8Regular(path) {
-    return readRegularBuffer(path)?.toString('utf8') ?? null;
+export function readUtf8Regular(path, maxBytes = Number.MAX_SAFE_INTEGER) {
+    return readRegularBuffer(path, maxBytes)?.toString('utf8') ?? null;
 }
 function writeAll(fd, value) {
     const bytes = typeof value === 'string' ? Buffer.from(value, 'utf8') : value;

package/dist/assetstore/localJsonl.d.ts

@@ -25,8 +25,9 @@ export declare class LocalJsonlProvider implements AssetStoreProvider {
      * 仅 v1→v2 导入用(硬化 A6 存量冻结); 普通写一律走 put(). record 必须自带 asset_id.
      */
     putFrozen(record: AssetRecord): Promise<PutResult>;
+    putFrozenConditional(record: AssetRecord, options?: ConditionalPutOptions): Promise<ConditionalPutResult>;
     get(assetId: string): Promise<AssetRecord | null>;
-    findByLogicalId(id: string, limit?: number): Promise<AssetRecord[]>;
+    findByLogicalId(id: string, limit?: number, kind?: AssetKind): Promise<AssetRecord[]>;
     list(kind?: AssetKind, limit?: number): Promise<AssetRecord[]>;
     search(q: SearchQuery): Promise<AssetRecord[]>;
     /**

package/dist/assetstore/localJsonl.js

@@ -2,7 +2,12 @@ import { join } from 'node:path';
 import { acquireLock, releaseLock } from '../util/fileLock.js';
 import { appendUtf8Durable, assertAssetStoreDirectory, assertOptionalRegularFile, ensureAssetStoreDirectory, readUtf8Regular, regularFileFingerprint, replaceUtf8Durable, } from './assetStoreStorage.js';
 import { LOCAL_ASSET_FILES } from './assetStoreLayout.js';
-import { normalizeForPut, } from './provider.js';
+import { FrozenAssetIdCollisionError, frozenAssetRecordsEqual, normalizeForPut, } from './provider.js';
+function resultLogicalId(logicalId) {
+    return logicalId !== undefined && logicalId.length > 0 && logicalId === logicalId.trim()
+        ? logicalId
+        : undefined;
+}
 function signalsOf(a) {
     const out = [];
     for (const key of ['signals_match', 'signals', 'trigger', 'trigger_signals']) {
@@ -109,13 +114,16 @@ export class LocalJsonlProvider {
         try {
             // Refresh under the shared lock so another process cannot append between reload and dedupe.
             this.refreshUnderLock();
-            if (this.index.has(record.asset_id)) {
+            const existing = this.index.get(record.asset_id);
+            if (existing) {
+                if (!frozenAssetRecordsEqual(existing, record))
+                    throw new FrozenAssetIdCollisionError(record.asset_id);
                 return {
                     asset_id: record.asset_id,
                     stored: false,
                     verified,
                     status: 'already_exists',
-                    logicalId,
+                    ...(resultLogicalId(logicalId) ? { logicalId } : {}),
                 };
             }
             collision = logicalId === undefined
@@ -129,7 +137,7 @@ export class LocalJsonlProvider {
                     stored: false,
                     verified,
                     status: 'logical_collision',
-                    logicalId,
+                    ...(resultLogicalId(logicalId) ? { logicalId } : {}),
                     collisionWithAssetId: collision.asset_id,
                 };
             }
@@ -146,7 +154,7 @@ export class LocalJsonlProvider {
             verified,
             status: 'stored',
             ...(collision ? {
-                logicalId,
+                ...(resultLogicalId(logicalId) ? { logicalId } : {}),
                 collisionWithAssetId: collision.asset_id,
             } : {}),
         };
@@ -156,15 +164,42 @@ export class LocalJsonlProvider {
      * 仅 v1→v2 导入用(硬化 A6 存量冻结); 普通写一律走 put(). record 必须自带 asset_id.
      */
     async putFrozen(record) {
+        return this.putFrozenConditional(record, { allowLogicalCollision: true });
+    }
+    async putFrozenConditional(record, options = {}) {
         if (!record.asset_id)
             throw new Error('putFrozen 需 record 自带冻结 asset_id');
         const file = join(this.baseDir, LOCAL_ASSET_FILES[record.type]);
+        let logicalId;
+        let collision;
         assertOptionalRegularFile(this.lockPath, 'lock_file');
         acquireLock(this.lockPath);
         try {
             this.refreshUnderLock();
-            if (this.index.has(record.asset_id))
-                return { asset_id: record.asset_id, stored: false, verified: false };
+            const existing = this.index.get(record.asset_id);
+            if (existing) {
+                if (!frozenAssetRecordsEqual(existing, record))
+                    throw new FrozenAssetIdCollisionError(record.asset_id);
+                return { asset_id: record.asset_id, stored: false, verified: false, status: 'already_exists' };
+            }
+            logicalId = typeof record['id'] === 'string' && record['id'].length > 0
+                ? record['id']
+                : undefined;
+            collision = logicalId === undefined
+                ? undefined
+                : [...this.index.values()].find((candidate) => (candidate.type === record.type
+                    && candidate['id'] === logicalId
+                    && candidate.asset_id !== record.asset_id));
+            if (collision && !options.allowLogicalCollision) {
+                return {
+                    asset_id: record.asset_id,
+                    stored: false,
+                    verified: false,
+                    status: 'logical_collision',
+                    ...(resultLogicalId(logicalId) ? { logicalId } : {}),
+                    collisionWithAssetId: collision.asset_id,
+                };
+            }
             appendUtf8Durable(file, `${JSON.stringify(record)}\n`);
             this.index.set(record.asset_id, record);
             this.updateFileStateAfterWrite();
@@ -172,18 +207,27 @@ export class LocalJsonlProvider {
         finally {
             releaseLock(this.lockPath);
         }
-        return { asset_id: record.asset_id, stored: true, verified: false };
+        return {
+            asset_id: record.asset_id,
+            stored: true,
+            verified: false,
+            status: 'stored',
+            ...(collision ? {
+                ...(resultLogicalId(logicalId) ? { logicalId } : {}),
+                collisionWithAssetId: collision.asset_id,
+            } : {}),
+        };
     }
     async get(assetId) {
         this.ensureFresh();
         return this.index.get(assetId) ?? null;
     }
-    async findByLogicalId(id, limit = 2) {
+    async findByLogicalId(id, limit = 2, kind) {
         this.ensureFresh();
         const boundedLimit = Number.isFinite(limit) ? Math.max(1, Math.min(1_000, Math.floor(limit))) : 2;
         const out = [];
         for (const record of this.index.values()) {
-            if (record['id'] !== id)
+            if (record['id'] !== id || (kind !== undefined && record.type !== kind))
                 continue;
             out.push(record);
             if (out.length >= boundedLimit)

package/dist/assetstore/provenance.d.ts

@@ -11,11 +11,18 @@ export interface ProvenanceRecord {
     /** Legacy promotion actor field kept for existing sidecar readers. */
     promotedBy?: string;
     reason?: string;
+    /** Canonical content id of the exact hash-mismatched body accepted by an unverified Hub ingest. */
+    frozenContentId?: string;
 }
 export interface ProvenanceTrustChange {
     changed: boolean;
     record: ProvenanceRecord;
 }
+export declare class ProvenanceWritePendingError extends Error {
+    readonly assetId: string;
+    readonly code = "PROVENANCE_WRITE_PENDING";
+    constructor(assetId: string);
+}
 /**
  * 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
@@ -36,6 +43,21 @@ export declare class ProvenanceStore {
     mark(rec: Omit<ProvenanceRecord, 'at'> & {
         at?: string;
     }): ProvenanceRecord;
+    /** Stage a verified Hub write without replacing an in-flight conservative marker. */
+    stageUntrustedWriteTracked(assetId: string, source: ProvenanceSource): {
+        record: ProvenanceRecord;
+        appended: boolean;
+    };
+    /** Finalize a verified write unless an operator made an explicit decision during I/O. */
+    finalizeUntrustedWrite(assetId: string, source: ProvenanceSource): ProvenanceRecord;
+    /** Stage an unverified write without overwriting an explicit trust decision or another conservative marker. */
+    stageUnverifiedWrite(assetId: string, source: ProvenanceSource, frozenContentId: string): ProvenanceRecord;
+    stageUnverifiedWriteTracked(assetId: string, source: ProvenanceSource, frozenContentId: string): {
+        record: ProvenanceRecord;
+        appended: boolean;
+    };
+    /** Atomically replace only a pending/no decision with the health-waiver reason after verified persistence. */
+    finalizeUnverifiedWrite(assetId: string, source: ProvenanceSource, reason: string, frozenContentId: string): ProvenanceRecord;
     rollbackLast(rec: ProvenanceRecord): void;
     get(assetId: string): ProvenanceRecord | null;
     /** No record → trusted (local default); a record → its trusted flag. */
@@ -67,6 +89,8 @@ export declare function ingestUntrusted(store: AssetStoreProvider, prov: Provena
  * 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>;
+/** Atomic frozen variant used by reuse so the logical-id check and append share one provider lock. */
+export declare function ingestUnverifiedConditional(store: AssetStoreProvider, prov: ProvenanceStore, record: AssetRecord, reason: string, options?: ConditionalPutOptions, source?: ProvenanceSource): Promise<ConditionalPutResult>;
 /**
  * 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.