@ai-sdlc/orchestrator 0.6.0 → 0.10.0

package/dist/runtime/worktree.js

@@ -0,0 +1,111 @@
+import { readFile, realpath, stat } from 'node:fs/promises';
+import { dirname, isAbsolute, join, resolve, sep } from 'node:path';
+const SLUG_INVALID = /[^a-zA-Z0-9._-]+/g;
+const SLUG_DEDUPE = /-+/g;
+export class WorktreeOwnershipError extends Error {
+    worktreePath;
+    expectedClone;
+    actualClone;
+    constructor(message, worktreePath, expectedClone, actualClone) {
+        super(message);
+        this.worktreePath = worktreePath;
+        this.expectedClone = expectedClone;
+        this.actualClone = actualClone;
+        this.name = 'WorktreeOwnershipError';
+    }
+}
+export function slugifyBranch(branch) {
+    if (!branch) {
+        throw new Error('Branch name cannot be empty');
+    }
+    const slug = branch
+        .replace(SLUG_INVALID, '-')
+        .replace(SLUG_DEDUPE, '-')
+        .replace(/^-+|-+$/g, '');
+    if (!slug) {
+        throw new Error(`Branch name has no slug-safe characters: ${branch}`);
+    }
+    return slug;
+}
+export function worktreePath(rootDir, branch) {
+    return join(rootDir, slugifyBranch(branch));
+}
+/**
+ * Verify a worktree at `worktreePath` was created from the clone at `expectedClonePath`.
+ *
+ * A git worktree contains a `.git` *file* (not directory) that points at the parent clone's
+ * `.git/worktrees/<name>/` directory. We parse the pointer and confirm it resolves under
+ * `expectedClonePath/.git/worktrees/`. Any mismatch returns owned=false with a structured reason.
+ */
+export async function verifyOwnership(worktreePathArg, expectedClonePath) {
+    const expectedWorktreesDir = resolve(expectedClonePath, '.git', 'worktrees');
+    // Canonicalize the expected dir to follow symlinks (e.g., macOS /var → /private/var).
+    // realpath fails if the path doesn't exist; fall back to resolve() in that case.
+    let canonicalExpected = expectedWorktreesDir;
+    try {
+        canonicalExpected = await realpath(expectedWorktreesDir);
+    }
+    catch {
+        /* directory doesn't exist yet — keep the resolved (non-canonical) path */
+    }
+    const dotGitPath = join(worktreePathArg, '.git');
+    let pointer;
+    try {
+        const buf = await readFile(dotGitPath);
+        pointer = buf.toString('utf8').trim();
+    }
+    catch {
+        return {
+            owned: false,
+            expectedClone: canonicalExpected,
+            actualClone: null,
+            reason: 'pointer-missing',
+        };
+    }
+    // Pointer file format per git docs: `gitdir: <absolute-path>` or `gitdir: <relative-path>`.
+    const match = pointer.match(/^gitdir:\s*(.+)$/);
+    if (!match) {
+        return {
+            owned: false,
+            expectedClone: canonicalExpected,
+            actualClone: pointer || null,
+            reason: 'pointer-malformed',
+        };
+    }
+    const declared = match[1].trim();
+    const declaredAbs = isAbsolute(declared) ? declared : resolve(dirname(dotGitPath), declared);
+    // Canonicalize the declared path the same way; if it doesn't exist, the worktree is
+    // detached and we can fall back to the resolved string.
+    let canonicalDeclared = resolve(declaredAbs);
+    try {
+        canonicalDeclared = await realpath(declaredAbs);
+    }
+    catch {
+        /* declared dir doesn't exist — use the resolved string for comparison */
+    }
+    // The pointer should land inside `<expectedClone>/.git/worktrees/<name>/`.
+    const owned = canonicalDeclared === canonicalExpected ||
+        canonicalDeclared.startsWith(canonicalExpected + sep);
+    return {
+        owned,
+        expectedClone: canonicalExpected,
+        actualClone: canonicalDeclared,
+        reason: owned ? 'ok' : 'cross-clone',
+    };
+}
+export async function assertOwnership(worktreePathArg, expectedClonePath) {
+    const result = await verifyOwnership(worktreePathArg, expectedClonePath);
+    if (!result.owned) {
+        throw new WorktreeOwnershipError(`Worktree ownership verification failed for ${worktreePathArg}: ${result.reason}`, worktreePathArg, result.expectedClone, result.actualClone);
+    }
+}
+export async function isExistingWorktree(worktreePathArg) {
+    try {
+        const dotGit = await stat(join(worktreePathArg, '.git'));
+        return dotGit.isFile();
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=worktree.js.map

package/dist/sa-scoring/auto-calibrate.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Phase 3 weight auto-calibration (RFC-0008 Addendum B §B.8).
+ *
+ * Reads trailing-90-day precision from `SAFeedbackStore`, shifts the
+ * Phase 3 (w_structural, w_llm) pair in the direction of the better-
+ * performing layer, and persists the result to `sa_phase_weights`.
+ *
+ * CR-2: `w_structural ≥ 0.20` floor enforced on the output, as is a
+ * symmetric `w_llm ≥ 0.20` floor — extreme single-layer dominance is
+ * never written.
+ *
+ * Idempotent: if the computed weights round-trip to the currently
+ * persisted pair, the row is not written and the caller's diff is
+ * empty. Rolling 90-day window by default.
+ */
+import type { SaDimension } from '../state/types.js';
+import type { StateStore } from '../state/store.js';
+import type { SAFeedbackStore } from './feedback-store.js';
+import type { PhaseWeights } from './composite.js';
+export declare const WEIGHT_FLOOR = 0.2;
+export declare const WEIGHT_CEILING: number;
+export declare const DEFAULT_SHIFT_SIZE = 0.05;
+export declare const PRECISION_DELTA_THRESHOLD = 0.1;
+/** Default calibration window — 90 days. */
+export declare const DEFAULT_WINDOW_DAYS = 90;
+/** Phase 2c default weights — used as starting point if none persisted. */
+export declare const DEFAULT_STARTING_WEIGHTS: PhaseWeights;
+export interface PrecisionPair {
+    structural: number;
+    llm: number;
+}
+export interface CalibrationDecision {
+    /** 'toward-structural' | 'toward-llm' | 'hold' */
+    direction: 'toward-structural' | 'toward-llm' | 'hold';
+    /** Magnitude of the LLM−structural precision difference. */
+    delta: number;
+}
+export declare function decideCalibrationDirection(precision: PrecisionPair): CalibrationDecision;
+export interface ComputePhase3WeightsInput {
+    current: PhaseWeights;
+    precision: PrecisionPair;
+    shiftSize?: number;
+}
+export declare function computePhase3Weights(input: ComputePhase3WeightsInput): PhaseWeights;
+export interface AutoCalibrateDeps {
+    feedback: SAFeedbackStore;
+    stateStore: StateStore;
+    /** Clock injection for deterministic tests. */
+    now?: () => number;
+    /** Override the window (default 90d). */
+    windowDays?: number;
+    /** Starting weights when none are persisted. */
+    startingWeights?: PhaseWeights;
+    /** Adjustment step size per calibration run. */
+    shiftSize?: number;
+}
+export interface DimensionDiff {
+    dimension: SaDimension;
+    precision: PrecisionPair;
+    previous: PhaseWeights;
+    next: PhaseWeights;
+    changed: boolean;
+}
+export interface AutoCalibrateResult {
+    diffs: DimensionDiff[];
+}
+export declare function autoCalibratePhaseWeights(deps: AutoCalibrateDeps): Promise<AutoCalibrateResult>;
+export declare function renderCalibrationDiff(result: AutoCalibrateResult): string;
+//# sourceMappingURL=auto-calibrate.d.ts.map

package/dist/sa-scoring/auto-calibrate.js

@@ -0,0 +1,107 @@
+/**
+ * Phase 3 weight auto-calibration (RFC-0008 Addendum B §B.8).
+ *
+ * Reads trailing-90-day precision from `SAFeedbackStore`, shifts the
+ * Phase 3 (w_structural, w_llm) pair in the direction of the better-
+ * performing layer, and persists the result to `sa_phase_weights`.
+ *
+ * CR-2: `w_structural ≥ 0.20` floor enforced on the output, as is a
+ * symmetric `w_llm ≥ 0.20` floor — extreme single-layer dominance is
+ * never written.
+ *
+ * Idempotent: if the computed weights round-trip to the currently
+ * persisted pair, the row is not written and the caller's diff is
+ * empty. Rolling 90-day window by default.
+ */
+import { W_STRUCTURAL_FLOOR } from './composite.js';
+// ── Defaults and constants ──────────────────────────────────────────
+export const WEIGHT_FLOOR = W_STRUCTURAL_FLOOR; // 0.20
+export const WEIGHT_CEILING = 1 - WEIGHT_FLOOR; // 0.80
+export const DEFAULT_SHIFT_SIZE = 0.05;
+export const PRECISION_DELTA_THRESHOLD = 0.1;
+/** Default calibration window — 90 days. */
+export const DEFAULT_WINDOW_DAYS = 90;
+/** Phase 2c default weights — used as starting point if none persisted. */
+export const DEFAULT_STARTING_WEIGHTS = Object.freeze({
+    wStructural: 0.35,
+    wLlm: 0.65,
+});
+export function decideCalibrationDirection(precision) {
+    const delta = precision.llm - precision.structural;
+    if (delta > PRECISION_DELTA_THRESHOLD)
+        return { direction: 'toward-llm', delta };
+    if (delta < -PRECISION_DELTA_THRESHOLD)
+        return { direction: 'toward-structural', delta };
+    return { direction: 'hold', delta };
+}
+export function computePhase3Weights(input) {
+    const shift = input.shiftSize ?? DEFAULT_SHIFT_SIZE;
+    const decision = decideCalibrationDirection(input.precision);
+    let wStructural = input.current.wStructural;
+    if (decision.direction === 'toward-llm')
+        wStructural -= shift;
+    else if (decision.direction === 'toward-structural')
+        wStructural += shift;
+    wStructural = Math.max(WEIGHT_FLOOR, Math.min(WEIGHT_CEILING, wStructural));
+    return { wStructural, wLlm: 1 - wStructural };
+}
+export async function autoCalibratePhaseWeights(deps) {
+    const nowMs = (deps.now ?? (() => Date.now()))();
+    const windowDays = deps.windowDays ?? DEFAULT_WINDOW_DAYS;
+    const since = new Date(nowMs - windowDays * 24 * 60 * 60 * 1000).toISOString();
+    const startingWeights = deps.startingWeights ?? DEFAULT_STARTING_WEIGHTS;
+    const diffs = [];
+    for (const dimension of ['SA-1', 'SA-2']) {
+        const existing = deps.stateStore.getSaPhaseWeights(dimension);
+        const current = existing
+            ? { wStructural: existing.wStructural, wLlm: existing.wLlm }
+            : startingWeights;
+        const structural = deps.feedback.structuralPrecision({ dimension, since });
+        const llm = deps.feedback.llmPrecision({ dimension, since });
+        const precision = {
+            structural: structural.precision,
+            llm: llm.precision,
+        };
+        const next = computePhase3Weights({
+            current,
+            precision,
+            shiftSize: deps.shiftSize,
+        });
+        const changed = !weightsEqual(current, next) || !existing; /* first-run write */
+        if (changed) {
+            deps.stateStore.upsertSaPhaseWeights({
+                dimension,
+                wStructural: next.wStructural,
+                wLlm: next.wLlm,
+            });
+        }
+        diffs.push({
+            dimension,
+            precision,
+            previous: current,
+            next,
+            // `changed` is true when we actually wrote: either the weight pair
+            // shifted, OR this was the mandatory first-run initialisation.
+            changed,
+        });
+    }
+    return { diffs };
+}
+function weightsEqual(a, b) {
+    return Math.abs(a.wStructural - b.wStructural) < 1e-9 && Math.abs(a.wLlm - b.wLlm) < 1e-9;
+}
+// ── Diff rendering (for CLI) ─────────────────────────────────────────
+export function renderCalibrationDiff(result) {
+    const lines = [];
+    lines.push('SA phase-weight calibration diff');
+    lines.push('--------------------------------');
+    for (const d of result.diffs) {
+        lines.push(`${d.dimension}:`);
+        lines.push(`  previous : w_structural=${d.previous.wStructural.toFixed(3)}  w_llm=${d.previous.wLlm.toFixed(3)}`);
+        lines.push(`  next     : w_structural=${d.next.wStructural.toFixed(3)}  w_llm=${d.next.wLlm.toFixed(3)}`);
+        lines.push(`  precision: structural=${(d.precision.structural * 100).toFixed(1)}%  llm=${(d.precision.llm * 100).toFixed(1)}%`);
+        lines.push(`  changed  : ${d.changed ? 'yes' : 'no'}`);
+    }
+    return lines.join('\n');
+}
+//# sourceMappingURL=auto-calibrate.js.map

package/dist/sa-scoring/c1-sa2-computable.d.ts

@@ -0,0 +1,42 @@
+/**
+ * C1 — SA-2 computable component (RFC-0008 v4 §5.2).
+ *
+ * SA-2 ("soul alignment with design system") has two halves:
+ *   - Computable: deterministic formula over DSB status fields
+ *   - LLM: structured assessment of principle coverage (M5)
+ *
+ * This module implements the computable half only. LLM is returned as
+ * `null` until M5 (AISDLC-59/60) replaces it.
+ *
+ * Formula (§5.2):
+ *   computableComponent = 0.3 × tokenCompliance + 0.2 × catalogHealth
+ *
+ * Where `tokenCompliance` and `catalogHealth` are normalized to [0, 1]
+ * from the DSB's published status.
+ */
+import type { DesignIntentDocument, DesignSystemBinding } from '@ai-sdlc/reference';
+export interface Sa2ComputableResult {
+    /** Normalized token-compliance value in [0, 1]. */
+    tokenCompliance: number;
+    /** Normalized catalog-health coverage in [0, 1]. */
+    catalogHealth: number;
+    /** 0.3 × tokenCompliance + 0.2 × catalogHealth. */
+    computableComponent: number;
+    /** LLM component — filled by M5. Always `null` in Phase 1. */
+    llmComponent: null;
+}
+/**
+ * Compute the SA-2 computable half from a DID and its resolved DSB.
+ *
+ * Returns `undefined` (caller falls back to label-based `soulAlignment`)
+ * when:
+ *   - `dsb` is undefined, OR
+ *   - Neither `tokenCompliance.currentCoverage` nor `catalogHealth.coveragePercent`
+ *     is present on the DSB status (can't compute either term).
+ *
+ * The DID is accepted for API symmetry and future extension (e.g. when
+ * individual principles select which DSB metrics to include); §5.2
+ * itself only reads DSB status.
+ */
+export declare function computeSa2Computable(did: DesignIntentDocument, dsb: DesignSystemBinding | undefined): Sa2ComputableResult | undefined;
+//# sourceMappingURL=c1-sa2-computable.d.ts.map

package/dist/sa-scoring/c1-sa2-computable.js

@@ -0,0 +1,59 @@
+/**
+ * C1 — SA-2 computable component (RFC-0008 v4 §5.2).
+ *
+ * SA-2 ("soul alignment with design system") has two halves:
+ *   - Computable: deterministic formula over DSB status fields
+ *   - LLM: structured assessment of principle coverage (M5)
+ *
+ * This module implements the computable half only. LLM is returned as
+ * `null` until M5 (AISDLC-59/60) replaces it.
+ *
+ * Formula (§5.2):
+ *   computableComponent = 0.3 × tokenCompliance + 0.2 × catalogHealth
+ *
+ * Where `tokenCompliance` and `catalogHealth` are normalized to [0, 1]
+ * from the DSB's published status.
+ */
+/**
+ * Compute the SA-2 computable half from a DID and its resolved DSB.
+ *
+ * Returns `undefined` (caller falls back to label-based `soulAlignment`)
+ * when:
+ *   - `dsb` is undefined, OR
+ *   - Neither `tokenCompliance.currentCoverage` nor `catalogHealth.coveragePercent`
+ *     is present on the DSB status (can't compute either term).
+ *
+ * The DID is accepted for API symmetry and future extension (e.g. when
+ * individual principles select which DSB metrics to include); §5.2
+ * itself only reads DSB status.
+ */
+export function computeSa2Computable(did, dsb) {
+    void did;
+    if (!dsb?.status)
+        return undefined;
+    const rawTokenCoverage = dsb.status.tokenCompliance?.currentCoverage;
+    const rawCatalogCoverage = dsb.status.catalogHealth?.coveragePercent;
+    if (rawTokenCoverage === undefined && rawCatalogCoverage === undefined) {
+        return undefined;
+    }
+    const tokenCompliance = normalizeCoverage(rawTokenCoverage);
+    const catalogHealth = normalizeCoverage(rawCatalogCoverage);
+    const computableComponent = 0.3 * tokenCompliance + 0.2 * catalogHealth;
+    return {
+        tokenCompliance,
+        catalogHealth,
+        computableComponent,
+        llmComponent: null,
+    };
+}
+/**
+ * Normalize a coverage value to [0, 1]. Accepts percentages (0–100) or
+ * ratios (0–1). Missing values are treated as 0.
+ */
+function normalizeCoverage(value) {
+    if (value === undefined || Number.isNaN(value))
+        return 0;
+    const clamped = value > 1 ? value / 100 : value;
+    return Math.min(1, Math.max(0, clamped));
+}
+//# sourceMappingURL=c1-sa2-computable.js.map

package/dist/sa-scoring/composite.d.ts

@@ -0,0 +1,107 @@
+/**
+ * SA-1 / SA-2 composite (RFC-0008 Addendum B §B.7).
+ *
+ * Combines Layer 1 deterministic results, Layer 2 BM25 structural
+ * scores, and Layer 3 LLM structured assessments into the two
+ * soul-alignment dimensions used by the admission composite.
+ *
+ * SA-1 per §B.7.1:
+ *   hard gate: scopeGate core → SA-1 = 0.0 (STOP)
+ *   coreConflictPenalty    = min(0.8, coreViolationCount × 0.4)
+ *   evolvingConflictPenalty = min(0.3, evolvingViolationCount × 0.1)
+ *   conflictPenalty        = 1.0 − coreConflictPenalty − evolvingConflictPenalty
+ *   subtleMult             = 0.5 if any high-severity conflict, else 1.0
+ *   blended                = w_s × domainRelevance + w_l × domainIntent × subtleMult
+ *   SA-1                   = blended × conflictPenalty
+ *
+ * SA-2 per corrected §B.7.2 (CR-1 — no self-multiplication):
+ *   computableScore       = 0.3 × tokenCompliance + 0.2 × catalogHealth
+ *   designConflictPenalty = 1.0 − min(0.6, coreAp × 0.3 + evolvingAp × 0.1)
+ *   llmTerm               = w_l × principleAlignment × subtleMult
+ *   blendedScore          = w_s × principleCoverage + llmTerm
+ *   llmComponent          = blendedScore × designConflictPenalty
+ *   SA-2                  = computableScore + 0.5 × llmComponent
+ *
+ * Phase weights (§B.7.3):
+ *   2a shadow      → (0, 0)      — computed but not used in ranking
+ *   2b blended     → (0.20, 0.80)
+ *   2c calibrating → (0.35, 0.65)
+ *   3 calibrated   → flywheel-driven; w_structural floored at 0.20 (CR-2)
+ */
+import type { SubtleConflict, SubtleDesignConflict } from './layer3-llm.js';
+export type SaPhase = '2a' | '2b' | '2c' | '3';
+export interface PhaseWeights {
+    wStructural: number;
+    wLlm: number;
+}
+/** CR-2: Phase 3 must never drop w_structural below this floor. */
+export declare const W_STRUCTURAL_FLOOR = 0.2;
+export declare function getPhaseWeights(phase: SaPhase, calibrated?: PhaseWeights): PhaseWeights;
+export interface Sa1Inputs {
+    /** True when Layer 1 scope gate flagged a core out-of-scope hit. */
+    hardGated: boolean;
+    coreViolationCount: number;
+    evolvingViolationCount: number;
+    /** Layer 2 SA-1 domainRelevance in [0, 1]. */
+    domainRelevance: number;
+    /** Layer 3 SA-1 domainIntent in [0, 1] (already confidence-filtered). */
+    domainIntent: number;
+    /** Layer 3 SA-1 subtle conflicts (already confidence-filtered). */
+    subtleConflicts: SubtleConflict[];
+}
+export interface Sa2Inputs {
+    /** From DSB status, normalized to [0, 1]. */
+    tokenCompliance: number;
+    /** From DSB status, normalized to [0, 1]. */
+    catalogHealth: number;
+    /** Layer 2 SA-2 principleCoverage (weighted mean) in [0, 1]. */
+    principleCoverage: number;
+    /** Layer 3 SA-2 principleAlignment in [0, 1] (confidence-filtered). */
+    principleAlignment: number;
+    /** Count of core-classified design anti-pattern hits. */
+    coreDesignAntiPatternCount: number;
+    /** Count of evolving-classified design anti-pattern hits. */
+    evolvingDesignAntiPatternCount: number;
+    /** Layer 3 SA-2 subtle design conflicts (confidence-filtered). */
+    subtleDesignConflicts: SubtleDesignConflict[];
+}
+export interface Sa1Result {
+    sa1: number;
+    hardGated: boolean;
+    /** Structural contribution: w_s × domainRelevance. */
+    structuralContribution: number;
+    /** LLM contribution: w_l × domainIntent × subtleMult. */
+    llmContribution: number;
+    blended: number;
+    conflictPenalty: number;
+    subtleMult: number;
+}
+export interface Sa2Result {
+    sa2: number;
+    computableScore: number;
+    structuralContribution: number;
+    llmContribution: number;
+    blendedScore: number;
+    designConflictPenalty: number;
+    subtleMult: number;
+    llmComponent: number;
+}
+export interface SoulAlignmentResult {
+    phase: SaPhase;
+    weights: PhaseWeights;
+    /** True for Phase 2a — consumers must NOT use sa1/sa2 in ranking. */
+    shadowMode: boolean;
+    sa1: Sa1Result;
+    sa2: Sa2Result;
+}
+export declare function computeSa1(inputs: Sa1Inputs, weights: PhaseWeights): Sa1Result;
+export declare function computeSa2(inputs: Sa2Inputs, weights: PhaseWeights): Sa2Result;
+export interface SoulAlignmentInput {
+    phase: SaPhase;
+    /** Required for Phase 3 if calibrated weights differ from the 2c default. */
+    calibratedWeights?: PhaseWeights;
+    sa1: Sa1Inputs;
+    sa2: Sa2Inputs;
+}
+export declare function computeSoulAlignment(input: SoulAlignmentInput): SoulAlignmentResult;
+//# sourceMappingURL=composite.d.ts.map

package/dist/sa-scoring/composite.js

@@ -0,0 +1,139 @@
+/**
+ * SA-1 / SA-2 composite (RFC-0008 Addendum B §B.7).
+ *
+ * Combines Layer 1 deterministic results, Layer 2 BM25 structural
+ * scores, and Layer 3 LLM structured assessments into the two
+ * soul-alignment dimensions used by the admission composite.
+ *
+ * SA-1 per §B.7.1:
+ *   hard gate: scopeGate core → SA-1 = 0.0 (STOP)
+ *   coreConflictPenalty    = min(0.8, coreViolationCount × 0.4)
+ *   evolvingConflictPenalty = min(0.3, evolvingViolationCount × 0.1)
+ *   conflictPenalty        = 1.0 − coreConflictPenalty − evolvingConflictPenalty
+ *   subtleMult             = 0.5 if any high-severity conflict, else 1.0
+ *   blended                = w_s × domainRelevance + w_l × domainIntent × subtleMult
+ *   SA-1                   = blended × conflictPenalty
+ *
+ * SA-2 per corrected §B.7.2 (CR-1 — no self-multiplication):
+ *   computableScore       = 0.3 × tokenCompliance + 0.2 × catalogHealth
+ *   designConflictPenalty = 1.0 − min(0.6, coreAp × 0.3 + evolvingAp × 0.1)
+ *   llmTerm               = w_l × principleAlignment × subtleMult
+ *   blendedScore          = w_s × principleCoverage + llmTerm
+ *   llmComponent          = blendedScore × designConflictPenalty
+ *   SA-2                  = computableScore + 0.5 × llmComponent
+ *
+ * Phase weights (§B.7.3):
+ *   2a shadow      → (0, 0)      — computed but not used in ranking
+ *   2b blended     → (0.20, 0.80)
+ *   2c calibrating → (0.35, 0.65)
+ *   3 calibrated   → flywheel-driven; w_structural floored at 0.20 (CR-2)
+ */
+/** CR-2: Phase 3 must never drop w_structural below this floor. */
+export const W_STRUCTURAL_FLOOR = 0.2;
+export function getPhaseWeights(phase, calibrated) {
+    switch (phase) {
+        case '2a':
+            return { wStructural: 0, wLlm: 0 };
+        case '2b':
+            return { wStructural: 0.2, wLlm: 0.8 };
+        case '2c':
+            return { wStructural: 0.35, wLlm: 0.65 };
+        case '3': {
+            if (!calibrated)
+                return { wStructural: 0.35, wLlm: 0.65 };
+            const wStructural = Math.max(W_STRUCTURAL_FLOOR, calibrated.wStructural);
+            // wLlm is whatever is left after clamping — keeps the pair summing to 1.0.
+            const wLlm = Math.max(0, 1 - wStructural);
+            return { wStructural, wLlm };
+        }
+    }
+}
+// ── Helpers ──────────────────────────────────────────────────────────
+function clamp01(value) {
+    if (Number.isNaN(value))
+        return 0;
+    return Math.min(1, Math.max(0, value));
+}
+function hasHighSeverity(conflicts) {
+    return conflicts.some((c) => c.severity === 'high');
+}
+function normalizeCoverage(value) {
+    if (value === undefined || Number.isNaN(value))
+        return 0;
+    const clamped = value > 1 ? value / 100 : value;
+    return clamp01(clamped);
+}
+// ── SA-1 ─────────────────────────────────────────────────────────────
+export function computeSa1(inputs, weights) {
+    // Hard gate: core out-of-scope match forces SA-1 = 0 irrespective of
+    // Layer 2/3 output (§B.7.1 STOP condition).
+    if (inputs.hardGated) {
+        return {
+            sa1: 0,
+            hardGated: true,
+            structuralContribution: 0,
+            llmContribution: 0,
+            blended: 0,
+            conflictPenalty: 0,
+            subtleMult: 1,
+        };
+    }
+    const coreConflictPenalty = Math.min(0.8, inputs.coreViolationCount * 0.4);
+    const evolvingConflictPenalty = Math.min(0.3, inputs.evolvingViolationCount * 0.1);
+    const conflictPenalty = Math.max(0, 1 - coreConflictPenalty - evolvingConflictPenalty);
+    const subtleMult = hasHighSeverity(inputs.subtleConflicts) ? 0.5 : 1.0;
+    const structuralContribution = weights.wStructural * clamp01(inputs.domainRelevance);
+    const llmContribution = weights.wLlm * clamp01(inputs.domainIntent) * subtleMult;
+    const blended = structuralContribution + llmContribution;
+    const sa1 = clamp01(blended * conflictPenalty);
+    return {
+        sa1,
+        hardGated: false,
+        structuralContribution,
+        llmContribution,
+        blended,
+        conflictPenalty,
+        subtleMult,
+    };
+}
+// ── SA-2 ─────────────────────────────────────────────────────────────
+export function computeSa2(inputs, weights) {
+    const tc = normalizeCoverage(inputs.tokenCompliance);
+    const ch = normalizeCoverage(inputs.catalogHealth);
+    // RFC §B.7.2: computableScore tops out at 0.5 by design — it's half
+    // the final SA-2 score. The other half comes from `0.5 × llmComponent`
+    // below, so perfect inputs on both layers yield SA-2 = 1.0. See the
+    // worked example in composite.test.ts: tc=0.88, ch=0.95 → 0.454.
+    const computableScore = 0.3 * tc + 0.2 * ch;
+    const rawPenalty = inputs.coreDesignAntiPatternCount * 0.3 + inputs.evolvingDesignAntiPatternCount * 0.1;
+    const designConflictPenalty = Math.max(0, 1 - Math.min(0.6, rawPenalty));
+    const subtleMult = hasHighSeverity(inputs.subtleDesignConflicts) ? 0.5 : 1.0;
+    const structuralContribution = weights.wStructural * clamp01(inputs.principleCoverage);
+    const llmContribution = weights.wLlm * clamp01(inputs.principleAlignment) * subtleMult;
+    const blendedScore = structuralContribution + llmContribution;
+    const llmComponent = blendedScore * designConflictPenalty;
+    const sa2 = clamp01(computableScore + 0.5 * llmComponent);
+    return {
+        sa2,
+        computableScore,
+        structuralContribution,
+        llmContribution,
+        blendedScore,
+        designConflictPenalty,
+        subtleMult,
+        llmComponent,
+    };
+}
+export function computeSoulAlignment(input) {
+    const weights = getPhaseWeights(input.phase, input.calibratedWeights);
+    const sa1 = computeSa1(input.sa1, weights);
+    const sa2 = computeSa2(input.sa2, weights);
+    return {
+        phase: input.phase,
+        weights,
+        shadowMode: input.phase === '2a',
+        sa1,
+        sa2,
+    };
+}
+//# sourceMappingURL=composite.js.map