@principles/core 1.73.0

package/dist/runtime-v2/l1-hard-cap.js

@@ -0,0 +1,51 @@
+export const DEFAULT_L1_HARD_CAP = 12;
+export const MAX_L1_HARD_CAP = 12;
+export function validateL1CapConfig(config) {
+    if (!Number.isFinite(config.hardCap) || !Number.isInteger(config.hardCap)) {
+        throw new Error(`L1 hard cap must be a finite integer, got ${config.hardCap}.`);
+    }
+    if (config.hardCap > MAX_L1_HARD_CAP) {
+        throw new Error(`L1 hard cap ${config.hardCap} exceeds maximum allowed cap of ${MAX_L1_HARD_CAP}. Config may lower but not raise the cap above ${MAX_L1_HARD_CAP}.`);
+    }
+    if (config.hardCap <= 0) {
+        throw new Error(`L1 hard cap must be a positive integer, got ${config.hardCap}.`);
+    }
+}
+function parseTriggeredAtOrThrow(id, value) {
+    const parsed = Date.parse(value);
+    if (!Number.isFinite(parsed)) {
+        throw new Error(`Invalid lastTriggeredAt for principle "${id}": ${value}`);
+    }
+    return parsed;
+}
+export function enforceL1HardCap(candidates, config) {
+    validateL1CapConfig(config);
+    const active = candidates.filter((c) => c.status === 'active');
+    const beforeCount = active.length;
+    if (beforeCount <= config.hardCap) {
+        return {
+            beforeCount,
+            afterCount: beforeCount,
+            evictedIds: [],
+            reason: '',
+            cap: config.hardCap,
+        };
+    }
+    const sorted = [...active].sort((a, b) => {
+        const timeA = parseTriggeredAtOrThrow(a.id, a.lastTriggeredAt);
+        const timeB = parseTriggeredAtOrThrow(b.id, b.lastTriggeredAt);
+        if (timeA !== timeB)
+            return timeA - timeB;
+        return a.id < b.id ? -1 : a.id > b.id ? 1 : 0;
+    });
+    const evictCount = beforeCount - config.hardCap;
+    const evictedIds = sorted.slice(0, evictCount).map((c) => c.id);
+    return {
+        beforeCount,
+        afterCount: config.hardCap,
+        evictedIds,
+        reason: `l1-hard-cap: ${beforeCount} active L1 principles exceeded cap of ${config.hardCap}, evicted ${evictCount} least-recently-triggered`,
+        cap: config.hardCap,
+    };
+}
+//# sourceMappingURL=l1-hard-cap.js.map

package/dist/runtime-v2/l1-hard-cap.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"l1-hard-cap.js","sourceRoot":"","sources":["../../src/runtime-v2/l1-hard-cap.ts"],"names":[],"mappings":"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"}

package/dist/runtime-v2/nocturnal/candidate-scoring.d.ts

@@ -0,0 +1,486 @@
+/**
+ * Nocturnal Candidate Scoring — Deterministic Tournament Selection
+ * ============================================================
+ *
+ * PURPOSE: Score Trinity candidates and run deterministic tournament selection
+ * to choose the best candidate for artifact generation.
+ *
+ * DESIGN CONSTRAINTS:
+ * - Scoring is deterministic: same inputs → same winner
+ * - Tie-break rules are stable and explicit
+ * - No randomness in ranking or selection
+ * - Winner is always the highest-scoring candidate
+ * - Thresholds provide minimum quality gates
+ * - Failed threshold candidates are excluded from tournament
+ *
+ * SCORING COMPONENTS:
+ * - schema completeness: candidate has all required fields
+ * - principle alignment: candidate aligns with target principle
+ * - executability: candidate describes an actionable next step
+ * - boundedness: candidate is specific and bounded
+ * - confidence/consistency: candidate's internal consistency
+ *
+ * PHASE 6 ONLY — No real training, no automatic deployment
+ */
+import { type Static } from '@sinclair/typebox';
+import type { TrinityDreamerCandidate, PhilosopherJudgment } from './trinity-types.js';
+/**
+ * Current threshold values.
+ */
+export declare const ThresholdValuesSchema: import("@sinclair/typebox").TObject<{
+    schemaCompletenessMin: import("@sinclair/typebox").TNumber;
+    principleAlignmentMin: import("@sinclair/typebox").TNumber;
+    executabilityMin: import("@sinclair/typebox").TNumber;
+    boundednessMin: import("@sinclair/typebox").TNumber;
+    confidenceMin: import("@sinclair/typebox").TNumber;
+    aggregateMin: import("@sinclair/typebox").TNumber;
+}>;
+export type ThresholdValues = Static<typeof ThresholdValuesSchema>;
+/**
+ * Single entry in the tournament trace (for candidate scoring).
+ */
+export declare const CandidateTournamentTraceEntrySchema: import("@sinclair/typebox").TObject<{
+    /** Description of this step */
+    step: import("@sinclair/typebox").TString;
+    /** Details about the decision */
+    details: import("@sinclair/typebox").TString;
+}>;
+export type CandidateTournamentTraceEntry = Static<typeof CandidateTournamentTraceEntrySchema>;
+/**
+ * Individual scoring dimensions for a candidate.
+ */
+export declare const CandidateScoresSchema: import("@sinclair/typebox").TObject<{
+    /** Schema completeness (0-1) */
+    schemaCompleteness: import("@sinclair/typebox").TNumber;
+    /** Principle alignment (0-1) */
+    principleAlignment: import("@sinclair/typebox").TNumber;
+    /** Executability (0-1) */
+    executability: import("@sinclair/typebox").TNumber;
+    /** Boundedness — specificity and constraint (0-1) */
+    boundedness: import("@sinclair/typebox").TNumber;
+    /** Confidence/consistency (0-1) */
+    confidence: import("@sinclair/typebox").TNumber;
+    /** Aggregate score (weighted average) */
+    aggregate: import("@sinclair/typebox").TNumber;
+}>;
+export type CandidateScores = Static<typeof CandidateScoresSchema>;
+/**
+ * Scored candidate with ranking.
+ */
+export declare const ScoredCandidateSchema: import("@sinclair/typebox").TObject<{
+    /** Original candidate index from Dreamer */
+    candidateIndex: import("@sinclair/typebox").TInteger;
+    /** The Dreamer candidate */
+    candidate: import("@sinclair/typebox").TObject<{
+        candidateIndex: import("@sinclair/typebox").TInteger;
+        badDecision: import("@sinclair/typebox").TString;
+        betterDecision: import("@sinclair/typebox").TString;
+        rationale: import("@sinclair/typebox").TString;
+        confidence: import("@sinclair/typebox").TNumber;
+        riskLevel: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"low">, import("@sinclair/typebox").TLiteral<"medium">, import("@sinclair/typebox").TLiteral<"high">]>>;
+        strategicPerspective: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"conservative_fix">, import("@sinclair/typebox").TLiteral<"structural_improvement">, import("@sinclair/typebox").TLiteral<"paradigm_shift">]>>;
+    }>;
+    /** The Philosopher judgment */
+    judgment: import("@sinclair/typebox").TObject<{
+        candidateIndex: import("@sinclair/typebox").TInteger;
+        critique: import("@sinclair/typebox").TString;
+        principleAligned: import("@sinclair/typebox").TBoolean;
+        score: import("@sinclair/typebox").TNumber;
+        rank: import("@sinclair/typebox").TInteger;
+        scores: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
+            principleAlignment: import("@sinclair/typebox").TNumber;
+            specificity: import("@sinclair/typebox").TNumber;
+            actionability: import("@sinclair/typebox").TNumber;
+            executability: import("@sinclair/typebox").TNumber;
+            safetyImpact: import("@sinclair/typebox").TNumber;
+            uxImpact: import("@sinclair/typebox").TNumber;
+        }>>;
+        risks: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
+            falsePositiveEstimate: import("@sinclair/typebox").TNumber;
+            implementationComplexity: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"low">, import("@sinclair/typebox").TLiteral<"medium">, import("@sinclair/typebox").TLiteral<"high">]>;
+            breakingChangeRisk: import("@sinclair/typebox").TBoolean;
+        }>>;
+    }>;
+    /** Individual dimension scores */
+    scores: import("@sinclair/typebox").TObject<{
+        /** Schema completeness (0-1) */
+        schemaCompleteness: import("@sinclair/typebox").TNumber;
+        /** Principle alignment (0-1) */
+        principleAlignment: import("@sinclair/typebox").TNumber;
+        /** Executability (0-1) */
+        executability: import("@sinclair/typebox").TNumber;
+        /** Boundedness — specificity and constraint (0-1) */
+        boundedness: import("@sinclair/typebox").TNumber;
+        /** Confidence/consistency (0-1) */
+        confidence: import("@sinclair/typebox").TNumber;
+        /** Aggregate score (weighted average) */
+        aggregate: import("@sinclair/typebox").TNumber;
+    }>;
+    /** Final tournament rank (1 = winner) */
+    rank: import("@sinclair/typebox").TInteger;
+    /** Whether this candidate passed all thresholds */
+    thresholdPassed: import("@sinclair/typebox").TBoolean;
+    /** Which thresholds failed (if any) */
+    failedThresholds: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+}>;
+export type ScoredCandidate = Static<typeof ScoredCandidateSchema>;
+/**
+ * Result of a tournament selection (for candidate scoring).
+ */
+export declare const CandidateTournamentResultSchema: import("@sinclair/typebox").TObject<{
+    /** Whether tournament produced a winner */
+    success: import("@sinclair/typebox").TBoolean;
+    /** The winning candidate (if success === true) */
+    winner: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TObject<{
+        /** Original candidate index from Dreamer */
+        candidateIndex: import("@sinclair/typebox").TInteger;
+        /** The Dreamer candidate */
+        candidate: import("@sinclair/typebox").TObject<{
+            candidateIndex: import("@sinclair/typebox").TInteger;
+            badDecision: import("@sinclair/typebox").TString;
+            betterDecision: import("@sinclair/typebox").TString;
+            rationale: import("@sinclair/typebox").TString;
+            confidence: import("@sinclair/typebox").TNumber;
+            riskLevel: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"low">, import("@sinclair/typebox").TLiteral<"medium">, import("@sinclair/typebox").TLiteral<"high">]>>;
+            strategicPerspective: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"conservative_fix">, import("@sinclair/typebox").TLiteral<"structural_improvement">, import("@sinclair/typebox").TLiteral<"paradigm_shift">]>>;
+        }>;
+        /** The Philosopher judgment */
+        judgment: import("@sinclair/typebox").TObject<{
+            candidateIndex: import("@sinclair/typebox").TInteger;
+            critique: import("@sinclair/typebox").TString;
+            principleAligned: import("@sinclair/typebox").TBoolean;
+            score: import("@sinclair/typebox").TNumber;
+            rank: import("@sinclair/typebox").TInteger;
+            scores: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
+                principleAlignment: import("@sinclair/typebox").TNumber;
+                specificity: import("@sinclair/typebox").TNumber;
+                actionability: import("@sinclair/typebox").TNumber;
+                executability: import("@sinclair/typebox").TNumber;
+                safetyImpact: import("@sinclair/typebox").TNumber;
+                uxImpact: import("@sinclair/typebox").TNumber;
+            }>>;
+            risks: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
+                falsePositiveEstimate: import("@sinclair/typebox").TNumber;
+                implementationComplexity: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"low">, import("@sinclair/typebox").TLiteral<"medium">, import("@sinclair/typebox").TLiteral<"high">]>;
+                breakingChangeRisk: import("@sinclair/typebox").TBoolean;
+            }>>;
+        }>;
+        /** Individual dimension scores */
+        scores: import("@sinclair/typebox").TObject<{
+            /** Schema completeness (0-1) */
+            schemaCompleteness: import("@sinclair/typebox").TNumber;
+            /** Principle alignment (0-1) */
+            principleAlignment: import("@sinclair/typebox").TNumber;
+            /** Executability (0-1) */
+            executability: import("@sinclair/typebox").TNumber;
+            /** Boundedness — specificity and constraint (0-1) */
+            boundedness: import("@sinclair/typebox").TNumber;
+            /** Confidence/consistency (0-1) */
+            confidence: import("@sinclair/typebox").TNumber;
+            /** Aggregate score (weighted average) */
+            aggregate: import("@sinclair/typebox").TNumber;
+        }>;
+        /** Final tournament rank (1 = winner) */
+        rank: import("@sinclair/typebox").TInteger;
+        /** Whether this candidate passed all thresholds */
+        thresholdPassed: import("@sinclair/typebox").TBoolean;
+        /** Which thresholds failed (if any) */
+        failedThresholds: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+    }>, import("@sinclair/typebox").TNull]>;
+    /** All ranked candidates (sorted by rank) */
+    rankedCandidates: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+        /** Original candidate index from Dreamer */
+        candidateIndex: import("@sinclair/typebox").TInteger;
+        /** The Dreamer candidate */
+        candidate: import("@sinclair/typebox").TObject<{
+            candidateIndex: import("@sinclair/typebox").TInteger;
+            badDecision: import("@sinclair/typebox").TString;
+            betterDecision: import("@sinclair/typebox").TString;
+            rationale: import("@sinclair/typebox").TString;
+            confidence: import("@sinclair/typebox").TNumber;
+            riskLevel: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"low">, import("@sinclair/typebox").TLiteral<"medium">, import("@sinclair/typebox").TLiteral<"high">]>>;
+            strategicPerspective: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"conservative_fix">, import("@sinclair/typebox").TLiteral<"structural_improvement">, import("@sinclair/typebox").TLiteral<"paradigm_shift">]>>;
+        }>;
+        /** The Philosopher judgment */
+        judgment: import("@sinclair/typebox").TObject<{
+            candidateIndex: import("@sinclair/typebox").TInteger;
+            critique: import("@sinclair/typebox").TString;
+            principleAligned: import("@sinclair/typebox").TBoolean;
+            score: import("@sinclair/typebox").TNumber;
+            rank: import("@sinclair/typebox").TInteger;
+            scores: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
+                principleAlignment: import("@sinclair/typebox").TNumber;
+                specificity: import("@sinclair/typebox").TNumber;
+                actionability: import("@sinclair/typebox").TNumber;
+                executability: import("@sinclair/typebox").TNumber;
+                safetyImpact: import("@sinclair/typebox").TNumber;
+                uxImpact: import("@sinclair/typebox").TNumber;
+            }>>;
+            risks: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
+                falsePositiveEstimate: import("@sinclair/typebox").TNumber;
+                implementationComplexity: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"low">, import("@sinclair/typebox").TLiteral<"medium">, import("@sinclair/typebox").TLiteral<"high">]>;
+                breakingChangeRisk: import("@sinclair/typebox").TBoolean;
+            }>>;
+        }>;
+        /** Individual dimension scores */
+        scores: import("@sinclair/typebox").TObject<{
+            /** Schema completeness (0-1) */
+            schemaCompleteness: import("@sinclair/typebox").TNumber;
+            /** Principle alignment (0-1) */
+            principleAlignment: import("@sinclair/typebox").TNumber;
+            /** Executability (0-1) */
+            executability: import("@sinclair/typebox").TNumber;
+            /** Boundedness — specificity and constraint (0-1) */
+            boundedness: import("@sinclair/typebox").TNumber;
+            /** Confidence/consistency (0-1) */
+            confidence: import("@sinclair/typebox").TNumber;
+            /** Aggregate score (weighted average) */
+            aggregate: import("@sinclair/typebox").TNumber;
+        }>;
+        /** Final tournament rank (1 = winner) */
+        rank: import("@sinclair/typebox").TInteger;
+        /** Whether this candidate passed all thresholds */
+        thresholdPassed: import("@sinclair/typebox").TBoolean;
+        /** Which thresholds failed (if any) */
+        failedThresholds: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+    }>>;
+    /** Trace of decisions for debugging/explainability */
+    trace: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+        /** Description of this step */
+        step: import("@sinclair/typebox").TString;
+        /** Details about the decision */
+        details: import("@sinclair/typebox").TString;
+    }>>;
+    /** Why no winner was selected (if success === false) */
+    failureReason: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+}>;
+export type CandidateTournamentResult = Static<typeof CandidateTournamentResultSchema>;
+/** @deprecated Use CandidateTournamentResult instead. Alias for backward compatibility. */
+export type TournamentResult = CandidateTournamentResult;
+/** @deprecated Use CandidateTournamentResultSchema instead. Alias for backward compatibility. */
+export declare const TournamentResultSchema: import("@sinclair/typebox").TObject<{
+    /** Whether tournament produced a winner */
+    success: import("@sinclair/typebox").TBoolean;
+    /** The winning candidate (if success === true) */
+    winner: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TObject<{
+        /** Original candidate index from Dreamer */
+        candidateIndex: import("@sinclair/typebox").TInteger;
+        /** The Dreamer candidate */
+        candidate: import("@sinclair/typebox").TObject<{
+            candidateIndex: import("@sinclair/typebox").TInteger;
+            badDecision: import("@sinclair/typebox").TString;
+            betterDecision: import("@sinclair/typebox").TString;
+            rationale: import("@sinclair/typebox").TString;
+            confidence: import("@sinclair/typebox").TNumber;
+            riskLevel: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"low">, import("@sinclair/typebox").TLiteral<"medium">, import("@sinclair/typebox").TLiteral<"high">]>>;
+            strategicPerspective: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"conservative_fix">, import("@sinclair/typebox").TLiteral<"structural_improvement">, import("@sinclair/typebox").TLiteral<"paradigm_shift">]>>;
+        }>;
+        /** The Philosopher judgment */
+        judgment: import("@sinclair/typebox").TObject<{
+            candidateIndex: import("@sinclair/typebox").TInteger;
+            critique: import("@sinclair/typebox").TString;
+            principleAligned: import("@sinclair/typebox").TBoolean;
+            score: import("@sinclair/typebox").TNumber;
+            rank: import("@sinclair/typebox").TInteger;
+            scores: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
+                principleAlignment: import("@sinclair/typebox").TNumber;
+                specificity: import("@sinclair/typebox").TNumber;
+                actionability: import("@sinclair/typebox").TNumber;
+                executability: import("@sinclair/typebox").TNumber;
+                safetyImpact: import("@sinclair/typebox").TNumber;
+                uxImpact: import("@sinclair/typebox").TNumber;
+            }>>;
+            risks: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
+                falsePositiveEstimate: import("@sinclair/typebox").TNumber;
+                implementationComplexity: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"low">, import("@sinclair/typebox").TLiteral<"medium">, import("@sinclair/typebox").TLiteral<"high">]>;
+                breakingChangeRisk: import("@sinclair/typebox").TBoolean;
+            }>>;
+        }>;
+        /** Individual dimension scores */
+        scores: import("@sinclair/typebox").TObject<{
+            /** Schema completeness (0-1) */
+            schemaCompleteness: import("@sinclair/typebox").TNumber;
+            /** Principle alignment (0-1) */
+            principleAlignment: import("@sinclair/typebox").TNumber;
+            /** Executability (0-1) */
+            executability: import("@sinclair/typebox").TNumber;
+            /** Boundedness — specificity and constraint (0-1) */
+            boundedness: import("@sinclair/typebox").TNumber;
+            /** Confidence/consistency (0-1) */
+            confidence: import("@sinclair/typebox").TNumber;
+            /** Aggregate score (weighted average) */
+            aggregate: import("@sinclair/typebox").TNumber;
+        }>;
+        /** Final tournament rank (1 = winner) */
+        rank: import("@sinclair/typebox").TInteger;
+        /** Whether this candidate passed all thresholds */
+        thresholdPassed: import("@sinclair/typebox").TBoolean;
+        /** Which thresholds failed (if any) */
+        failedThresholds: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+    }>, import("@sinclair/typebox").TNull]>;
+    /** All ranked candidates (sorted by rank) */
+    rankedCandidates: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+        /** Original candidate index from Dreamer */
+        candidateIndex: import("@sinclair/typebox").TInteger;
+        /** The Dreamer candidate */
+        candidate: import("@sinclair/typebox").TObject<{
+            candidateIndex: import("@sinclair/typebox").TInteger;
+            badDecision: import("@sinclair/typebox").TString;
+            betterDecision: import("@sinclair/typebox").TString;
+            rationale: import("@sinclair/typebox").TString;
+            confidence: import("@sinclair/typebox").TNumber;
+            riskLevel: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"low">, import("@sinclair/typebox").TLiteral<"medium">, import("@sinclair/typebox").TLiteral<"high">]>>;
+            strategicPerspective: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"conservative_fix">, import("@sinclair/typebox").TLiteral<"structural_improvement">, import("@sinclair/typebox").TLiteral<"paradigm_shift">]>>;
+        }>;
+        /** The Philosopher judgment */
+        judgment: import("@sinclair/typebox").TObject<{
+            candidateIndex: import("@sinclair/typebox").TInteger;
+            critique: import("@sinclair/typebox").TString;
+            principleAligned: import("@sinclair/typebox").TBoolean;
+            score: import("@sinclair/typebox").TNumber;
+            rank: import("@sinclair/typebox").TInteger;
+            scores: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
+                principleAlignment: import("@sinclair/typebox").TNumber;
+                specificity: import("@sinclair/typebox").TNumber;
+                actionability: import("@sinclair/typebox").TNumber;
+                executability: import("@sinclair/typebox").TNumber;
+                safetyImpact: import("@sinclair/typebox").TNumber;
+                uxImpact: import("@sinclair/typebox").TNumber;
+            }>>;
+            risks: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
+                falsePositiveEstimate: import("@sinclair/typebox").TNumber;
+                implementationComplexity: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"low">, import("@sinclair/typebox").TLiteral<"medium">, import("@sinclair/typebox").TLiteral<"high">]>;
+                breakingChangeRisk: import("@sinclair/typebox").TBoolean;
+            }>>;
+        }>;
+        /** Individual dimension scores */
+        scores: import("@sinclair/typebox").TObject<{
+            /** Schema completeness (0-1) */
+            schemaCompleteness: import("@sinclair/typebox").TNumber;
+            /** Principle alignment (0-1) */
+            principleAlignment: import("@sinclair/typebox").TNumber;
+            /** Executability (0-1) */
+            executability: import("@sinclair/typebox").TNumber;
+            /** Boundedness — specificity and constraint (0-1) */
+            boundedness: import("@sinclair/typebox").TNumber;
+            /** Confidence/consistency (0-1) */
+            confidence: import("@sinclair/typebox").TNumber;
+            /** Aggregate score (weighted average) */
+            aggregate: import("@sinclair/typebox").TNumber;
+        }>;
+        /** Final tournament rank (1 = winner) */
+        rank: import("@sinclair/typebox").TInteger;
+        /** Whether this candidate passed all thresholds */
+        thresholdPassed: import("@sinclair/typebox").TBoolean;
+        /** Which thresholds failed (if any) */
+        failedThresholds: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+    }>>;
+    /** Trace of decisions for debugging/explainability */
+    trace: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+        /** Description of this step */
+        step: import("@sinclair/typebox").TString;
+        /** Details about the decision */
+        details: import("@sinclair/typebox").TString;
+    }>>;
+    /** Why no winner was selected (if success === false) */
+    failureReason: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+}>;
+/** @deprecated Use CandidateTournamentTraceEntry instead. Alias for backward compatibility. */
+export type TournamentTraceEntry = CandidateTournamentTraceEntry;
+/** @deprecated Use CandidateTournamentTraceEntrySchema instead. Alias for backward compatibility. */
+export declare const TournamentTraceEntrySchema: import("@sinclair/typebox").TObject<{
+    /** Description of this step */
+    step: import("@sinclair/typebox").TString;
+    /** Details about the decision */
+    details: import("@sinclair/typebox").TString;
+}>;
+/**
+ * Scoring weights for aggregate calculation.
+ */
+export declare const ScoringWeightsSchema: import("@sinclair/typebox").TObject<{
+    schemaCompleteness: import("@sinclair/typebox").TNumber;
+    principleAlignment: import("@sinclair/typebox").TNumber;
+    executability: import("@sinclair/typebox").TNumber;
+    boundedness: import("@sinclair/typebox").TNumber;
+    confidence: import("@sinclair/typebox").TNumber;
+}>;
+export type ScoringWeights = Static<typeof ScoringWeightsSchema>;
+/**
+ * Default scoring weights (must sum to 1.0).
+ */
+export declare const DEFAULT_SCORING_WEIGHTS: ScoringWeights;
+/**
+ * Result of diversity validation on Dreamer candidates.
+ * Soft enforcement: result is informational, never gates the pipeline.
+ */
+export declare const DiversityValidationResultSchema: import("@sinclair/typebox").TObject<{
+    /** Whether candidates passed diversity checks */
+    diversityCheckPassed: import("@sinclair/typebox").TBoolean;
+    /** Whether at least 2 distinct risk levels were present */
+    riskLevelDiversity: import("@sinclair/typebox").TBoolean;
+    /** Whether no candidate pair exceeded keyword overlap threshold */
+    keywordOverlapPassed: import("@sinclair/typebox").TBoolean;
+    /** Highest pairwise keyword overlap score (for telemetry) */
+    maxOverlapScore: import("@sinclair/typebox").TNumber;
+    /** Human-readable summary of check results */
+    details: import("@sinclair/typebox").TString;
+}>;
+export type DiversityValidationResult = Static<typeof DiversityValidationResultSchema>;
+/**
+ * Score a single Dreamer candidate + Philosopher judgment pair.
+ *
+ * @param candidate - Dreamer candidate
+ * @param judgment - Philosopher judgment
+ * @param weights - Scoring weights
+ * @returns Individual scores
+ */
+export declare function scoreCandidate(candidate: TrinityDreamerCandidate, judgment: PhilosopherJudgment, weights?: ScoringWeights): CandidateScores;
+/**
+ * Check if candidate passes minimum thresholds.
+ *
+ * @param scores - Candidate scores
+ * @param thresholds - Minimum threshold values
+ * @returns Tuple of [passed, failedThresholdNames]
+ */
+export declare function checkThresholds(scores: CandidateScores, thresholds: ThresholdValues): [boolean, string[]];
+/**
+ * Validate that Dreamer candidates are strategically diverse.
+ *
+ * DIVER-03: Checks risk level diversity (Set.size >= 2 when candidates >= 2)
+ * and keyword overlap similarity (reject if intersection / max(|A|, |B|) > 0.8
+ * for words > 3 chars per D-05).
+ *
+ * This is SOFT enforcement: returns a result, never throws.
+ * Pipeline continues regardless of diversityCheckPassed value.
+ *
+ * @param candidates - Dreamer candidates to validate
+ * @returns DiversityValidationResult with pass/fail details
+ */
+export declare function validateCandidateDiversity(candidates: TrinityDreamerCandidate[]): DiversityValidationResult;
+export interface RankCandidatesOptions {
+    candidates: TrinityDreamerCandidate[];
+    judgments: PhilosopherJudgment[];
+    thresholds: ThresholdValues;
+    weights?: ScoringWeights;
+}
+export interface RunTournamentOptions {
+    candidates: TrinityDreamerCandidate[];
+    judgments: PhilosopherJudgment[];
+    thresholds: ThresholdValues;
+    weights?: ScoringWeights;
+}
+/**
+ * Score and rank all candidates deterministically.
+ *
+ * @param options - Ranking options
+ * @returns All scored and ranked candidates
+ */
+export declare function rankCandidates(options: RankCandidatesOptions): ScoredCandidate[];
+/**
+ * Run tournament selection to choose the best candidate.
+ *
+ * @param options - Tournament options
+ * @returns Tournament result with winner
+ */
+export declare function runTournament(options: RunTournamentOptions): CandidateTournamentResult;
+//# sourceMappingURL=candidate-scoring.d.ts.map

package/dist/runtime-v2/nocturnal/candidate-scoring.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"candidate-scoring.d.ts","sourceRoot":"","sources":["../../../src/runtime-v2/nocturnal/candidate-scoring.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,EAAQ,KAAK,MAAM,EAAE,MAAM,mBAAmB,CAAC;AACtD,OAAO,KAAK,EAAE,uBAAuB,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAOvF;;GAEG;AACH,eAAO,MAAM,qBAAqB;;;;;;;EAOhC,CAAC;AACH,MAAM,MAAM,eAAe,GAAG,MAAM,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAMlE;;GAEG;AACH,eAAO,MAAM,mCAAmC;IAC9C,+BAA+B;;IAE/B,iCAAiC;;EAEjC,CAAC;AACH,MAAM,MAAM,6BAA6B,GAAG,MAAM,CAAC,OAAO,mCAAmC,CAAC,CAAA;AAE9F;;GAEG;AACH,eAAO,MAAM,qBAAqB;IAChC,gCAAgC;;IAEhC,gCAAgC;;IAEhC,0BAA0B;;IAE1B,qDAAqD;;IAErD,mCAAmC;;IAEnC,yCAAyC;;EAEzC,CAAC;AACH,MAAM,MAAM,eAAe,GAAG,MAAM,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAElE;;GAEG;AACH,eAAO,MAAM,qBAAqB;IAChC,4CAA4C;;IAE5C,4BAA4B;;;;;;;;;;IAE5B,+BAA+B;;;;;;;;;;;;;;;;;;;;;IAE/B,kCAAkC;;QAzBlC,gCAAgC;;QAEhC,gCAAgC;;QAEhC,0BAA0B;;QAE1B,qDAAqD;;QAErD,mCAAmC;;QAEnC,yCAAyC;;;IAiBzC,yCAAyC;;IAEzC,mDAAmD;;IAEnD,uCAAuC;;EAEvC,CAAC;AACH,MAAM,MAAM,eAAe,GAAG,MAAM,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAElE;;GAEG;AACH,eAAO,MAAM,+BAA+B;IAC1C,2CAA2C;;IAE3C,kDAAkD;;QAvBlD,4CAA4C;;QAE5C,4BAA4B;;;;;;;;;;QAE5B,+BAA+B;;;;;;;;;;;;;;;;;;;;;QAE/B,kCAAkC;;YAzBlC,gCAAgC;;YAEhC,gCAAgC;;YAEhC,0BAA0B;;YAE1B,qDAAqD;;YAErD,mCAAmC;;YAEnC,yCAAyC;;;QAiBzC,yCAAyC;;QAEzC,mDAAmD;;QAEnD,uCAAuC;;;IAavC,6CAA6C;;QAzB7C,4CAA4C;;QAE5C,4BAA4B;;;;;;;;;;QAE5B,+BAA+B;;;;;;;;;;;;;;;;;;;;;QAE/B,kCAAkC;;YAzBlC,gCAAgC;;YAEhC,gCAAgC;;YAEhC,0BAA0B;;YAE1B,qDAAqD;;YAErD,mCAAmC;;YAEnC,yCAAyC;;;QAiBzC,yCAAyC;;QAEzC,mDAAmD;;QAEnD,uCAAuC;;;IAevC,sDAAsD;;QAzDtD,+BAA+B;;QAE/B,iCAAiC;;;IAyDjC,wDAAwD;;EAExD,CAAC;AACH,MAAM,MAAM,yBAAyB,GAAG,MAAM,CAAC,OAAO,+BAA+B,CAAC,CAAA;AAGtF,2FAA2F;AAC3F,MAAM,MAAM,gBAAgB,GAAG,yBAAyB,CAAC;AAEzD,iGAAiG;AACjG,eAAO,MAAM,sBAAsB;IAlBjC,2CAA2C;;IAE3C,kDAAkD;;QAvBlD,4CAA4C;;QAE5C,4BAA4B;;;;;;;;;;QAE5B,+BAA+B;;;;;;;;;;;;;;;;;;;;;QAE/B,kCAAkC;;YAzBlC,gCAAgC;;YAEhC,gCAAgC;;YAEhC,0BAA0B;;YAE1B,qDAAqD;;YAErD,mCAAmC;;YAEnC,yCAAyC;;;QAiBzC,yCAAyC;;QAEzC,mDAAmD;;QAEnD,uCAAuC;;;IAavC,6CAA6C;;QAzB7C,4CAA4C;;QAE5C,4BAA4B;;;;;;;;;;QAE5B,+BAA+B;;;;;;;;;;;;;;;;;;;;;QAE/B,kCAAkC;;YAzBlC,gCAAgC;;YAEhC,gCAAgC;;YAEhC,0BAA0B;;YAE1B,qDAAqD;;YAErD,mCAAmC;;YAEnC,yCAAyC;;;QAiBzC,yCAAyC;;QAEzC,mDAAmD;;QAEnD,uCAAuC;;;IAevC,sDAAsD;;QAzDtD,+BAA+B;;QAE/B,iCAAiC;;;IAyDjC,wDAAwD;;EAUW,CAAC;AAEtE,+FAA+F;AAC/F,MAAM,MAAM,oBAAoB,GAAG,6BAA6B,CAAC;AAEjE,qGAAqG;AACrG,eAAO,MAAM,0BAA0B;IA3ErC,+BAA+B;;IAE/B,iCAAiC;;EAyE0C,CAAC;AAE9E;;GAEG;AACH,eAAO,MAAM,oBAAoB;;;;;;EAM/B,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,MAAM,CAAC,OAAO,oBAAoB,CAAC,CAAA;AAEhE;;GAEG;AACH,eAAO,MAAM,uBAAuB,EAAE,cAMrC,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,+BAA+B;IAC1C,iDAAiD;;IAEjD,2DAA2D;;IAE3D,mEAAmE;;IAEnE,6DAA6D;;IAE7D,8CAA8C;;EAE9C,CAAC;AACH,MAAM,MAAM,yBAAyB,GAAG,MAAM,CAAC,OAAO,+BAA+B,CAAC,CAAA;AAqCtF;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAC5B,SAAS,EAAE,uBAAuB,EAClC,QAAQ,EAAE,mBAAmB,EAC7B,OAAO,GAAE,cAAwC,GAChD,eAAe,CA+DjB;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAC7B,MAAM,EAAE,eAAe,EACvB,UAAU,EAAE,eAAe,GAC1B,CAAC,OAAO,EAAE,MAAM,EAAE,CAAC,CAuBrB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,0BAA0B,CACxC,UAAU,EAAE,uBAAuB,EAAE,GACpC,yBAAyB,CAmE3B;AAID,MAAM,WAAW,qBAAqB;IACpC,UAAU,EAAE,uBAAuB,EAAE,CAAC;IACtC,SAAS,EAAE,mBAAmB,EAAE,CAAC;IACjC,UAAU,EAAE,eAAe,CAAC;IAC5B,OAAO,CAAC,EAAE,cAAc,CAAC;CAC1B;AAED,MAAM,WAAW,oBAAoB;IACnC,UAAU,EAAE,uBAAuB,EAAE,CAAC;IACtC,SAAS,EAAE,mBAAmB,EAAE,CAAC;IACjC,UAAU,EAAE,eAAe,CAAC;IAC5B,OAAO,CAAC,EAAE,cAAc,CAAC;CAC1B;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAC5B,OAAO,EAAE,qBAAqB,GAC7B,eAAe,EAAE,CA0FnB;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAC3B,OAAO,EAAE,oBAAoB,GAC5B,yBAAyB,CAkE3B"}