@lmzhen/dsh-evolution-merge 0.30.24 → 0.30.25

package/lib/types/wire-projection.js

@@ -10,10 +10,15 @@ export function actionRefs(row) {
         return [{ id: 'discard', command: base + 'discard ' + row.id, confirm: true, enabled: true }, { id: 'pair', command: base + 'pair ' + row.a + ' ' + row.b, confirm: true, enabled: true }];
     if (row.state === 'pending')
         return [action('approve'), action('reject', true), action('discard', true)];
-    if (row.state === 'approved' || row.state === 'fuse')
-        return [action('discard', true), action('status')];
+    if (row.state === 'approved' || row.state === 'fuse') {
+        if (row.failure !== undefined && row.failure.retryable === false)
+            return [{ id: 'pair', command: base + 'pair ' + row.a + ' ' + row.b, confirm: true, enabled: true }, action('discard', true)];
+        return [{ id: 'retry-resume', command: base + 'resume --retry ' + row.id, confirm: true, enabled: true }, action('discard', true), action('status')];
+    }
     if (row.state === 'skipped')
         return [action('restore', true)];
+    if (row.state === 'verify')
+        return [{ id: 'retry-candidates', command: base + 'candidates --retry ' + row.id, confirm: false, enabled: true }];
     return [action('pair')];
 }
 export function toRowFact(row, actions = actionRefs(row)) {

package/lib/types/wire.d.ts

@@ -59,6 +59,7 @@ export interface RowFact {
     };
     readonly summary?: SummarySlots;
     readonly reason?: string;
+    readonly reasonCode?: string;
     readonly origin?: SkipOrigin;
     readonly skipKind?: SkipKind;
     readonly confidence?: number;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@lmzhen/dsh-evolution-merge",
   "description": "Skill auto-merge domain: screening, two-round authoring, queues and commit orchestration (community build)",
-  "version": "0.30.24",
+  "version": "0.30.25",
   "publishConfig": {
     "access": "public"
   },
@@ -32,9 +32,9 @@
   },
   "dependencies": {
     "@deepseek-ai/schemastery": "^3.18.5",
-    "@lmzhen/dsh-evolution-core": "^0.30.24",
-    "@lmzhen/dsh-evolution-commands": "^0.30.24",
-    "@lmzhen/dsh-evolution-merge-engine": "0.30.24"
+    "@lmzhen/dsh-evolution-core": "^0.30.25",
+    "@lmzhen/dsh-evolution-commands": "^0.30.25",
+    "@lmzhen/dsh-evolution-merge-engine": "0.30.25"
   },
   "peerDependencies": {
     "@deepseek-ai/cordis": "^4.0.5"

package/lib/types/adapters/model.d.ts

@@ -1,31 +0,0 @@
-/**
- * Structural ModelPort adapter over the platform llm service. The platform exposes either
- * `stream()` (the current shape) or the older prepareCall()/stream pair; both return raw text
- * because the gate and proposer own JSON extraction.
- */
-import type { ModelPort } from '../propose.ts';
-export interface ModelRoute {
-    readonly provider: string;
-    readonly model: string;
-}
-export interface LlmChunkLike {
-    readonly type: string;
-    readonly text?: string;
-    readonly usage?: unknown;
-    readonly reason?: {
-        readonly kind?: string;
-        readonly failure?: {
-            readonly message?: string;
-        };
-    };
-}
-export interface LlmCallLike {
-    readonly config: Record<string, unknown>;
-    stream(input: Record<string, unknown>): AsyncIterable<LlmChunkLike>;
-}
-export interface LlmServiceLike {
-    prepareCall?(config: Record<string, unknown>, signal?: AbortSignal): Promise<LlmCallLike>;
-    stream?(options: Record<string, unknown>): AsyncIterable<LlmChunkLike>;
-}
-export declare function createModelPort(llm: LlmServiceLike, route: () => ModelRoute): ModelPort;
-//# sourceMappingURL=model.d.ts.map

package/lib/types/adapters/model.js

@@ -1,47 +0,0 @@
-import { normalizeProviderKey } from "../domain/provider-key.js";
-function append(chunk, text) {
-    if (chunk.type === 'text-delta' || chunk.type === 'text')
-        return text + (chunk.text ?? '');
-    if (chunk.type === 'finish' && chunk.reason?.kind === 'error') {
-        throw new Error('model call failed: ' + (chunk.reason.failure?.message ?? 'unknown'));
-    }
-    return text;
-}
-export function createModelPort(llm, route) {
-    return {
-        async callJson(request) {
-            const selection = route();
-            let text = '';
-            if (llm.stream !== undefined) {
-                for await (const chunk of llm.stream({
-                    provider: normalizeProviderKey(selection.provider),
-                    model: selection.model,
-                    system: request.system,
-                    messages: [{ role: 'user', content: [{ type: 'text', text: request.user }] }],
-                    maxTokens: request.maxTokens,
-                    temperature: 0,
-                    signal: request.signal,
-                }))
-                    text = append(chunk, text);
-                return text;
-            }
-            if (llm.prepareCall === undefined)
-                throw new Error('llm service has neither stream nor prepareCall');
-            const call = await llm.prepareCall({
-                provider: selection.provider,
-                model: selection.model,
-                maxTokens: request.maxTokens,
-                temperature: 0,
-            }, request.signal);
-            for await (const chunk of call.stream({
-                ...call.config,
-                system: request.system,
-                messages: [{ role: 'user', content: [{ type: 'text', text: request.user }] }],
-                signal: request.signal,
-            }))
-                text = append(chunk, text);
-            return text;
-        },
-    };
-}
-//# sourceMappingURL=model.js.map

package/lib/types/gate-cache.d.ts

@@ -1,12 +0,0 @@
-import { type EvolutionIoLike } from '@lmzhen/dsh-evolution-core';
-import { GateCache } from './ladder.ts';
-export declare const GATE_CACHE_VERSION = 1;
-export declare function gateCachePath(home: string): string;
-export interface LoadGateCacheResult {
-    readonly cache: GateCache;
-    readonly note?: string;
-}
-export declare function loadGateCache(io: EvolutionIoLike, home: string): Promise<LoadGateCacheResult>;
-export declare function saveGateCache(io: EvolutionIoLike, home: string, cache: GateCache): Promise<void>;
-export declare function hasGateCache(cache: GateCache): boolean;
-//# sourceMappingURL=gate-cache.d.ts.map

package/lib/types/gate-cache.js

@@ -1,36 +0,0 @@
-/**
- * File-backed gate cache: <home>/merge/gate-cache.json.
- * Reads are three-state; a malformed file is reported, not overwritten. Writes are one
- * transact so two runs cannot interleave a partial cache.
- */
-import { join } from 'node:path';
-import { probeText, transactIo } from '@lmzhen/dsh-evolution-core';
-import { GateCache } from "./ladder.js";
-export const GATE_CACHE_VERSION = 1;
-export function gateCachePath(home) {
-    return join(home, 'merge', 'gate-cache.json');
-}
-export async function loadGateCache(io, home) {
-    const probe = await probeText(io, gateCachePath(home));
-    if (probe.kind === 'absent')
-        return { cache: new GateCache() };
-    if (probe.kind === 'unknown')
-        return { cache: new GateCache(), note: probe.reason };
-    try {
-        const parsed = JSON.parse(probe.value);
-        if (parsed.schemaVersion !== GATE_CACHE_VERSION || typeof parsed.entries !== 'object' || parsed.entries === null) {
-            return { cache: new GateCache(), note: 'gate cache has an unexpected shape' };
-        }
-        return { cache: GateCache.fromObject(parsed.entries) };
-    }
-    catch (error) {
-        return { cache: new GateCache(), note: 'gate cache is not JSON: ' + (error instanceof Error ? error.message : String(error)) };
-    }
-}
-export async function saveGateCache(io, home, cache) {
-    await transactIo(io, gateCachePath(home), () => JSON.stringify({ schemaVersion: GATE_CACHE_VERSION, entries: cache.toObject() }, null, 2) + '\n');
-}
-export function hasGateCache(cache) {
-    return cache.size > 0;
-}
-//# sourceMappingURL=gate-cache.js.map

package/lib/types/gate-filter.d.ts

@@ -1,31 +0,0 @@
-/**
- * Gate filter: turn lexical/proposed candidates into the candidates scan may process.
- * L0 keeps are dropped unless the deterministic 10% audit re-runs L2 and overrides.
- */
-import type { MergeCandidate } from './contracts.ts';
-import { type GateCache, type GateFacts, type GateModelPort, type GateVerdict } from './ladder.ts';
-export interface GateFilterOptions {
-    readonly facts: readonly GateFacts[];
-    readonly model: GateModelPort;
-    readonly modelName: string;
-    readonly signal: AbortSignal;
-    readonly runSeed: string;
-    readonly cache?: GateCache;
-    readonly auditRate?: number;
-}
-export interface GateDecision {
-    readonly candidate: MergeCandidate;
-    readonly verdicts: readonly GateVerdict[];
-    readonly auditOverride: boolean;
-}
-export interface GateFilterResult {
-    readonly kept: readonly GateDecision[];
-    readonly dropped: readonly GateDecision[];
-    readonly errors: readonly {
-        readonly candidate: MergeCandidate;
-        readonly message: string;
-    }[];
-    readonly calls: number;
-}
-export declare function filterCandidates(candidates: readonly MergeCandidate[], options: GateFilterOptions): Promise<GateFilterResult>;
-//# sourceMappingURL=gate-filter.d.ts.map

package/lib/types/gate-filter.js

@@ -1,64 +0,0 @@
-import { pairKey } from "./contracts.js";
-import { runLadder, selectedForAudit } from "./ladder.js";
-function withGate(candidate, verdicts, auditOverride) {
-    const last = verdicts[verdicts.length - 1];
-    if (last === undefined)
-        return candidate;
-    return {
-        ...candidate,
-        gate: {
-            level: last.level,
-            verdict: last.verdict,
-            reason: last.reason,
-            ...(last.cached ? { cached: true } : {}),
-            ...(auditOverride ? { auditOverride: true } : {}),
-        },
-    };
-}
-export async function filterCandidates(candidates, options) {
-    const kept = [];
-    const dropped = [];
-    const errors = [];
-    let calls = 0;
-    for (const candidate of candidates) {
-        const first = await runLadder({
-            level: 'L0', candidate, facts: options.facts, model: options.model,
-            modelName: options.modelName, signal: options.signal,
-            ...(options.cache === undefined ? {} : { cache: options.cache }),
-        });
-        calls += first.calls;
-        if (first.route === 'error') {
-            errors.push({ candidate, message: first.error ?? 'gate error' });
-            continue;
-        }
-        if (first.route !== 'keep' || first.droppedAt !== 'L0') {
-            if (first.route === 'merge' || first.route === 'undecided')
-                kept.push({ candidate: withGate(candidate, first.verdicts, false), verdicts: first.verdicts, auditOverride: false });
-            else
-                dropped.push({ candidate, verdicts: first.verdicts, auditOverride: false });
-            continue;
-        }
-        if (!selectedForAudit(pairKey(candidate.a, candidate.b), options.runSeed, options.auditRate ?? 0.1)) {
-            dropped.push({ candidate, verdicts: first.verdicts, auditOverride: false });
-            continue;
-        }
-        const audit = await runLadder({
-            level: 'L0', startLevel: 'L2', candidate, facts: options.facts, model: options.model,
-            modelName: options.modelName, signal: options.signal,
-            ...(options.cache === undefined ? {} : { cache: options.cache }),
-        });
-        calls += audit.calls;
-        if (audit.route === 'merge' || audit.route === 'undecided') {
-            const all = [...first.verdicts, ...audit.verdicts];
-            kept.push({ candidate: withGate(candidate, all, true), verdicts: all, auditOverride: true });
-        }
-        else if (audit.route === 'error') {
-            errors.push({ candidate, message: audit.error ?? 'audit gate error' });
-        }
-        else {
-            dropped.push({ candidate, verdicts: [...first.verdicts, ...audit.verdicts], auditOverride: true });
-        }
-    }
-    return { kept, dropped, errors, calls };
-}
-//# sourceMappingURL=gate-filter.js.map

package/lib/types/ladder.d.ts

@@ -1,65 +0,0 @@
-export type GateLevel = 'L0' | 'L1' | 'L2';
-export type GateVerdictValue = 1 | 0 | -1;
-export interface GateFacts {
-    readonly name: string;
-    readonly description: string;
-    readonly body: string;
-}
-export interface GateCandidate {
-    readonly a: string;
-    readonly b: string;
-    readonly score?: number;
-}
-export interface GateEvidence {
-    readonly path: string;
-    readonly line: number;
-    readonly quote: string;
-}
-export interface GateVerdict {
-    readonly level: GateLevel;
-    readonly verdict: GateVerdictValue;
-    readonly reason: string;
-    readonly evidence: readonly GateEvidence[];
-    readonly cached: boolean;
-}
-export interface GateModelPort {
-    callJson(request: {
-        readonly system: string;
-        readonly user: string;
-        readonly maxTokens: number;
-        readonly signal: AbortSignal;
-    }): Promise<unknown>;
-}
-export type LadderRoute = 'merge' | 'undecided' | 'keep' | 'error';
-export interface LadderResult {
-    readonly route: LadderRoute;
-    readonly verdicts: readonly GateVerdict[];
-    readonly calls: number;
-    readonly droppedAt?: GateLevel;
-    readonly error?: string;
-}
-export declare class GateCache {
-    private readonly entries;
-    get(key: string): GateVerdict | undefined;
-    put(key: string, value: GateVerdict): void;
-    get size(): number;
-    toObject(): Record<string, GateVerdict>;
-    static fromObject(value: unknown): GateCache;
-}
-export declare function gateCacheKey(level: GateLevel, payload: string, model: string): string;
-export declare function parseVerdict(level: GateLevel, raw: unknown, cached?: boolean): GateVerdict | undefined;
-export interface RunLadderOptions {
-    readonly level: GateLevel;
-    readonly candidate: GateCandidate;
-    readonly facts: readonly GateFacts[];
-    readonly model: GateModelPort;
-    readonly modelName: string;
-    readonly signal: AbortSignal;
-    readonly cache?: GateCache;
-    /** Audit path starts at L2 after an L0 keep. */
-    readonly startLevel?: GateLevel;
-}
-/** Deterministic 10% L0 audit selection from the run seed + pair key. */
-export declare function selectedForAudit(pairKey: string, seed: string, rate?: number): boolean;
-export declare function runLadder(options: RunLadderOptions): Promise<LadderResult>;
-//# sourceMappingURL=ladder.d.ts.map

package/lib/types/ladder.js

@@ -1,162 +0,0 @@
-/**
- * L0–L2 candidate gate. This is a CANDIDATE classifier, not a content quality judge.
- * Routing follows the frozen table: L0 -1 stops; L0 1/0 → L1; L1 -1 stops; L1 0/1 → L2;
- * L2 1 → agent1; L2 0 → agent1 (undecided); L2 -1 → skipped.
- */
-import { createHash } from 'node:crypto';
-export class GateCache {
-    entries = new Map();
-    get(key) { return this.entries.get(key); }
-    put(key, value) { this.entries.set(key, value); }
-    get size() { return this.entries.size; }
-    toObject() { return Object.fromEntries(this.entries); }
-    static fromObject(value) {
-        const cache = new GateCache();
-        if (typeof value !== 'object' || value === null)
-            return cache;
-        for (const [key, entry] of Object.entries(value)) {
-            if (typeof entry !== 'object' || entry === null)
-                continue;
-            const verdict = entry;
-            if (verdict.verdict === 1 || verdict.verdict === 0 || verdict.verdict === -1) {
-                cache.put(key, { level: verdict.level === 'L0' || verdict.level === 'L1' || verdict.level === 'L2' ? verdict.level : 'L2', verdict: verdict.verdict, reason: typeof verdict.reason === 'string' ? verdict.reason : '', evidence: Array.isArray(verdict.evidence) ? verdict.evidence : [], cached: true });
-            }
-        }
-        return cache;
-    }
-}
-export function gateCacheKey(level, payload, model) {
-    return createHash('sha256').update(JSON.stringify({ level, payload, model })).digest('hex');
-}
-function payloadFor(level, candidate, facts) {
-    const a = facts.get(candidate.a);
-    const b = facts.get(candidate.b);
-    if (a === undefined || b === undefined)
-        throw new Error('candidate names are not in the fact set');
-    const base = {
-        level,
-        skill_a: { name: a.name, description: a.description },
-        skill_b: { name: b.name, description: b.description },
-        scores: { jaccard_summary: candidate.score ?? null },
-        schema: { verdict: '1 | 0 | -1', reason: '<=80 chars' },
-    };
-    if (level === 'L0')
-        return JSON.stringify(base);
-    const withHead = {
-        ...base,
-        skill_a: { ...base.skill_a, head: a.body.slice(0, 2400) },
-        skill_b: { ...base.skill_b, head: b.body.slice(0, 2400) },
-    };
-    if (level === 'L1')
-        return JSON.stringify(withHead);
-    return JSON.stringify({
-        ...withHead,
-        skill_a: { ...withHead.skill_a, body_excerpt: a.body.slice(0, 4000) },
-        skill_b: { ...withHead.skill_b, body_excerpt: b.body.slice(0, 4000) },
-    });
-}
-const SYSTEM = 'Judge whether two skill documents describe the same reusable capability. Shared vocabulary or a shared preamble is not duplication. Return only strict JSON: {"verdict":1|0|-1,"reason":"..."}';
-function extractJson(text) {
-    const fenced = /`\``(?:json)?\s*([\s\S]*?)`\``/i.exec(text);
-    const body = fenced?.[1] ?? text;
-    const start = body.indexOf('{');
-    if (start < 0)
-        return undefined;
-    let depth = 0;
-    for (let index = start; index < body.length; index += 1) {
-        if (body[index] === '{')
-            depth += 1;
-        else if (body[index] === '}') {
-            depth -= 1;
-            if (depth === 0) {
-                try {
-                    return JSON.parse(body.slice(start, index + 1));
-                }
-                catch {
-                    return undefined;
-                }
-            }
-        }
-    }
-    return undefined;
-}
-export function parseVerdict(level, raw, cached = false) {
-    const value = typeof raw === 'string' ? extractJson(raw) : raw;
-    if (typeof value !== 'object' || value === null)
-        return undefined;
-    const record = value;
-    const verdict = record.verdict === 1 || record.verdict === '1' ? 1
-        : record.verdict === 0 || record.verdict === '0' ? 0
-            : record.verdict === -1 || record.verdict === '-1' ? -1
-                : undefined;
-    if (verdict === undefined)
-        return undefined;
-    const reason = typeof record.reason === 'string' ? record.reason.slice(0, 80) : '';
-    const evidence = Array.isArray(record.evidence)
-        ? record.evidence
-            .filter(item => typeof item === 'object' && item !== null)
-            .map((item) => {
-            const entry = item;
-            return { path: typeof entry.path === 'string' ? entry.path : '', line: typeof entry.line === 'number' ? entry.line : -1, quote: typeof entry.quote === 'string' ? entry.quote.slice(0, 120) : '' };
-        })
-        : [];
-    return { level, verdict, reason, evidence, cached };
-}
-/** Deterministic 10% L0 audit selection from the run seed + pair key. */
-export function selectedForAudit(pairKey, seed, rate = 0.1) {
-    const digest = createHash('sha256').update(seed + '\u0000' + pairKey).digest();
-    return digest[0] !== undefined && digest[0] < Math.round(Math.max(0, Math.min(1, rate)) * 256);
-}
-export async function runLadder(options) {
-    const facts = new Map(options.facts.map(fact => [fact.name, fact]));
-    const verdicts = [];
-    let calls = 0;
-    let level = options.startLevel ?? 'L0';
-    for (;;) {
-        let payload;
-        try {
-            payload = payloadFor(level, options.candidate, facts);
-        }
-        catch (error) {
-            return { route: 'error', verdicts, calls, error: error instanceof Error ? error.message : String(error) };
-        }
-        const key = gateCacheKey(level, payload, options.modelName);
-        const cached = options.cache?.get(key);
-        let verdict;
-        if (cached !== undefined)
-            verdict = { ...cached, level, cached: true };
-        else {
-            try {
-                calls += 1;
-                const raw = await options.model.callJson({ system: SYSTEM, user: payload, maxTokens: 500, signal: options.signal });
-                verdict = parseVerdict(level, raw);
-                if (verdict !== undefined)
-                    options.cache?.put(key, verdict);
-            }
-            catch (error) {
-                return { route: 'error', verdicts, calls, error: error instanceof Error ? error.message : String(error) };
-            }
-        }
-        if (verdict === undefined)
-            return { route: 'error', verdicts, calls, error: 'invalid gate JSON' };
-        verdicts.push(verdict);
-        if (level === 'L0') {
-            if (verdict.verdict === -1)
-                return { route: 'keep', verdicts, calls, droppedAt: 'L0' };
-            level = 'L1';
-            continue;
-        }
-        if (level === 'L1') {
-            if (verdict.verdict === -1)
-                return { route: 'keep', verdicts, calls, droppedAt: 'L1' };
-            level = 'L2';
-            continue;
-        }
-        if (verdict.verdict === 1)
-            return { route: 'merge', verdicts, calls };
-        if (verdict.verdict === 0)
-            return { route: 'undecided', verdicts, calls };
-        return { route: 'keep', verdicts, calls, droppedAt: 'L2' };
-    }
-}
-//# sourceMappingURL=ladder.js.map

package/lib/types/propose.d.ts

@@ -1,26 +0,0 @@
-/**
- * C3 semantic proposer: one library-level model call (sharded when the library is large)
- * that proposes candidate pairs. It never judges merge quality; L0–L2 does that.
- */
-import type { MergeCandidate } from './contracts.ts';
-import type { SkillCard } from './screening.ts';
-export interface ModelPort {
-    callJson(request: {
-        readonly system: string;
-        readonly user: string;
-        readonly maxTokens: number;
-        readonly signal: AbortSignal;
-    }): Promise<unknown>;
-}
-export interface ProposeOptions {
-    readonly shardSize?: number;
-    readonly maxPairs?: number;
-    readonly signal: AbortSignal;
-}
-export interface ProposeResult {
-    readonly candidates: readonly MergeCandidate[];
-    readonly shards: number;
-    readonly degraded: readonly string[];
-}
-export declare function proposePairs(cards: readonly SkillCard[], port: ModelPort, options: ProposeOptions): Promise<ProposeResult>;
-//# sourceMappingURL=propose.d.ts.map

package/lib/types/propose.js

@@ -1,69 +0,0 @@
-const SYSTEM = 'You propose skill pairs that may be merged. Return only a JSON object: {"pairs":[{"a":"skill-a","b":"skill-b","reason":"one sentence"}]}. Use only supplied skill names. Do not decide whether a merge is good.';
-function parsePairs(raw, known, cap) {
-    let value = raw;
-    if (typeof raw === 'string') {
-        try {
-            value = JSON.parse(raw);
-        }
-        catch {
-            return [];
-        }
-    }
-    if (typeof value !== 'object' || value === null)
-        return [];
-    const pairs = value.pairs;
-    if (!Array.isArray(pairs))
-        return [];
-    const out = [];
-    const seen = new Set();
-    for (const item of pairs) {
-        if (out.length >= cap)
-            break;
-        const pair = item;
-        if (typeof pair.a !== 'string' || typeof pair.b !== 'string')
-            continue;
-        const a = pair.a.trim();
-        const b = pair.b.trim();
-        if (a === b || !known.has(a) || !known.has(b))
-            continue;
-        const [first, second] = a < b ? [a, b] : [b, a];
-        const key = first + '\u0000' + second;
-        if (seen.has(key))
-            continue;
-        seen.add(key);
-        out.push({ a: first, b: second, source: 'proposed', ...(typeof pair.reason === 'string' && pair.reason.trim() !== '' ? { reason: pair.reason.trim() } : {}) });
-    }
-    return out;
-}
-export async function proposePairs(cards, port, options) {
-    const shardSize = Math.max(2, options.shardSize ?? 60);
-    const cap = Math.max(0, options.maxPairs ?? 200);
-    const known = new Set(cards.map(card => card.name));
-    const candidates = [];
-    const degraded = [];
-    let shards = 0;
-    for (let start = 0; start < cards.length && candidates.length < cap; start += shardSize) {
-        const shard = cards.slice(start, start + shardSize);
-        if (shard.length < 2)
-            continue;
-        shards += 1;
-        try {
-            const raw = await port.callJson({
-                system: SYSTEM,
-                user: JSON.stringify(shard.map(card => ({
-                    name: card.name,
-                    description: card.description.slice(0, 400),
-                    body: card.body.slice(0, 600),
-                }))),
-                maxTokens: 1200,
-                signal: options.signal,
-            });
-            candidates.push(...parsePairs(raw, known, cap - candidates.length));
-        }
-        catch (error) {
-            degraded.push('proposal shard failed: ' + (error instanceof Error ? error.message : String(error)));
-        }
-    }
-    return { candidates, shards, degraded };
-}
-//# sourceMappingURL=propose.js.map

package/lib/types/screening-port.d.ts

@@ -1,47 +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 { type MergeCandidate } from './contracts.ts';
-import { type SkillCard, type ScreeningOptions } from './screening.ts';
-import { type ModelPort } from './propose.ts';
-import type { GateCache, GateModelPort } from './ladder.ts';
-export interface ScreeningForRunOptions extends Omit<BuildScreeningOptions, 'signal'> {
-    readonly runSeed: string;
-}
-export interface BuildScreeningOptions {
-    readonly cards: readonly SkillCard[];
-    readonly signal: AbortSignal;
-    readonly lexical?: ScreeningOptions;
-    readonly propose?: {
-        readonly model: ModelPort;
-        readonly shardSize?: number;
-        readonly maxPairs?: number;
-    };
-    readonly gate?: {
-        readonly model: GateModelPort;
-        readonly modelName: string;
-        readonly runSeed: string;
-        readonly cache?: GateCache;
-        readonly auditRate?: number;
-    };
-}
-export interface ScreeningPortStats {
-    readonly lexical: number;
-    readonly proposed: number;
-    readonly candidates: number;
-    readonly kept: number;
-    readonly dropped: number;
-    readonly gateCalls: number;
-    readonly gateErrors: number;
-    readonly shards: number;
-}
-export interface ScreeningPortResult {
-    readonly candidates: readonly MergeCandidate[];
-    readonly stats: ScreeningPortStats;
-    readonly degraded: readonly string[];
-}
-export declare function buildScreeningCandidates(options: BuildScreeningOptions): Promise<ScreeningPortResult>;
-/** Build the run-scoped screening function; the run id seeds the 10% audit. */
-export declare function createScreeningForRun(options: ScreeningForRunOptions): (signal: AbortSignal) => Promise<readonly MergeCandidate[]>;
-//# sourceMappingURL=screening-port.d.ts.map