@evomap/evolver-core 2.0.0-beta.9 → 2.0.0

package/dist/assetstore/provider.js

@@ -1,4 +1,87 @@
-import { computeAssetId, verifyAssetId } from '../wire/index.js';
+import { canonicalize, computeAssetId, verifyAssetId } from '../wire/index.js';
+export class FrozenAssetIdCollisionError extends Error {
+    assetId;
+    code = 'FROZEN_ASSET_ID_COLLISION';
+    constructor(assetId) {
+        super('frozen asset_id already exists with different content');
+        this.assetId = assetId;
+        this.name = 'FrozenAssetIdCollisionError';
+    }
+}
+export class InvalidFrozenPutResultError extends Error {
+    code = 'INVALID_FROZEN_PUT_RESULT';
+    constructor() {
+        super('invalid frozen put result');
+        this.name = 'InvalidFrozenPutResultError';
+    }
+}
+export function frozenAssetRecordsEqual(left, right) {
+    return canonicalize(left) === canonicalize(right);
+}
+export function validateFrozenPutResult(value, expectedAssetId) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        throw new InvalidFrozenPutResultError();
+    const result = value;
+    if (result['asset_id'] !== expectedAssetId
+        || typeof result['stored'] !== 'boolean'
+        || result['verified'] !== false) {
+        throw new InvalidFrozenPutResultError();
+    }
+    return value;
+}
+export class InvalidConditionalPutResultError extends Error {
+    reason;
+    code = 'INVALID_CONDITIONAL_PUT_RESULT';
+    constructor(reason) {
+        super(`invalid conditional put result: ${reason}`);
+        this.reason = reason;
+        this.name = 'InvalidConditionalPutResultError';
+    }
+}
+/** Validate an injected provider response before callers treat it as an explicit write/no-write decision. */
+export function validateConditionalPutResult(value, expectedAssetId, options) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        throw new InvalidConditionalPutResultError('malformed_result');
+    }
+    const result = value;
+    const status = result['status'];
+    const collisionWithAssetId = result['collisionWithAssetId'];
+    if (typeof result['asset_id'] !== 'string'
+        || typeof result['stored'] !== 'boolean'
+        || typeof result['verified'] !== 'boolean'
+        || (status !== 'stored' && status !== 'already_exists' && status !== 'logical_collision')
+        || (result['logicalId'] !== undefined
+            && (typeof result['logicalId'] !== 'string'
+                || !result['logicalId'].trim()
+                || result['logicalId'] !== result['logicalId'].trim()))
+        || (collisionWithAssetId !== undefined
+            && (typeof collisionWithAssetId !== 'string'
+                || !collisionWithAssetId.trim()
+                || collisionWithAssetId !== collisionWithAssetId.trim()))) {
+        throw new InvalidConditionalPutResultError('malformed_result');
+    }
+    if (result['asset_id'] !== expectedAssetId) {
+        throw new InvalidConditionalPutResultError('asset_id_mismatch');
+    }
+    if (result['stored'] !== (status === 'stored')) {
+        throw new InvalidConditionalPutResultError('inconsistent_status');
+    }
+    const allowLogicalCollision = options?.allowLogicalCollision === true;
+    if (status === 'logical_collision'
+        && (!collisionWithAssetId || collisionWithAssetId === expectedAssetId || allowLogicalCollision)) {
+        throw new InvalidConditionalPutResultError('invalid_collision');
+    }
+    if (status === 'stored' && collisionWithAssetId && !allowLogicalCollision) {
+        throw new InvalidConditionalPutResultError('collision_bypass');
+    }
+    return value;
+}
+export function supportsAtomicConditionalPut(provider) {
+    return typeof provider.putConditional === 'function';
+}
+export function supportsAtomicFrozenConditionalPut(provider) {
+    return typeof provider.putFrozenConditional === 'function';
+}
 export class AssetIdMismatchError extends Error {
     claimed;
     actual;
@@ -12,6 +95,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 表示非入参自带).
@@ -19,11 +114,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/dist/benchmark/antiGeneBenchmark.d.ts

@@ -70,6 +70,8 @@ export interface AntiGeneBenchmarkOptions {
     minFailureDelta?: number;
     now?: () => number;
     eventsPath?: string;
+    /** Apply the pre-IDF semantic scorer consistently to both A/B arms. */
+    disableSemanticIdf?: boolean;
 }
 export interface AntiGeneBenchmarkDeps {
     store: AssetStoreProvider;

package/dist/benchmark/antiGeneBenchmark.js

@@ -79,7 +79,7 @@ function executeFor(outcome) {
         },
     });
 }
-async function runOneArm(arm, task, source, sourceReview, rootDir, now) {
+async function runOneArm(arm, task, source, sourceReview, rootDir, now, disableSemanticIdf) {
     const armDir = join(rootDir, arm, task.id);
     const store = new LocalJsonlProvider(join(armDir, 'assets'));
     const review = new ReviewLedger(join(armDir, 'assets'), now);
@@ -105,6 +105,7 @@ async function runOneArm(arm, task, source, sourceReview, rootDir, now) {
         execute: executeFor(spec),
         review,
         consumePendingSignals: false,
+        ...(disableSemanticIdf ? { disableSemanticIdf: true } : {}),
     };
     const result = await runEvolutionCycle(engine, store, opts);
     const observed = observedWarningIds(result.decision);
@@ -168,8 +169,8 @@ export async function runAntiGeneBenchmark(suite, deps, options = {}) {
         for (const task of suite.tasks) {
             taskResults.push({
                 taskId: task.id,
-                baseline: await runOneArm('baseline', task, deps.store, sourceReview, rootDir, now),
-                antiGene: await runOneArm('antiGene', task, deps.store, sourceReview, rootDir, now),
+                baseline: await runOneArm('baseline', task, deps.store, sourceReview, rootDir, now, options.disableSemanticIdf === true),
+                antiGene: await runOneArm('antiGene', task, deps.store, sourceReview, rootDir, now, options.disableSemanticIdf === true),
             });
         }
         const report = buildReport(suite, taskResults, minSamples, minFailureDelta);

package/dist/benchmark/antiGeneRollout.d.ts

@@ -75,6 +75,8 @@ export interface AntiGeneRolloutOptions {
     minFailureDelta?: number;
     now?: () => number;
     eventsPath?: string;
+    /** Apply the pre-IDF semantic scorer consistently to both A/B arms. */
+    disableSemanticIdf?: boolean;
 }
 export declare function runAntiGeneRollout(suite: AntiGeneRolloutSuite, deps: AntiGeneRolloutDeps, options?: AntiGeneRolloutOptions): Promise<AntiGeneRolloutReport>;
 export declare function writeAntiGeneRolloutResult(report: AntiGeneRolloutReport, eventsPath: string, now?: () => number): Promise<void>;

package/dist/benchmark/antiGeneRollout.js

@@ -82,7 +82,7 @@ function scoreFromResult(result, status) {
     const score = result.capsule?.outcome?.score;
     return typeof score === 'number' && Number.isFinite(score) ? score : status === 'success' ? 0.9 : 0.2;
 }
-async function runOneArm(arm, task, source, sourceReview, makeExecute, rootDir, now) {
+async function runOneArm(arm, task, source, sourceReview, makeExecute, rootDir, now, disableSemanticIdf) {
     const armDir = join(rootDir, arm, task.id);
     const store = new LocalJsonlProvider(join(armDir, 'assets'));
     const review = new ReviewLedger(join(armDir, 'assets'), now);
@@ -107,6 +107,7 @@ async function runOneArm(arm, task, source, sourceReview, makeExecute, rootDir,
         execute: makeExecute({ arm, task, store, review, armDir }),
         review,
         consumePendingSignals: false,
+        ...(disableSemanticIdf ? { disableSemanticIdf: true } : {}),
     };
     const result = await runEvolutionCycle(engine, store, opts);
     const status = statusFromResult(result);
@@ -183,8 +184,8 @@ export async function runAntiGeneRollout(suite, deps, options = {}) {
         for (const task of suite.tasks) {
             taskResults.push({
                 taskId: task.id,
-                baseline: await runOneArm('baseline', task, deps.store, sourceReview, deps.makeExecute, rootDir, now),
-                antiGene: await runOneArm('antiGene', task, deps.store, sourceReview, deps.makeExecute, rootDir, now),
+                baseline: await runOneArm('baseline', task, deps.store, sourceReview, deps.makeExecute, rootDir, now, options.disableSemanticIdf === true),
+                antiGene: await runOneArm('antiGene', task, deps.store, sourceReview, deps.makeExecute, rootDir, now, options.disableSemanticIdf === true),
             });
         }
         const report = buildReport(suite, taskResults, minSamples, minFailureDelta);

package/dist/benchmark/index.d.ts

@@ -3,4 +3,5 @@ export * from './thesis.js';
 export * from './evolutionThesisSolver.js';
 export * from './antiGeneBenchmark.js';
 export * from './antiGeneRollout.js';
-export * from './triggerShift.js';
+export * from './triggerShift.js';
+export * from './selectionFlatAbstention.js';

package/dist/benchmark/index.js

@@ -3,4 +3,5 @@ export * from './thesis.js';
 export * from './evolutionThesisSolver.js';
 export * from './antiGeneBenchmark.js';
 export * from './antiGeneRollout.js';
-export * from './triggerShift.js';
+export * from './triggerShift.js';
+export * from './selectionFlatAbstention.js';

package/dist/benchmark/selectionFlatAbstention.d.ts

@@ -0,0 +1,152 @@
+import { type GeneDecision, type SelectionInput } from '../algo/geneSelection.js';
+export declare const SELECTION_FLAT_ABSTENTION_BENCHMARK_VERSION = "global-flat-abstention-paired-v1";
+export type SelectionFlatArm = 'current' | 'global-flat-abstain';
+export type SelectionFlatSplit = 'calibration' | 'holdout';
+export type SelectionFlatAction = {
+    kind: 'reuse';
+    geneId: string;
+    assetId?: string;
+} | {
+    kind: 'innovate';
+};
+export interface SelectionFlatComparison {
+    targeted: boolean;
+    targetReason?: 'outside_plateau_flat_positive';
+    currentDecision: GeneDecision;
+    currentAction: SelectionFlatAction;
+    globalFlatAbstainAction: SelectionFlatAction;
+}
+export interface SelectionFlatCohort {
+    id: string;
+    version: string;
+    sourceCommit: string;
+    taskFingerprints: readonly string[];
+    verifier: {
+        id: string;
+        version: string;
+    };
+}
+export type SelectionFlatExpectedRole = 'target' | 'control';
+export interface SelectionFlatExpectation {
+    role: SelectionFlatExpectedRole;
+    currentAction: SelectionFlatAction;
+    globalFlatAbstainAction: SelectionFlatAction;
+}
+export interface SelectionFlatTaskSnapshot<I> {
+    id: string;
+    workspaceSnapshotDigest: string;
+    split: SelectionFlatSplit;
+    stratum: string;
+    /** Verifier input is a private structured-clone-normalized copy (for example, Node Buffer becomes Uint8Array). */
+    payload: I;
+    selection: Omit<SelectionInput, 'selectionGuard'>;
+    expectation: SelectionFlatExpectation;
+}
+export interface SelectionFlatTask<I> extends SelectionFlatTaskSnapshot<I> {
+    taskFingerprint: string;
+}
+export interface SelectionFlatBenchmarkSuite<I> {
+    name: string;
+    cohort: SelectionFlatCohort;
+    tasks: readonly SelectionFlatTask<I>[];
+}
+export interface SelectionFlatVerifierProof {
+    id: string;
+    version: string;
+    proofSha256: string;
+}
+export interface SelectionFlatObjectiveOutcome {
+    passed: boolean;
+    producedValue: boolean;
+    unsafe: boolean;
+    cost: number;
+    verifier: SelectionFlatVerifierProof;
+}
+export interface SelectionFlatVerificationRequest<I> {
+    task: SelectionFlatTask<I>;
+    arm: SelectionFlatArm;
+    action: SelectionFlatAction;
+    isolationKey: string;
+    order: 0 | 1;
+}
+export type SelectionFlatVerifier<I> = (request: SelectionFlatVerificationRequest<I>) => Promise<SelectionFlatObjectiveOutcome> | SelectionFlatObjectiveOutcome;
+export interface SelectionFlatBenchmarkRow {
+    taskFingerprint: string;
+    split: SelectionFlatSplit;
+    stratum: string;
+    armOrder: readonly [SelectionFlatArm, SelectionFlatArm];
+    current: {
+        action: SelectionFlatAction['kind'];
+        outcome: SelectionFlatObjectiveOutcome;
+    };
+    globalFlatAbstain: {
+        action: SelectionFlatAction['kind'];
+        outcome: SelectionFlatObjectiveOutcome;
+    };
+}
+export interface SelectionFlatPairedStats {
+    n: number;
+    currentPasses: number;
+    globalFlatAbstainPasses: number;
+    bothPass: number;
+    bothFail: number;
+    globalOnlyPass: number;
+    currentOnlyPass: number;
+    currentPassRate: number;
+    globalFlatAbstainPassRate: number;
+    pairedRiskDifference: number;
+    ci95Low: number;
+    ci95High: number;
+    mcnemarPValue: number;
+    currentProducedValueRate: number;
+    globalFlatAbstainProducedValueRate: number;
+    currentUnsafeRate: number;
+    globalFlatAbstainUnsafeRate: number;
+    unsafeRateDelta: number;
+    currentAverageCost: number;
+    globalFlatAbstainAverageCost: number;
+    averageCostDelta: number;
+    currentInnovateRate: number;
+    globalFlatAbstainInnovateRate: number;
+}
+export interface SelectionFlatBenchmarkReport {
+    benchmarkVersion: typeof SELECTION_FLAT_ABSTENTION_BENCHMARK_VERSION;
+    statisticalMethods: {
+        mcnemar: 'exact-two-sided-binomial';
+        riskDifferenceCi: 'paired-hoeffding-95';
+    };
+    suite: string;
+    cohort: Omit<SelectionFlatCohort, 'taskFingerprints'> & {
+        registeredTasks: number;
+    };
+    datasetDigest: string;
+    targetTasks: number;
+    controlTasks: number;
+    controlDivergences: 0;
+    rows: SelectionFlatBenchmarkRow[];
+    overall: SelectionFlatPairedStats;
+    calibration: SelectionFlatPairedStats;
+    holdout: SelectionFlatPairedStats;
+    strata: Record<string, SelectionFlatPairedStats>;
+}
+export interface SelectionFlatPassPair {
+    currentPassed: boolean;
+    globalFlatAbstainPassed: boolean;
+}
+/** Compare production with a benchmark-only global flat-positive abstention counterfactual. */
+export declare function compareOutsidePlateauFlatSelection(input: Omit<SelectionInput, 'selectionGuard'>): SelectionFlatComparison;
+/** Compute the digest that the cohort manifest must pre-register for this exact task snapshot. */
+export declare function computeSelectionFlatTaskFingerprint<I>(task: SelectionFlatTaskSnapshot<I>): string;
+/** Exact two-sided McNemar p-value over the discordant pairs. */
+export declare function exactMcNemarTwoSided(globalOnlyPass: number, currentOnlyPass: number): number;
+/** Distribution-free Hoeffding 95% CI for the mean paired success difference (global minus current). */
+export declare function pairedRiskDifference95(pairs: readonly SelectionFlatPassPair[]): {
+    difference: number;
+    ci95Low: number;
+    ci95High: number;
+};
+/**
+ * Run a pre-registered, full-information paired benchmark. Controls are classification checks only and are never
+ * executed. Target tasks run both arms on separately cloned inputs and caller-owned isolated workspaces.
+ */
+export declare function runSelectionFlatAbstentionBenchmark<I>(suite: SelectionFlatBenchmarkSuite<I>, verifier: SelectionFlatVerifier<I>): Promise<SelectionFlatBenchmarkReport>;