export interface AssayConfig {
    projectName: string;
    description: string;
    techStack: string;
    targetAudience: string;
    createdAt: string;
    /** Phase 2 tournament regeneration: number of candidates per regenerate (default 1 = off). */
    tournamentSize?: number;
}
export type HallucinationType = 'tos' | 'api-docs' | 'user-manual';
export interface HallucinationMeta {
    type: HallucinationType;
    iteration: number;
    model: string;
    inputTokens: number;
    outputTokens: number;
    sectionCount: number;
    estimatedClaims: number;
    generatedAt: string;
    durationMs: number;
}
export type ClaimCategory = 'data-privacy' | 'security' | 'functionality' | 'operational' | 'legal';
export type ClaimSeverity = 'critical' | 'high' | 'medium' | 'low';
export interface Claim {
    id: string;
    section: string;
    category: ClaimCategory;
    severity: ClaimSeverity;
    text: string;
    testable: boolean;
}
export interface ExtractionResult {
    iteration: number;
    documentType: string;
    claims: Claim[];
    totalClaims: number;
    testableClaims: number;
    extractedAt: string;
}
export interface ClaimSuppression {
    claimId: string;
    file: string;
    claim: string;
    reason: string;
    suppressedAt: string;
    suppressedBy: 'manual' | 'pattern';
}
export interface OverridesConfig {
    suppressions: ClaimSuppression[];
    gapSuppressions?: import('./lib/intent-types.js').IntentGapSuppression[];
}
export type Verdict = 'PASS' | 'PARTIAL' | 'FAIL' | 'N/A' | 'UNVERIFIABLE';
export interface Evidence {
    file: string;
    lineNumber?: number;
    snippet: string;
    confidence: number;
}
export interface ClaimVerification {
    claimId: string;
    claim: string;
    verdict: Verdict;
    evidence: Evidence[];
    reasoning: string;
    /** Set when the verdict depends on code the verifier was not given — describes the missing file/module. */
    missing?: string;
    verification_method?: 'formal' | 'llm';
    formal_override?: {
        original_llm_verdict: Verdict;
        formal_verdict: 'PASS' | 'FAIL';
        reason: string;
    };
    /** Set by the cross-flow contradiction check: the code deliberately implements a sibling flow's mechanism, so this FAIL/PARTIAL is a spec error (intent drift), not a code defect. Drifted claims are excluded from the bug list and scoring. */
    intent_drift?: {
        contradictingFlowId: string;
        contradictingFlowName: string;
        reason: string;
    };
    /** Set by the report-time triage pass: whether this bug is a genuine code defect or a spec/intent mismatch. Drives which fix prompt is generated. */
    classification?: {
        verdict: 'real-defect' | 'spec-drift' | 'uncertain';
        rationale: string;
    };
}
export interface VerificationReport {
    iteration: number;
    codebasePath: string;
    verdicts: {
        pass: number;
        partial: number;
        fail: number;
        na: number;
        unverifiable: number;
    };
    verifications: ClaimVerification[];
    generatedAt: string;
}
export type RemediationAction = 'add' | 'modify' | 'remove' | 'configure';
export interface RemediationTask {
    id: string;
    claimId: string;
    verdict: 'FAIL' | 'PARTIAL';
    severity: ClaimSeverity;
    category: ClaimCategory;
    title: string;
    description: string;
    action: RemediationAction;
    targetFiles: string[];
    estimatedEffort: 'trivial' | 'small' | 'medium' | 'large';
    codeGuidance: string;
}
export interface RemediationPlan {
    iteration: number;
    codebasePath: string;
    currentScore: number;
    targetScore: number;
    totalTasks: number;
    tasksByVerdict: {
        fail: number;
        partial: number;
    };
    tasksBySeverity: {
        critical: number;
        high: number;
        medium: number;
        low: number;
    };
    tasks: RemediationTask[];
    generatedAt: string;
    inputTokens: number;
    outputTokens: number;
    durationMs: number;
}
export type SpecCategory = 'correctness' | 'security' | 'performance' | 'error-handling' | 'edge-case' | 'type-safety';
/** A formal specification that generated code must satisfy */
export interface CodeSpec {
    id: string;
    category: SpecCategory;
    severity: ClaimSeverity;
    description: string;
    assertion: string;
    rationale: string;
}
export interface SpecSynthesisResult {
    task: string;
    language: string;
    specs: CodeSpec[];
    totalSpecs: number;
    synthesizedAt: string;
    inputTokens: number;
    outputTokens: number;
}
export type ConstraintType = 'must' | 'must-not' | 'prefer';
export type ConstraintSource = 'benchmark' | 'spec' | 'domain';
/** A constraint that guides code generation */
export interface GenerationConstraint {
    id: string;
    type: ConstraintType;
    description: string;
    pattern?: string;
    source: ConstraintSource;
}
export interface ConstraintSet {
    task: string;
    constraints: GenerationConstraint[];
    totalConstraints: number;
    generatedAt: string;
    inputTokens: number;
    outputTokens: number;
}
export type SelfVerificationStatus = 'satisfied' | 'partial' | 'unsatisfied' | 'unknown';
export interface SelfVerificationResult {
    specId: string;
    status: SelfVerificationStatus;
    reasoning: string;
}
/** The output of guided generation */
export interface GeneratedCode {
    task: string;
    code: string;
    language: string;
    specs: CodeSpec[];
    constraints: GenerationConstraint[];
    selfVerification: SelfVerificationResult[];
    satisfiedCount: number;
    totalSpecs: number;
    generatedAt: string;
    inputTokens: number;
    outputTokens: number;
}
/** Full reverse pipeline result */
export interface ReverseAssayResult {
    task: string;
    language: string;
    specSynthesis: SpecSynthesisResult;
    constraintSet: ConstraintSet;
    generatedCode: GeneratedCode;
    totalInputTokens: number;
    totalOutputTokens: number;
    totalDurationMs: number;
}
export interface RouteInventoryItem {
    path: string;
    component: string;
    domain: string;
    guard?: string;
    roles?: string[];
    tables?: string[];
}
export interface TableInventoryItem {
    name: string;
    domain: string;
    columns: string[];
    relationships: string[];
}
export interface PermissionInventoryItem {
    system: string;
    codes: string[];
    roles: string[];
    conflicts?: string[];
}
export interface AssessmentInventory {
    routes: RouteInventoryItem[];
    tables: TableInventoryItem[];
    permissions: PermissionInventoryItem[];
}
export interface RouteRequirement {
    id: string;
    route: string;
    domain: string;
    component: string;
    guard?: string;
    roles: string[];
    tables: string[];
    behaviors: string[];
    scaffoldingFlags: string[];
}
export interface AssessmentConfig {
    targetPath: string;
    publish: boolean;
    apiUrl: string;
    domains?: string[];
    concurrency: number;
}
export interface RouteAssessmentResult {
    requirement: RouteRequirement;
    claims: Claim[];
    verifications: ClaimVerification[];
    bugs: ClaimVerification[];
}
export interface AssessmentResult {
    id: string;
    repoName: string;
    repoUrl: string;
    frameworks: string[];
    totalRoutes: number;
    totalClaims: number;
    verdicts: {
        pass: number;
        partial: number;
        fail: number;
        na: number;
        unverifiable: number;
    };
    bugs: {
        critical: number;
        high: number;
        medium: number;
        low: number;
    };
    score: number;
    executiveSummary: string;
    routeResults: RouteAssessmentResult[];
    createdAt: string;
    completedAt: string;
    formalCoverage?: {
        formalClaimsVerified: number;
        llmClaimsVerified: number;
        totalClaims: number;
        formalPercent: number;
        formalOverrides?: number;
        disagreements?: number;
    };
    inputTokens: number;
    outputTokens: number;
}
export interface VulnerabilityTemplate {
    id: string;
    name: string;
    cwe: string;
    filePatterns: string[];
    triagePrompt: string;
    deepDivePrompt: string;
    knownBypasses: string[];
    specReferences: string[];
    severityRange: [string, string];
    negativePatterns?: string[];
    minMatchScore?: number;
}
export interface HuntHypothesis {
    id: number;
    templateId: string;
    file: string;
    line?: number;
    confidence: 'high' | 'medium' | 'low';
    summary: string;
    attackerControl: string;
    impact: string;
}
export interface HuntFinding {
    hypothesisId: number;
    templateId: string;
    file: string;
    line?: number;
    cwe: string;
    severity: 'critical' | 'high' | 'medium' | 'low';
    title: string;
    attackScenario: string;
    reproductionSteps: string;
    evidence: string;
    recommendation: string;
    confirmed: boolean;
}
export interface HuntState {
    scannedAt: string;
    path: string;
    fileHashes: Record<string, string>;
    filesScanned: number;
    hypotheses: HuntHypothesis[];
    findings: HuntFinding[];
}