import {
  enrichAdmissionInput,
  scoreIssueForAdmission,
  scoreSoulAlignment,
  HttpDepparseClient,
  loadConfigAsync,
  resolveRepoRoot,
  StateStore,
} from '@ai-sdlc/orchestrator';

const workDir = await resolveRepoRoot();
const config = await loadConfigAsync(`${workDir}/.ai-sdlc`);
const did = config.designIntentDocuments?.[0];
const dsb = config.designSystemBindings?.[0];
const stateStore = StateStore.open(`${workDir}/.ai-sdlc/state.db`);

const enriched = enrichAdmissionInput(input, {
  stateStore,
  designSystemBinding: dsb,
  designIntentDocument: did,
  codeArea: 'components/Button.tsx',
});

const result = scoreIssueForAdmission(enriched, {
  minimumScore: 0.05,
  minimumConfidence: 0.2,
});

console.log(result.score.composite);     // SA × D-pi × ER × (1 + HC)
console.log(result.pillarBreakdown);     // product / design / engineering
console.log(result.pillarBreakdown.tensions); // [TensionFlag, ...]

function enrichAdmissionInput(
  input: AdmissionInput,
  ctx: EnrichmentContext,
): AdmissionInput;

type LifecyclePhase = 'preDesignSystem' | 'catalogBootstrap' | 'postDesignSystem';

P_admission = SA × D-pi_adjusted × ER × (1 + HC)

where  D-pi_adjusted = rawDP × (1 − defectRiskFactor)
       ER            = min(baseER × autonomyFactor, designSystemReadiness)
       baseER        = 1 − complexity / 10
       HC            = tanh(0.2×exp + 0.45×con + 0.25×dec + 0.10×design)

interface AdmissionCompositeOptions {
  /** Replaces the label-based heuristic — typically a Phase 2b/2c/3 SA-1 score. */
  soulAlignmentOverride?: number;
}

function computeAdmissionComposite(
  input: AdmissionInput,
  config?: PriorityConfig,
  options?: AdmissionCompositeOptions,
): AdmissionComposite;

type PillarName = 'product' | 'design' | 'engineering';

interface PillarContribution {
  pillar: PillarName;
  governedDimensions: string[];
  signal: number;            // [0, 1]
  interpretation: string;    // e.g. "strong Design signal"
}

interface PillarBreakdown {
  product: PillarContribution;
  design: PillarContribution;
  engineering: PillarContribution;
  shared: SharedDimensions;
  tensions: TensionFlag[];
}

interface ScoreSoulAlignmentInput {
  issueText: string;
  did: DesignIntentDocument;
  dsb?: DesignSystemBinding;
  phase: '2a' | '2b' | '2c' | '3';
  calibratedWeights?: PhaseWeights;
  observedMetrics?: Record<string, number>;
  issueNumber?: number;
}

interface ScoreSoulAlignmentDeps {
  depparse: DepparseClient;
  llm: LLMClient;
  stateStore?: StateStore;
  compiledDid?: CompiledDid;
}

interface SoulAlignmentScoringResult {
  sa1: number;                 // final SA-1 (0 in shadow mode)
  sa2: number;                 // final SA-2 (0 in shadow mode)
  composite: SoulAlignmentResult;
  layer1: DeterministicScoringResult;
  layer2: { domainRelevance; principleCoverage; };
  layer3?: LLMScoringResult;    // absent when layer1.hardGated
  shadowMode: boolean;
  phase: SaPhase;
  weights: PhaseWeights;
}

hardGated → 0
otherwise:
  blended         = wStructural × domainRelevance + wLlm × domainIntent × subtleMult
  conflictPenalty = max(0, 1 − coreCount × 0.4 − evolvingCount × 0.1)
  SA-1            = clamp01(blended × conflictPenalty)

computableScore       = 0.3 × tokenCompliance + 0.2 × catalogHealth   // up to 0.5
blendedScore          = wStructural × principleCoverage + wLlm × principleAlignment × subtleMult
designConflictPenalty = max(0, 1 − min(0.6, coreAp × 0.3 + evolvingAp × 0.1))
llmComponent          = blendedScore × designConflictPenalty
SA-2                  = clamp01(computableScore + 0.5 × llmComponent)

function compileDid(did: DesignIntentDocument): CompiledDid;

new HttpDepparseClient({
  baseUrl: 'http://depparse:8000',  // MUST be http: or https:
  timeoutMs: 5_000,
  retries: 1,
  fetchImpl: fetch,
});

const feedback = new SAFeedbackStore(stateStore);

feedback.record({
  didName: 'acme-did',
  issueNumber: 42,
  dimension: 'SA-1',
  signal: 'accept',
  principal: 'alice',
  category: 'product',
});

feedback.structuralPrecision({ dimension: 'SA-1', since });
feedback.llmPrecision({ since });
feedback.highFalsePositiveCategories({ since }, 3 /* min sample size */);

const result = await autoCalibratePhaseWeights({
  feedback: new SAFeedbackStore(stateStore),
  stateStore,
  windowDays: 90,        // default
  shiftSize: 0.05,       // default
});
console.log(renderCalibrationDiff(result));

import { computeCalibrationCoefficient } from '@ai-sdlc/orchestrator';

const cκ = computeCalibrationCoefficient(category, feedbackEvents);
// 1.0 + (accepts − escalates) / total × 0.3, clamped [0.7, 1.3]

const event = detectSoulDrift('SA-1', {
  stateStore,
  config: {
    meanThreshold: 0.4,
    stddevThreshold: 0.15,
    consecutiveWindows: 3,
    windowDays: 30,
    recoveryMs: 7 × 86_400_000,
  },
  getLastTriggerAt: (dim) => stateStore.getLastDriftTriggerAt(dim),
});

import { handleCoreIdentityChanged } from '@ai-sdlc/orchestrator';

const reshuffled = await handleCoreIdentityChanged(
  { type: 'CoreIdentityChanged', didName: 'acme-did', changedFields: [...], timestamp },
  { getDid, recompileArtifacts, rescoreFullBacklog, flagInFlight },
);
// Emits: BacklogReshuffled (with rescoredItems + inFlightFlagged counts)

# Single issue
ai-sdlc pattern-test \
  --did acme-did \
  --field constraints.no-developer-integration \
  --issue-text "Add inventory sync via webhook for developer integration"

# Whole fixture set
ai-sdlc pattern-test \
  --did acme-did \
  --field constraints.no-developer-integration \
  --issue-set ./.ai-sdlc/sa-exemplars.yaml
# Exits 1 if FP rate > 20%

import { createDesignIntentReconciler } from '@ai-sdlc/reference';

const reconcile = createDesignIntentReconciler({
  getDesignSystemBinding: () => dsb,
  getLastSnapshot: async (didName) => store.getDidSnapshot(didName),
  saveSnapshot: async (didName, snap) => store.saveDidSnapshot(didName, snap),
  countInFlightItems: async (didName) => store.countInFlight(didName),
  onEvent: (e) => bus.emit(e),
});

const result = await reconcile(did);