@lmzhen/dsh-evolution-merge 0.28.0 → 0.29.0

package/lib/types/adapters/engine-screen.d.ts

@@ -0,0 +1,55 @@
+import type { EvolutionIoLike } from '@lmzhen/dsh-evolution-core';
+import type { MergeCandidate } from '../contracts.ts';
+import type { SkillCard } from '../skill-card.ts';
+export type EngineScreenResult = {
+    readonly ok: true;
+    readonly report: Record<string, unknown>;
+} | {
+    readonly ok: false;
+    readonly error: {
+        readonly code: string;
+        readonly stage?: string;
+        readonly detail?: string;
+    };
+};
+export interface EngineScreenPort {
+    screen(input: {
+        readonly corpusDir: string;
+        readonly outDir: string;
+        readonly cfg?: Record<string, unknown>;
+        readonly signal?: AbortSignal;
+        readonly onProgress?: (p: {
+            stage: string;
+            done?: number;
+            total?: number;
+        }) => void;
+        readonly runner?: (prompt: string, cfg?: Record<string, unknown>) => Promise<string>;
+    }): Promise<EngineScreenResult>;
+}
+export interface CandidateSelection {
+    readonly candidates: readonly MergeCandidate[];
+    readonly skipped: readonly {
+        readonly pairKey: string;
+        readonly a: string;
+        readonly b: string;
+        readonly reason?: string;
+    }[];
+    readonly reportOnly: number;
+    readonly candidatePairs?: number;
+}
+export type ScreeningCandidates = readonly MergeCandidate[] & {
+    readonly candidatePairs?: number;
+};
+export interface EngineScreeningDeps {
+    readonly io: EvolutionIoLike;
+    readonly home: string;
+    readonly engine: EngineScreenPort;
+    readonly select: (report: Record<string, unknown>) => CandidateSelection;
+    readonly cfg?: Record<string, unknown>;
+    readonly runner?: (prompt: string, cfg?: Record<string, unknown>) => Promise<string>;
+    readonly onSelection?: (selection: CandidateSelection, runId: string) => Promise<void>;
+}
+/** Write the exact card bodies as a support-free corpus snapshot and return its root. */
+export declare function snapshotCards(io: EvolutionIoLike, home: string, runId: string, cards: readonly SkillCard[]): Promise<string>;
+export declare function createEngineScreening(deps: EngineScreeningDeps): (cards: readonly SkillCard[], runId: string, signal: AbortSignal) => Promise<readonly MergeCandidate[]>;
+//# sourceMappingURL=engine-screen.d.ts.map

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

@@ -0,0 +1,28 @@
+/**
+ * DeepSeek judge runner over the platform llm service. The engine calls
+ * runner(prompt, cfg) and expects raw model text; the platform owns provider
+ * selection, usage accounting and transport.
+ */
+export interface ModelRoute {
+    readonly provider: string;
+    readonly model: string;
+}
+export interface LlmChunkLike {
+    readonly type: string;
+    readonly text?: string;
+    readonly reason?: {
+        readonly kind?: string;
+        readonly failure?: {
+            readonly message?: string;
+        };
+    };
+}
+export interface LlmServiceLike {
+    stream?(options: Record<string, unknown>): AsyncIterable<LlmChunkLike>;
+    prepareCall?(config: Record<string, unknown>, signal?: AbortSignal): Promise<{
+        readonly config: Record<string, unknown>;
+        stream(input: Record<string, unknown>): AsyncIterable<LlmChunkLike>;
+    }>;
+}
+export declare function createEngineRunner(llm: LlmServiceLike, route: () => ModelRoute): (prompt: string) => Promise<string>;
+//# sourceMappingURL=model-runner.d.ts.map

package/lib/types/authoring-flow.d.ts

@@ -7,12 +7,15 @@ import type { EvolutionIoLike } from '@lmzhen/dsh-evolution-core';
 import { type RuleFinding } from './rules.ts';
 import { type CommitPort, type CommitStagedResult } from './commit-execute.ts';
 import type { StagedTree } from './rules.ts';
-import type { SkillCard } from './screening.ts';
+import type { SkillCard } from './skill-card.ts';
 export interface RunAuthoringOptions {
     readonly io: EvolutionIoLike;
     readonly home: string;
     readonly runId: string;
+    readonly stageKey?: string;
+    readonly reuseStaging?: boolean;
     readonly target: string;
+    readonly mode?: 'merge-into-existing' | 'create-umbrella' | 'keep';
     readonly cards: readonly SkillCard[];
     readonly author: (staging: {
         readonly home: string;
@@ -25,7 +28,9 @@ export interface RunAuthoringOptions {
 export type AuthoringResult = {
     readonly ok: true;
     readonly tree: StagedTree;
-    readonly commit: CommitStagedResult;
+    readonly commit: Extract<CommitStagedResult, {
+        readonly ok: true;
+    }>;
 } | {
     readonly ok: false;
     readonly message: string;

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

@@ -4,7 +4,7 @@
  * outside this adapter: the caller owns staging -> commitStagedRun.
  */
 import type { MergeDecision, MergeRow } from './contracts.ts';
-import type { SkillCard } from './screening.ts';
+import type { SkillCard } from './skill-card.ts';
 import type { ScanRound1Outcome } from './scan-run.ts';
 export interface ChannelTurnLike {
     readonly text: string;
@@ -45,6 +45,7 @@ export interface ChannelRound1Options {
     readonly allow: readonly string[];
     readonly cwd?: string;
     readonly timeoutMs: number;
+    readonly onChildOpened?: (childId: string) => void;
 }
 export interface ChannelRound1Result {
     readonly outcome: ScanRound1Outcome;

package/lib/types/commit-assembly.d.ts

@@ -9,6 +9,8 @@ import type { EvolutionIoLike } from '@lmzhen/dsh-evolution-core';
 export interface CommitAssemblyPort {
     /** Current SKILL.md body, or null when the skill is not live. */
     readSkill(name: string): Promise<string | null>;
+    /** Whether the name is already occupied by an archived (tombstoned) skill. */
+    isArchived?(name: string): Promise<boolean>;
 }
 export interface CommitAssemblyOptions {
     readonly origin: WriteOrigin;

package/lib/types/commit-receipt.d.ts

@@ -1,6 +1,7 @@
 import type { EvolutionIoLike } from '@lmzhen/dsh-evolution-core';
 export interface CommitReceipt {
     readonly runId: string;
+    readonly parentRunId?: string;
     readonly unitId: string;
     readonly target: string;
     readonly create: boolean;
@@ -9,6 +10,8 @@ export interface CommitReceipt {
     readonly at: number;
 }
 export declare function commitReceiptPath(home: string, runId: string): string;
+export declare function durableReceiptDir(home: string, parentRunId: string): string;
+export declare function durableReceiptPath(home: string, parentRunId: string, stageKey: string): string;
 export declare function writeCommitReceipt(io: EvolutionIoLike, home: string, receipt: CommitReceipt): Promise<string>;
-export declare function readCommitReceipt(io: EvolutionIoLike, home: string, runId: string): Promise<CommitReceipt | null>;
+export declare function readCommitReceipt(io: EvolutionIoLike, home: string, runId: string, target?: string): Promise<CommitReceipt | null>;
 //# sourceMappingURL=commit-receipt.d.ts.map

package/lib/types/contracts.d.ts

@@ -41,7 +41,7 @@ export interface MergeCandidate {
     readonly arms?: readonly string[];
     readonly reason?: string;
     readonly gate?: MergeGateFact;
-    readonly source?: 'lexical' | 'proposed';
+    readonly source?: 'lexical' | 'proposed' | 'engine';
 }
 export interface MergeDecision {
     readonly shouldMerge: boolean;
@@ -50,6 +50,8 @@ export interface MergeDecision {
     readonly sources: readonly string[];
     readonly rationale: string;
     readonly confidence?: number;
+    readonly aSummary?: string;
+    readonly bSummary?: string;
 }
 export interface MergeUsage {
     readonly inputTokens?: number;
@@ -123,6 +125,8 @@ export interface MergeRow {
     readonly unitId?: string;
     readonly origin?: 'agent' | 'human';
     readonly attempts?: number;
+    readonly stagingRef?: string;
+    readonly stagingExpiresAt?: number;
     readonly createdAt: string;
     readonly updatedAt: string;
 }
@@ -132,5 +136,6 @@ export interface MergeState {
 }
 export declare function emptyMergeState(): MergeState;
 /** One record can be retried only when the failure says so and names a stage. */
-export declare function canRetry(record: Pick<MergeRow, 'state' | 'failure'>): boolean;
+export declare const MERGE_MAX_ATTEMPTS = 3;
+export declare function canRetry(record: Pick<MergeRow, 'state' | 'failure' | 'attempts'>): boolean;
 //# sourceMappingURL=contracts.d.ts.map

package/lib/types/coordinator.d.ts

@@ -18,6 +18,8 @@ export type MergeEvent = {
     readonly type: 'round1-merge';
     readonly approval: 'on' | 'off';
     readonly decision?: MergeDecision;
+    readonly stagingRef?: string;
+    readonly stagingExpiresAt?: number;
     readonly at: string;
 } | {
     readonly type: 'round1-fail';
@@ -44,6 +46,12 @@ export type MergeEvent = {
 } | {
     readonly type: 'source-gone';
     readonly at: string;
+} | {
+    readonly type: 'gate-keep';
+    readonly a: string;
+    readonly b: string;
+    readonly reason?: string;
+    readonly at: string;
 };
 export type TransitionResult = {
     readonly ok: true;

package/lib/types/doctor.d.ts

@@ -6,5 +6,5 @@ export interface MergeDoctorRow {
     readonly status: 'ok' | 'warn' | 'unknown';
     readonly detail: string;
 }
-export declare function mergeDoctor(io: EvolutionIoLike, home: string): Promise<readonly MergeDoctorRow[]>;
+export declare function mergeDoctor(io: EvolutionIoLike, home: string, configuredRoot?: string): Promise<readonly MergeDoctorRow[]>;
 //# sourceMappingURL=doctor.d.ts.map

package/lib/types/index.d.ts

@@ -6,11 +6,13 @@ export declare const Config: z<Schemastery.ObjectS<NoInfer<{
     mergeSkippedTtlDays: z<number, number, "volatile-defined">;
     mergeRunTimeoutMinutes: z<number, number, "volatile-defined">;
     mergePairTimeoutMinutes: z<number, number, "defined">;
+    mergeModelsRoot: z<string, string, "defined">;
 }>>, Schemastery.ObjectT<NoInfer<{
     mergeApproval: z<boolean, boolean, "volatile-defined">;
     mergeSkippedTtlDays: z<number, number, "volatile-defined">;
     mergeRunTimeoutMinutes: z<number, number, "volatile-defined">;
     mergePairTimeoutMinutes: z<number, number, "defined">;
+    mergeModelsRoot: z<string, string, "defined">;
 }>>, "plain">;
 export interface MergePresentationScope {
     effect(run: () => () => void, label?: string): unknown;
@@ -20,6 +22,7 @@ export interface MergePresentationScope {
         }, owner?: unknown) => unknown;
     };
 }
+export declare function engineConfigFromEnv(configuredRoot?: string): Record<string, unknown> | undefined;
 export interface MergePresentationContext {
     inject(names: string[], run: (scope: MergePresentationScope) => void): void;
     readonly fiber?: unknown;
@@ -27,6 +30,7 @@ export interface MergePresentationContext {
 /** Suppress the platform auto form; the registry renders the merge card instead. */
 export declare function configureMergePresentation(ctx: MergePresentationContext): void;
 export * from './contracts.ts';
+export * from './skill-card.ts';
 export * from './state.ts';
 export * from './coordinator.ts';
 export * from './report.ts';
@@ -42,8 +46,9 @@ export * from './commit-receipt.ts';
 export * from './commit-execute.ts';
 export * from './undo-merge.ts';
 export * from './adapters/library.ts';
-export * from './adapters/model.ts';
+export * from './adapters/model-runner.ts';
 export * from './adapters/channel.ts';
+export * from './adapters/engine-screen.ts';
 export * from './adapters/undo.ts';
 export * from './run-shell.ts';
 export * from './scan-run.ts';
@@ -53,12 +58,6 @@ export * from './round2-outcome.ts';
 export * from './approve-command.ts';
 export * from './pair-command.ts';
 export * from './resume-command.ts';
-export * from './screening.ts';
-export * from './propose.ts';
-export * from './ladder.ts';
-export * from './gate-cache.ts';
-export * from './gate-filter.ts';
-export * from './screening-port.ts';
 export * from './decision.ts';
 export * from './prompts.ts';
 export * from './channel-port.ts';

package/lib/types/merge-command.d.ts

@@ -32,5 +32,8 @@ export interface MergeCommandDefinitionLike {
     readonly handler: (invocation: CommandInvocationLike) => Promise<CommandResultLike>;
 }
 export declare function createReadOnlyMergeService(io: EvolutionIoLike, home: string): MergeCommandService;
+export declare function runMergeCommand(service: MergeCommandService, rawInput: string, invocation?: {
+    readonly agent?: unknown;
+}): Promise<MergeCommandResult>;
 export declare function createMergeCommand(service: MergeCommandService): MergeCommandDefinitionLike;
 //# sourceMappingURL=merge-command.d.ts.map

package/lib/types/merge-routes.d.ts

@@ -16,6 +16,7 @@ export interface MergeRouteSource {
     run(id: string): Promise<RunRecord | undefined>;
     runs(cursor?: string, limit?: number): Promise<readonly RunRecord[]>;
     commands(): readonly string[];
+    approval?(): boolean;
 }
 export declare function makeMergeRoutes(deps: {
     getSource: () => MergeRouteSource | undefined;

package/lib/types/new-child-authoring.d.ts

@@ -4,7 +4,7 @@
  */
 import type { EvolutionIoLike } from '@lmzhen/dsh-evolution-core';
 import type { MergeDecision, MergeRow } from './contracts.ts';
-import type { SkillCard } from './screening.ts';
+import type { SkillCard } from './skill-card.ts';
 import type { ConversationChannelLike } from './channel-port.ts';
 import { type CommitPort } from './commit-execute.ts';
 import type { StageToolContext } from './stage-tool.ts';

package/lib/types/params.d.ts

@@ -7,6 +7,7 @@ export interface MergeParams {
     readonly mergeSkippedTtlDays: number;
     readonly mergeRunTimeoutMinutes: number;
     readonly mergePairTimeoutMinutes: number;
+    readonly mergeModelsRoot: string;
 }
 export declare const MERGE_PARAM_DEFAULTS: MergeParams;
 export declare function resolveMergeParams(input?: unknown): MergeParams;

package/lib/types/prompts.d.ts

@@ -1,13 +1,15 @@
 /**
- * Round-1/round-2 prompt builders. Pure strings; the channel adapter owns transport.
- * Round 1 may only decide; round 2 may only write the staged tree through merge_stage.
+ * Round-1/round-2 prompt builders. B draft body, with only the file-tool ->
+ * merge_stage substitution and the fresh-mode bridge sentence.
  */
 import type { MergeDecision, MergeRow } from './contracts.ts';
-import type { SkillCard } from './screening.ts';
-export declare const MERGE_PROMPT_VERSION = "merge-pair/v1";
+import type { SkillCard } from './skill-card.ts';
+export declare const MERGE_PROMPT_VERSION = "merge-b/v1";
+export declare const STANDBY_PROMPT = "You are a merge worker. Wait for instructions.";
 export declare function buildRound1Prompt(candidate: {
     readonly a: string;
     readonly b: string;
 }, cards: readonly SkillCard[]): string;
-export declare function buildRound2Prompt(row: MergeRow, decision: MergeDecision): string;
+export declare function buildRound2Prompt(row: MergeRow, decision: MergeDecision, mode?: 'continue' | 'fresh'): string;
+export declare function buildStandbyPrompt(): string;
 //# sourceMappingURL=prompts.d.ts.map

package/lib/types/routes.d.ts

@@ -15,6 +15,19 @@ export interface MergeRowView {
     readonly stage: string | null;
     readonly label: string;
     readonly updatedAt: string;
+    readonly createdAt: string;
+    readonly target?: string;
+    readonly confidence?: number;
+    readonly failure?: {
+        readonly stage: string;
+        readonly code: string;
+        readonly message: string;
+        readonly retryable: boolean;
+    };
+    readonly attempts?: number;
+    readonly origin?: 'agent' | 'human';
+    readonly stagingExpiresAt?: number;
+    readonly actions: readonly string[];
 }
 export declare function toRowView(row: MergeRow): MergeRowView;
 export interface MergeView {
@@ -25,8 +38,10 @@ export interface MergeView {
         readonly count: number;
     }[];
     readonly commands: readonly string[];
+    readonly latestRun?: MergeRunFact;
+    readonly approval?: boolean;
 }
-export declare function buildMergeView(rows: readonly MergeRow[], commands: readonly string[]): MergeView;
+export declare function buildMergeView(rows: readonly MergeRow[], commands: readonly string[], latestRun?: MergeRunFact, approval?: boolean): MergeView;
 export interface QueuePage {
     readonly queue: MergeQueue;
     readonly items: readonly MergeRowView[];

package/lib/types/runtime.d.ts

@@ -6,7 +6,7 @@
 import { type EvolutionIoLike, type SkillLibrary } from '@lmzhen/dsh-evolution-core';
 import { type MergeCandidate } from './contracts.ts';
 import type { MergeParams } from './params.ts';
-import type { SkillCard } from './screening.ts';
+import type { SkillCard } from './skill-card.ts';
 import type { MergeRegistryPort } from './run-shell.ts';
 import type { MergeCommandService } from './merge-command.ts';
 import type { StageToolContext } from './stage-tool.ts';
@@ -29,9 +29,8 @@ export interface MergeRuntimeDeps {
     readonly cwd?: string;
     readonly timeoutMinutes: number;
     readonly cards: (signal: AbortSignal) => Promise<readonly SkillCard[]>;
-    readonly screening: (cards: readonly SkillCard[], signal: AbortSignal) => Promise<readonly MergeCandidate[]>;
-    /** Run-scoped screening (lexical/C3/gate with a runId-seeded audit); preferred when present. */
-    readonly screeningForRun?: (cards: readonly SkillCard[], runId: string, signal: AbortSignal) => Promise<readonly MergeCandidate[]>;
+    /** Run-scoped engine screening. */
+    readonly screeningForRun: (cards: readonly SkillCard[], runId: string, signal: AbortSignal) => Promise<readonly MergeCandidate[]>;
     readonly stage?: MergeStageBindingPort;
 }
 export declare function createMergeRuntime(deps: MergeRuntimeDeps): MergeCommandService;

package/lib/types/scan-ports.d.ts

@@ -6,7 +6,7 @@
  * approve run must open a new child (not handled by this factory).
  */
 import type { EvolutionIoLike } from '@lmzhen/dsh-evolution-core';
-import type { SkillCard } from './screening.ts';
+import type { SkillCard } from './skill-card.ts';
 import { type ConversationChannelLike } from './channel-port.ts';
 import type { CommitPort } from './commit-execute.ts';
 import type { StageToolContext } from './stage-tool.ts';

package/lib/types/scan-run.d.ts

@@ -9,6 +9,8 @@ export interface ScanRound1Outcome {
     readonly kind: 'keep' | 'merge' | 'failed';
     readonly decision?: MergeDecision;
     readonly failure?: MergeFailure;
+    readonly stagingRef?: string;
+    readonly stagingExpiresAt?: number;
 }
 export interface ScanRound2Outcome {
     readonly kind: 'merged' | 'failed';

package/lib/types/skill-card.d.ts

@@ -0,0 +1,12 @@
+export interface SkillCard {
+    readonly name: string;
+    readonly description: string;
+    readonly body: string;
+    readonly files?: readonly {
+        readonly path: string;
+        readonly content: string;
+    }[];
+    readonly protectedBy?: string | null;
+    readonly protectionUnknown?: boolean;
+}
+//# sourceMappingURL=skill-card.d.ts.map

package/lib/types/staging.d.ts

@@ -1,5 +1,6 @@
 import { type EvolutionIoLike, type Probe } from '@lmzhen/dsh-evolution-core';
 export declare const STAGING_SCHEMA_VERSION = 1;
+export declare function stageKeyOf(runId: string, pairKey: string): string;
 export declare function stagingRoot(home: string, runId: string): string;
 export interface StagingSource {
     readonly name: string;
@@ -13,6 +14,7 @@ export interface StagingManifest {
     readonly schemaVersion: typeof STAGING_SCHEMA_VERSION;
     readonly runId: string;
     readonly target: string;
+    readonly mode?: 'merge-into-existing' | 'create-umbrella' | 'keep';
     readonly sources: readonly string[];
     readonly promptVersion: string;
     readonly createdAt: number;
@@ -21,6 +23,7 @@ export interface StagingManifest {
 export interface CreateStagingInput {
     readonly runId: string;
     readonly target: string;
+    readonly mode?: 'merge-into-existing' | 'create-umbrella' | 'keep';
     readonly sources: readonly StagingSource[];
     readonly promptVersion: string;
     readonly ttlDays: number;
@@ -40,4 +43,7 @@ export interface StagedView {
     readonly manifest: StagingManifest;
 }
 export declare function readStaging(io: EvolutionIoLike, home: string, runId: string): Promise<Probe<StagedView>>;
+export declare function ensureStaging(io: EvolutionIoLike, home: string, input: CreateStagingInput): Promise<CreateStagingResult>;
+export declare function setStagingTarget(io: EvolutionIoLike, home: string, stageKey: string, target: string, mode?: 'merge-into-existing' | 'create-umbrella' | 'keep'): Promise<boolean>;
+export declare function dropStaging(io: EvolutionIoLike, home: string, stageKey: string): Promise<void>;
 //# sourceMappingURL=staging.d.ts.map

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.28.0",
+  "version": "0.29.0",
   "publishConfig": {
     "access": "public"
   },
@@ -27,15 +27,12 @@
   "license": "MIT",
   "dependencies": {
     "@deepseek-ai/schemastery": "^3.18.5",
-    "@lmzhen/dsh-evolution-core": "^0.28.0"
+    "@lmzhen/dsh-evolution-core": "^0.29.0",
+    "@lmzhen/dsh-evolution-merge-engine": "^0.29.0"
   },
   "peerDependencies": {
     "@deepseek-ai/cordis": "^4.0.5"
   },
-  "devDependencies": {
-    "@deepseek-ai/cordis": "^4.0.5",
-    "@lmzhen/dsh-evolution-core": "^0.28.0"
-  },
   "engines": {
     "dsh": ">=0.2.1-rc.1 <0.2.2-0"
   }

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/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/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/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

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