@lmzhen/dsh-evolution-merge 0.30.24 → 0.30.25

package/lib/types/screening-port.js

@@ -1,93 +0,0 @@
-/**
- * The real screening port: lexical floor + optional C3 proposal + optional L0–L2 gate.
- * Each stage is independently testable; this file only composes their frozen contracts.
- */
-import { pairKey } from "./contracts.js";
-import { lexicalCandidates } from "./screening.js";
-import { proposePairs } from "./propose.js";
-import { filterCandidates } from "./gate-filter.js";
-export async function buildScreeningCandidates(options) {
-    const lexical = lexicalCandidates(options.cards, options.lexical);
-    const merged = new Map();
-    for (const candidate of lexical.candidates)
-        merged.set(pairKey(candidate.a, candidate.b), candidate);
-    const degraded = [];
-    let proposed = 0;
-    let shards = 0;
-    if (options.propose !== undefined) {
-        const proposal = await proposePairs(options.cards, options.propose.model, {
-            signal: options.signal,
-            ...(options.propose.shardSize === undefined ? {} : { shardSize: options.propose.shardSize }),
-            ...(options.propose.maxPairs === undefined ? {} : { maxPairs: options.propose.maxPairs }),
-        });
-        proposed = proposal.candidates.length;
-        shards = proposal.shards;
-        degraded.push(...proposal.degraded);
-        for (const candidate of proposal.candidates) {
-            const key = pairKey(candidate.a, candidate.b);
-            const existing = merged.get(key);
-            if (existing === undefined) {
-                merged.set(key, candidate);
-                continue;
-            }
-            const arms = [...new Set([...(existing.arms ?? []), ...(candidate.arms ?? [])])];
-            merged.set(key, {
-                ...existing,
-                ...(candidate.reason === undefined || existing.reason !== undefined ? {} : { reason: candidate.reason }),
-                ...(arms.length === 0 ? {} : { arms }),
-            });
-        }
-    }
-    let candidates = [...merged.values()].sort((left, right) => (right.score ?? 0) - (left.score ?? 0)
-        || left.a.localeCompare(right.a)
-        || left.b.localeCompare(right.b));
-    let kept = candidates.length;
-    let dropped = 0;
-    let gateCalls = 0;
-    let gateErrors = 0;
-    if (options.gate !== undefined) {
-        const facts = options.cards.map(card => ({ name: card.name, description: card.description, body: card.body }));
-        const filtered = await filterCandidates(candidates, {
-            facts,
-            model: options.gate.model,
-            modelName: options.gate.modelName,
-            signal: options.signal,
-            runSeed: options.gate.runSeed,
-            ...(options.gate.cache === undefined ? {} : { cache: options.gate.cache }),
-            ...(options.gate.auditRate === undefined ? {} : { auditRate: options.gate.auditRate }),
-        });
-        candidates = filtered.kept.map(decision => decision.candidate);
-        kept = filtered.kept.length;
-        dropped = filtered.dropped.length;
-        gateCalls = filtered.calls;
-        gateErrors = filtered.errors.length;
-        for (const error of filtered.errors)
-            degraded.push('gate error: ' + error.candidate.a + ' + ' + error.candidate.b + ': ' + error.message);
-    }
-    return {
-        candidates,
-        stats: {
-            lexical: lexical.candidates.length,
-            proposed,
-            candidates: merged.size,
-            kept,
-            dropped,
-            gateCalls,
-            gateErrors,
-            shards,
-        },
-        degraded,
-    };
-}
-/** Build the run-scoped screening function; the run id seeds the 10% audit. */
-export function createScreeningForRun(options) {
-    const gate = options.gate === undefined ? undefined : { ...options.gate, runSeed: options.runSeed };
-    return async (signal) => (await buildScreeningCandidates({
-        cards: options.cards,
-        signal,
-        ...(options.lexical === undefined ? {} : { lexical: options.lexical }),
-        ...(options.propose === undefined ? {} : { propose: options.propose }),
-        ...(gate === undefined ? {} : { gate }),
-    })).candidates;
-}
-//# sourceMappingURL=screening-port.js.map

package/lib/types/screening.d.ts

@@ -1,30 +0,0 @@
-import type { MergeCandidate } from './contracts.ts';
-export interface SkillCard {
-    readonly name: string;
-    readonly description: string;
-    readonly body: string;
-}
-export interface ScreeningOptions {
-    /** Body Jaccard at/above this is a candidate on its own. */
-    readonly bodyGate?: number;
-    /** Description Jaccard at/above this is a candidate when the body also clears minAffinity. */
-    readonly summaryGate?: number;
-    /** Minimum body affinity for a summary-led candidate. */
-    readonly minAffinity?: number;
-    /** Upper bound after sorting by score; absent = no cap. */
-    readonly maxCandidates?: number;
-}
-export interface ScreeningStats {
-    readonly skills: number;
-    readonly filtered: number;
-    readonly candidates: number;
-}
-export interface ScreeningResult {
-    readonly candidates: readonly MergeCandidate[];
-    readonly stats: ScreeningStats;
-}
-/** Shannon entropy over characters; a cheap prefilter signal, not a name-quality judge. */
-export declare function nameEntropy(name: string): number;
-export declare function prefilter(cards: readonly SkillCard[]): readonly SkillCard[];
-export declare function lexicalCandidates(cards: readonly SkillCard[], options?: ScreeningOptions): ScreeningResult;
-//# sourceMappingURL=screening.d.ts.map

package/lib/types/screening.js

@@ -1,75 +0,0 @@
-/**
- * Deterministic candidate screening: name prefilter + lexical affinity.
- *
- * The semantic proposer (C3) is a separate port; this module is the zero-cost floor that
- * must work without a model. It reuses core `vocabulary`/`affinity` so drift/dedup and
- * merge screening share one tokenizer.
- */
-import { affinity, vocabulary } from '@lmzhen/dsh-evolution-core';
-/** Shannon entropy over characters; a cheap prefilter signal, not a name-quality judge. */
-export function nameEntropy(name) {
-    if (name === '')
-        return 0;
-    const counts = new Map();
-    for (const char of name)
-        counts.set(char, (counts.get(char) ?? 0) + 1);
-    let entropy = 0;
-    for (const count of counts.values()) {
-        const p = count / name.length;
-        entropy -= p * Math.log2(p);
-    }
-    return entropy;
-}
-const MIN_NAME_ENTROPY = 1.5;
-const MIN_NAME_LENGTH = 6;
-export function prefilter(cards) {
-    return cards.filter((card) => {
-        const name = card.name.trim();
-        if (name.length < MIN_NAME_LENGTH)
-            return false;
-        if (nameEntropy(name) < MIN_NAME_ENTROPY)
-            return false;
-        return card.body.trim() !== '' || card.description.trim() !== '';
-    });
-}
-function sortedPair(a, b) {
-    return a < b ? [a, b] : [b, a];
-}
-export function lexicalCandidates(cards, options = {}) {
-    const bodyGate = options.bodyGate ?? 0.9;
-    const summaryGate = options.summaryGate ?? 0.5;
-    const minAffinity = options.minAffinity ?? 0.3;
-    const eligible = prefilter(cards);
-    const vectors = eligible.map(card => ({
-        card,
-        summary: vocabulary(card.description),
-        body: vocabulary(card.body),
-    }));
-    const candidates = [];
-    for (let i = 0; i < vectors.length; i += 1) {
-        for (let j = i + 1; j < vectors.length; j += 1) {
-            const left = vectors[i];
-            const right = vectors[j];
-            if (left === undefined || right === undefined)
-                continue;
-            const summary = affinity(left.summary, right.summary);
-            const body = affinity(left.body, right.body);
-            const arms = [];
-            if (body >= bodyGate)
-                arms.push('body');
-            if (summary >= summaryGate && body >= minAffinity)
-                arms.push('summary');
-            if (arms.length === 0)
-                continue;
-            const [a, b] = sortedPair(left.card.name, right.card.name);
-            candidates.push({ a, b, score: Math.max(body, summary), arms, source: 'lexical' });
-        }
-    }
-    candidates.sort((left, right) => (right.score ?? 0) - (left.score ?? 0) || left.a.localeCompare(right.a) || left.b.localeCompare(right.b));
-    const capped = options.maxCandidates === undefined ? candidates : candidates.slice(0, options.maxCandidates);
-    return {
-        candidates: capped,
-        stats: { skills: cards.length, filtered: cards.length - eligible.length, candidates: capped.length },
-    };
-}
-//# sourceMappingURL=screening.js.map