@ai-sdlc/orchestrator 0.6.0 → 0.9.0

package/dist/sa-scoring/index.js

@@ -0,0 +1,158 @@
+/**
+ * SA scoring orchestration (RFC-0008 Addendum B §B.7.3).
+ *
+ * `scoreSoulAlignment(input, deps)` runs the three-layer SA scorer end
+ * to end with phase-aware short-circuits:
+ *
+ *   - Layer 1 hard gate → skips Layer 2/3, SA-1 forced to 0
+ *   - Phase 2a shadow  → all layers computed + persisted, but
+ *                         shadowMode=true signals caller to use
+ *                         label-based soulAlignment in ranking
+ *   - Phase 2b/2c/3    → sa1 replaces label-based soulAlignment
+ *
+ * Persists one `did_scoring_events` row per dimension so operators can
+ * query per-dimension precision by phase.
+ */
+import { compileDid } from './did-compiler.js';
+import { runLayer1 } from './layer1-deterministic.js';
+import { computeDomainRelevance, computePrincipleCoverage, } from './layer2-structural.js';
+import { runLayer3 } from './layer3-llm.js';
+import { computeSoulAlignment, } from './composite.js';
+// ── Orchestration ───────────────────────────────────────────────────
+export async function scoreSoulAlignment(input, deps) {
+    const compiled = deps.compiledDid ?? compileDid(input.did);
+    // ── Layer 1 (deterministic) ────────────────────────────────────
+    const layer1 = await runLayer1({
+        issueText: input.issueText,
+        compiled,
+        depparse: deps.depparse,
+        observedMetrics: input.observedMetrics,
+    });
+    // ── Layer 2 (BM25 structural) ──────────────────────────────────
+    // Always compute, even in shadow mode, so precision tracking works.
+    const domainRelevance = computeDomainRelevance(input.issueText, compiled.bm25Corpus);
+    const principleCoverage = computePrincipleCoverage(input.issueText, compiled.principleCorpora);
+    // ── Layer 3 (LLM) ──────────────────────────────────────────────
+    // Skip Layer 3 if hard-gated — SA-1 = 0 short-circuits regardless
+    // of what the LLM might say. Matches §B.7.1 STOP condition.
+    let layer3;
+    if (!layer1.hardGated) {
+        layer3 = await runLayer3({
+            issueText: input.issueText,
+            did: input.did,
+            dsb: input.dsb,
+            preVerifiedSummary: layer1.preVerifiedSummary,
+            llm: deps.llm,
+        });
+    }
+    // ── DSB-derived computable inputs for SA-2 ────────────────────
+    const tokenCompliance = input.dsb?.status?.tokenCompliance?.currentCoverage ?? 0;
+    const catalogHealth = input.dsb?.status?.catalogHealth?.coveragePercent ?? 0;
+    // Count design anti-pattern hits for SA-2 conflict penalty.
+    const coreDesignAntiPatternCount = layer1.designAntiPatternHits.hits.filter((h) => h.identityClass === 'core').length;
+    const evolvingDesignAntiPatternCount = layer1.designAntiPatternHits.hits.filter((h) => h.identityClass === 'evolving').length;
+    // ── Composite ─────────────────────────────────────────────────
+    const composite = computeSoulAlignment({
+        phase: input.phase,
+        calibratedWeights: input.calibratedWeights,
+        sa1: {
+            hardGated: layer1.hardGated,
+            coreViolationCount: layer1.coreViolationCount,
+            evolvingViolationCount: layer1.evolvingViolationCount,
+            domainRelevance: domainRelevance.score,
+            domainIntent: layer3?.domainIntent ?? 0,
+            subtleConflicts: layer3?.subtleConflicts ?? [],
+        },
+        sa2: {
+            tokenCompliance,
+            catalogHealth,
+            principleCoverage: principleCoverage.overallCoverage,
+            principleAlignment: layer3?.principleAlignment ?? 0,
+            coreDesignAntiPatternCount,
+            evolvingDesignAntiPatternCount,
+            subtleDesignConflicts: layer3?.subtleDesignConflicts ?? [],
+        },
+    });
+    // ── Persist to did_scoring_events (one row per dimension) ─────
+    if (deps.stateStore && input.issueNumber !== undefined) {
+        persistScoringEvent(deps.stateStore, {
+            didName: input.did.metadata.name,
+            issueNumber: input.issueNumber,
+            dimension: 'SA-1',
+            phase: input.phase,
+            weights: composite.weights,
+            layer1,
+            layer2: domainRelevance,
+            layer3Sa1: layer3
+                ? {
+                    domainIntent: layer3.domainIntent,
+                    domainIntentConfidence: layer3.domainIntentConfidence,
+                    subtleConflicts: layer3.subtleConflicts,
+                }
+                : undefined,
+            compositeScore: composite.sa1.sa1,
+        });
+        persistScoringEvent(deps.stateStore, {
+            didName: input.did.metadata.name,
+            issueNumber: input.issueNumber,
+            dimension: 'SA-2',
+            phase: input.phase,
+            weights: composite.weights,
+            layer1,
+            layer2: principleCoverage,
+            layer3Sa2: layer3
+                ? {
+                    principleAlignment: layer3.principleAlignment,
+                    principleAlignmentConfidence: layer3.principleAlignmentConfidence,
+                    subtleDesignConflicts: layer3.subtleDesignConflicts,
+                }
+                : undefined,
+            compositeScore: composite.sa2.sa2,
+        });
+    }
+    return {
+        sa1: composite.sa1.sa1,
+        sa2: composite.sa2.sa2,
+        composite,
+        layer1,
+        layer2: { domainRelevance, principleCoverage },
+        layer3,
+        shadowMode: composite.shadowMode,
+        phase: input.phase,
+        weights: composite.weights,
+    };
+}
+function persistScoringEvent(store, input) {
+    const layer1Summary = {
+        hardGated: input.layer1.hardGated,
+        coreViolationCount: input.layer1.coreViolationCount,
+        evolvingViolationCount: input.layer1.evolvingViolationCount,
+        scopeOutOfScopeHits: input.layer1.scopeGate.outOfScopeHits.length,
+        constraintViolations: input.layer1.constraintViolations.violations.length,
+        antiPatternHits: input.layer1.antiPatternHits.hits.length + input.layer1.designAntiPatternHits.hits.length,
+    };
+    const layer3Payload = input.layer3Sa1 ?? input.layer3Sa2;
+    store.recordDidScoringEvent({
+        didName: input.didName,
+        issueNumber: input.issueNumber,
+        saDimension: input.dimension,
+        phase: input.phase,
+        layer1ResultJson: JSON.stringify(layer1Summary),
+        layer2ResultJson: JSON.stringify(input.layer2),
+        layer3ResultJson: layer3Payload ? JSON.stringify(layer3Payload) : undefined,
+        compositeScore: input.compositeScore,
+        phaseWeightsJson: JSON.stringify(input.weights),
+    });
+}
+// ── Admission-composite integration helpers ──────────────────────────
+/**
+ * Resolve the soulAlignment value to feed the admission composite
+ * based on phase + SA result. In shadow mode (2a), returns undefined
+ * so the caller falls back to the label-based heuristic.
+ */
+export function resolveSoulAlignmentOverride(result) {
+    if (result.shadowMode)
+        return undefined;
+    return result.sa1;
+}
+//# sourceMappingURL=index.js.map

package/dist/sa-scoring/layer1-deterministic.d.ts

@@ -0,0 +1,115 @@
+/**
+ * Layer 1 — Deterministic SA scorer (RFC-0008 Addendum B §B.4).
+ *
+ * Consumes a `CompiledDid` + issue text + state store metrics and
+ * produces a fully-deterministic scoring result. Layer 1 never makes
+ * network or LLM calls *except* for the dep-parse sidecar (for
+ * requirement-construction detection).
+ *
+ * A `core` out-of-scope match is a **hard gate** — downstream SA-1
+ * scoring must treat `hardGated=true` as SA-1 = 0.0 regardless of
+ * Layer 2/3 output. Evolving matches surface as warnings but do not
+ * gate admission.
+ */
+import type { CompiledDid } from './did-compiler.js';
+import type { DepparseClient } from './depparse-client.js';
+export interface ScopeGateMatch {
+    label: string;
+    synonym?: string;
+    identityClass: 'core' | 'evolving';
+    matchedText: string;
+}
+export interface ScopeGateResult {
+    inScopeHits: ScopeGateMatch[];
+    outOfScopeHits: ScopeGateMatch[];
+    /** True when a core out-of-scope term matched (hard gate). */
+    hardGated: boolean;
+    /** Warnings for evolving out-of-scope hits (soft gate). */
+    warnings: string[];
+}
+export interface ConstraintViolation {
+    constraintId: string;
+    concept: string;
+    relationship: string;
+    pattern: string;
+    matchedText: string;
+    construction?: string;
+    depPath?: string[];
+    identityClass: 'core' | 'evolving';
+}
+export interface ConstraintViolationResult {
+    violations: ConstraintViolation[];
+    /** True when the depparse sidecar was unavailable (fail-soft skip). */
+    depparseSkipped: boolean;
+}
+export interface AntiPatternHit {
+    id: string;
+    label: string;
+    pattern: string;
+    matchedText: string;
+    identityClass: 'core' | 'evolving';
+    scope: 'product' | 'design-principle' | 'voice' | 'visual';
+    /** Present only for scope='design-principle'. */
+    principleId?: string;
+}
+export interface AntiPatternResult {
+    hits: AntiPatternHit[];
+}
+export type MeasurableSignalStatus = 'pass' | 'fail' | 'missing';
+export interface MeasurableSignalCheck {
+    id: string;
+    metric: string;
+    threshold: number;
+    operator: string;
+    observedValue?: number;
+    status: MeasurableSignalStatus;
+    identityClass: 'core' | 'evolving';
+}
+export interface MeasurableSignalResult {
+    checks: MeasurableSignalCheck[];
+    /** Count of signals with status='fail' on a core-classified signal. */
+    coreFailureCount: number;
+}
+export interface DeterministicScoringResult {
+    scopeGate: ScopeGateResult;
+    constraintViolations: ConstraintViolationResult;
+    antiPatternHits: AntiPatternResult;
+    designAntiPatternHits: AntiPatternResult;
+    measurableSignalChecks: MeasurableSignalResult;
+    /** Shortcut — true when the scope gate (core) fails. */
+    hardGated: boolean;
+    /** Total count of `core` violations across all sources. */
+    coreViolationCount: number;
+    /** Total count of `evolving` violations across all sources. */
+    evolvingViolationCount: number;
+    /** Human-readable pre-verified summary for Layer 3 prompt injection. */
+    preVerifiedSummary: string;
+}
+export declare function checkScopeGate(issueText: string, compiled: CompiledDid): ScopeGateResult;
+export declare function detectConstraintViolations(issueText: string, compiled: CompiledDid, client: DepparseClient): Promise<ConstraintViolationResult>;
+export declare function detectAntiPatterns(issueText: string, compiled: CompiledDid): {
+    product: AntiPatternResult;
+    design: AntiPatternResult;
+};
+export declare function checkMeasurableSignals(observed: Record<string, number>, compiled: CompiledDid): MeasurableSignalResult;
+export interface Layer1Input {
+    issueText: string;
+    compiled: CompiledDid;
+    depparse: DepparseClient;
+    /** Observed metric values keyed by signal metric name. */
+    observedMetrics?: Record<string, number>;
+}
+export declare function runLayer1(input: Layer1Input): Promise<DeterministicScoringResult>;
+interface SummaryInput {
+    scopeGate: ScopeGateResult;
+    constraintViolations: ConstraintViolationResult;
+    product: AntiPatternResult;
+    design: AntiPatternResult;
+    measurable: MeasurableSignalResult;
+    hardGated: boolean;
+    coreViolationCount: number;
+    evolvingViolationCount: number;
+}
+export declare function renderPreVerifiedSummary(input: SummaryInput): string;
+export {};
+//# sourceMappingURL=layer1-deterministic.d.ts.map

package/dist/sa-scoring/layer1-deterministic.js

@@ -0,0 +1,298 @@
+/**
+ * Layer 1 — Deterministic SA scorer (RFC-0008 Addendum B §B.4).
+ *
+ * Consumes a `CompiledDid` + issue text + state store metrics and
+ * produces a fully-deterministic scoring result. Layer 1 never makes
+ * network or LLM calls *except* for the dep-parse sidecar (for
+ * requirement-construction detection).
+ *
+ * A `core` out-of-scope match is a **hard gate** — downstream SA-1
+ * scoring must treat `hardGated=true` as SA-1 = 0.0 regardless of
+ * Layer 2/3 output. Evolving matches surface as warnings but do not
+ * gate admission.
+ */
+import { DepparseError } from './depparse-client.js';
+// ── Tokenization / matching ──────────────────────────────────────────
+function lower(s) {
+    return s.toLowerCase();
+}
+function includesWhole(haystack, needle) {
+    if (!needle)
+        return false;
+    // Whole-word-ish match: bounds on non-alphanumeric.
+    const re = new RegExp(`(^|[^a-z0-9])${escapeRegex(lower(needle))}($|[^a-z0-9])`, 'i');
+    return re.test(haystack);
+}
+function escapeRegex(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+// ── Scope gate ───────────────────────────────────────────────────────
+export function checkScopeGate(issueText, compiled) {
+    const text = lower(issueText);
+    const inHits = [];
+    const outHits = [];
+    const warnings = [];
+    let hardGated = false;
+    for (const entry of compiled.scopeLists.inScope) {
+        const all = [entry.label, ...entry.synonyms];
+        for (const term of all) {
+            if (includesWhole(text, term)) {
+                inHits.push({
+                    label: entry.label,
+                    synonym: term === entry.label ? undefined : term,
+                    identityClass: entry.identityClass,
+                    matchedText: term,
+                });
+                break;
+            }
+        }
+    }
+    for (const entry of compiled.scopeLists.outOfScope) {
+        const all = [entry.label, ...entry.synonyms];
+        for (const term of all) {
+            if (includesWhole(text, term)) {
+                outHits.push({
+                    label: entry.label,
+                    synonym: term === entry.label ? undefined : term,
+                    identityClass: entry.identityClass,
+                    matchedText: term,
+                });
+                if (entry.identityClass === 'core') {
+                    hardGated = true;
+                }
+                else {
+                    warnings.push(`Evolving out-of-scope match: "${entry.label}" via "${term}"`);
+                }
+                break;
+            }
+        }
+    }
+    return { inScopeHits: inHits, outOfScopeHits: outHits, hardGated, warnings };
+}
+// ── Constraint violations (via depparse sidecar) ─────────────────────
+export async function detectConstraintViolations(issueText, compiled, client) {
+    const violations = [];
+    let depparseSkipped = false;
+    for (const rule of compiled.constraintRules) {
+        // Only enforce `must-not-require` / `must-not-include` via depparse;
+        // `must-require` / `must-include` are positive constraints (enforced
+        // downstream as signal requirements, not as violation checks).
+        if (rule.relationship !== 'must-not-require' && rule.relationship !== 'must-not-include') {
+            continue;
+        }
+        let response;
+        try {
+            response = await client.match({
+                text: issueText,
+                patterns: rule.detectionPatterns,
+            });
+        }
+        catch (err) {
+            if (err instanceof DepparseError &&
+                (err.kind === 'model-unavailable' || err.kind === 'network' || err.kind === 'timeout')) {
+                depparseSkipped = true;
+                continue;
+            }
+            throw err;
+        }
+        for (const match of response.matches) {
+            violations.push(buildViolation(rule, match));
+        }
+    }
+    return { violations, depparseSkipped };
+}
+function buildViolation(rule, match) {
+    return {
+        constraintId: rule.id,
+        concept: rule.concept,
+        relationship: rule.relationship,
+        pattern: match.pattern,
+        matchedText: match.matchedText,
+        construction: match.construction,
+        depPath: match.depPath,
+        identityClass: rule.identityClass,
+    };
+}
+// ── Anti-pattern matching ────────────────────────────────────────────
+function matchAntiPatterns(text, list, scope, principleId) {
+    const hits = [];
+    for (const ap of list) {
+        for (const pattern of ap.detectionPatterns) {
+            if (includesWhole(text, pattern)) {
+                hits.push({
+                    id: ap.id,
+                    label: ap.label,
+                    pattern,
+                    matchedText: pattern,
+                    identityClass: ap.identityClass,
+                    scope,
+                    ...(principleId ? { principleId } : {}),
+                });
+            }
+        }
+    }
+    return hits;
+}
+export function detectAntiPatterns(issueText, compiled) {
+    const text = lower(issueText);
+    const productHits = matchAntiPatterns(text, compiled.antiPatternLists.product, 'product');
+    const designHits = [];
+    for (const [principleId, list] of Object.entries(compiled.antiPatternLists.perPrinciple)) {
+        designHits.push(...matchAntiPatterns(text, list, 'design-principle', principleId));
+    }
+    designHits.push(...matchAntiPatterns(text, compiled.antiPatternLists.voice, 'voice'));
+    designHits.push(...matchAntiPatterns(text, compiled.antiPatternLists.visual, 'visual'));
+    return {
+        product: { hits: productHits },
+        design: { hits: designHits },
+    };
+}
+// ── Measurable signal checks ─────────────────────────────────────────
+export function checkMeasurableSignals(observed, compiled) {
+    const checks = [];
+    let coreFailureCount = 0;
+    for (const signal of compiled.measurableSignals) {
+        const value = observed[signal.metric];
+        let status;
+        if (value === undefined || Number.isNaN(value)) {
+            status = 'missing';
+        }
+        else {
+            status = evaluateOperator(value, signal.threshold, signal.operator) ? 'pass' : 'fail';
+        }
+        checks.push({
+            id: signal.id,
+            metric: signal.metric,
+            threshold: signal.threshold,
+            operator: signal.operator,
+            observedValue: value,
+            status,
+            identityClass: signal.identityClass,
+        });
+        if (status === 'fail' && signal.identityClass === 'core')
+            coreFailureCount++;
+    }
+    return { checks, coreFailureCount };
+}
+function evaluateOperator(value, threshold, operator) {
+    switch (operator) {
+        case 'gte':
+            return value >= threshold;
+        case 'lte':
+            return value <= threshold;
+        case 'gt':
+            return value > threshold;
+        case 'lt':
+            return value < threshold;
+        case 'eq':
+            return value === threshold;
+        case 'neq':
+            return value !== threshold;
+        default:
+            return false;
+    }
+}
+export async function runLayer1(input) {
+    const { issueText, compiled, depparse, observedMetrics = {} } = input;
+    const scopeGate = checkScopeGate(issueText, compiled);
+    const constraintViolations = await detectConstraintViolations(issueText, compiled, depparse);
+    const { product, design } = detectAntiPatterns(issueText, compiled);
+    const measurable = checkMeasurableSignals(observedMetrics, compiled);
+    // Count core vs evolving violations across all dimensions.
+    let coreViolationCount = 0;
+    let evolvingViolationCount = 0;
+    const bump = (ic) => {
+        if (ic === 'core')
+            coreViolationCount++;
+        else
+            evolvingViolationCount++;
+    };
+    for (const hit of scopeGate.outOfScopeHits)
+        bump(hit.identityClass);
+    for (const v of constraintViolations.violations)
+        bump(v.identityClass);
+    for (const h of product.hits)
+        bump(h.identityClass);
+    for (const h of design.hits)
+        bump(h.identityClass);
+    coreViolationCount += measurable.coreFailureCount;
+    const hardGated = scopeGate.hardGated;
+    const preVerifiedSummary = renderPreVerifiedSummary({
+        scopeGate,
+        constraintViolations,
+        product,
+        design,
+        measurable,
+        hardGated,
+        coreViolationCount,
+        evolvingViolationCount,
+    });
+    return {
+        scopeGate,
+        constraintViolations,
+        antiPatternHits: product,
+        designAntiPatternHits: design,
+        measurableSignalChecks: measurable,
+        hardGated,
+        coreViolationCount,
+        evolvingViolationCount,
+        preVerifiedSummary,
+    };
+}
+export function renderPreVerifiedSummary(input) {
+    const lines = [];
+    lines.push('## Deterministic verification');
+    lines.push('');
+    lines.push(`- Hard gated: ${input.hardGated ? 'yes' : 'no'}`);
+    lines.push(`- Core violations: ${input.coreViolationCount}`);
+    lines.push(`- Evolving violations: ${input.evolvingViolationCount}`);
+    lines.push('');
+    lines.push('### Scope gate');
+    if (input.scopeGate.outOfScopeHits.length === 0) {
+        lines.push('- No out-of-scope hits');
+    }
+    else {
+        for (const hit of input.scopeGate.outOfScopeHits) {
+            lines.push(`- ${hit.identityClass} OUT — "${hit.label}"` +
+                (hit.synonym ? ` via "${hit.synonym}"` : ''));
+        }
+    }
+    lines.push('');
+    lines.push('### Constraint violations');
+    if (input.constraintViolations.violations.length === 0) {
+        lines.push('- None detected');
+        if (input.constraintViolations.depparseSkipped) {
+            lines.push('- (depparse sidecar unavailable — skipped)');
+        }
+    }
+    else {
+        for (const v of input.constraintViolations.violations) {
+            lines.push(`- ${v.identityClass} ${v.constraintId} (${v.relationship} ${v.concept}) — "${v.matchedText}"` +
+                (v.construction ? ` via ${v.construction}` : ''));
+        }
+    }
+    lines.push('');
+    lines.push('### Anti-pattern hits');
+    const allAntiHits = [...input.product.hits, ...input.design.hits];
+    if (allAntiHits.length === 0) {
+        lines.push('- None detected');
+    }
+    else {
+        for (const h of allAntiHits) {
+            lines.push(`- ${h.identityClass} [${h.scope}${h.principleId ? `:${h.principleId}` : ''}] ${h.label} — "${h.matchedText}"`);
+        }
+    }
+    lines.push('');
+    lines.push('### Measurable signals');
+    const failures = input.measurable.checks.filter((c) => c.status === 'fail');
+    if (failures.length === 0) {
+        lines.push('- No failing signals');
+    }
+    else {
+        for (const c of failures) {
+            lines.push(`- ${c.identityClass} ${c.id} (${c.metric} ${c.operator} ${c.threshold}) — observed ${c.observedValue ?? 'n/a'}`);
+        }
+    }
+    return lines.join('\n');
+}
+//# sourceMappingURL=layer1-deterministic.js.map

package/dist/sa-scoring/layer2-structural.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Layer 2 — Structural BM25 scorer (RFC-0008 Addendum B §B.5).
+ *
+ *   computeDomainRelevance(issueText, bm25Corpus)   → SA-1 [0, 1]
+ *   computePrincipleCoverage(issueText, principleCorpora) → SA-2 vector
+ *
+ * Uses a minimal in-process BM25 implementation — no external index
+ * library needed. The corpus is tokenized at compile time
+ * (`did-compiler.ts`), so scoring is O(|query| × |corpus|) per call.
+ *
+ * Determinism: pure functions, no randomness, arithmetic-only. Same
+ * inputs → bit-exact outputs.
+ */
+import type { Bm25Corpus, PrincipleCorpora } from './did-compiler.js';
+interface Bm25Index {
+    /** The weighted-document list — each carries its own TF map + length. */
+    docs: Array<{
+        id: string;
+        weight: number;
+        length: number;
+        termFreq: Map<string, number>;
+    }>;
+    /** Number of documents that contain each term (for IDF). */
+    docFreq: Map<string, number>;
+    /** Average document length (weighted). */
+    avgDocLength: number;
+}
+declare function buildIndex(corpus: Bm25Corpus): Bm25Index;
+declare function idf(term: string, index: Bm25Index): number;
+declare function scoreDoc(queryTokens: readonly string[], doc: Bm25Index['docs'][number], index: Bm25Index): {
+    score: number;
+    termContributions: Map<string, number>;
+};
+declare function normalizeScore(rawScore: number): number;
+declare function topTerms(contributions: Map<string, number>, limit: number): ContributingTerm[];
+export interface ContributingTerm {
+    term: string;
+    score: number;
+}
+export interface DomainRelevanceResult {
+    /** Normalized relevance in [0, 1]. */
+    score: number;
+    /** Raw BM25 sum before normalization (for debugging / calibration). */
+    rawScore: number;
+    /** Top contributing terms, sorted by contribution score. */
+    contributingTerms: ContributingTerm[];
+    /** Number of query tokens after stopword stripping. */
+    queryLength: number;
+}
+export interface PrincipleCoverageEntry {
+    principleId: string;
+    coverage: number;
+    identityClass: 'core' | 'evolving';
+    contributingTerms: ContributingTerm[];
+}
+export interface PrincipleCoverageVector {
+    principles: PrincipleCoverageEntry[];
+    /** Weighted mean — core principles count twice, evolving once. */
+    overallCoverage: number;
+}
+export declare function computeDomainRelevance(issueText: string, corpus: Bm25Corpus): DomainRelevanceResult;
+export declare function computePrincipleCoverage(issueText: string, principleCorpora: PrincipleCorpora): PrincipleCoverageVector;
+export declare const __internals: {
+    buildIndex: typeof buildIndex;
+    idf: typeof idf;
+    scoreDoc: typeof scoreDoc;
+    normalizeScore: typeof normalizeScore;
+    topTerms: typeof topTerms;
+};
+export {};
+//# sourceMappingURL=layer2-structural.d.ts.map