@codeledger/types 0.7.2 → 0.7.5

package/dist/index.d.ts

@@ -790,6 +790,444 @@ export interface SessionRecord {
     pid: number | null;
     bundle_files: string[];
     status: SessionStatus;
+    /** Git ref (commit SHA) at the time the bundle was activated.
+     *  Used by pr-check and staleness detection as the baseline for
+     *  computing what changed since the session started working. */
+    activation_ref?: string;
+}
+/** A single file-system event detected by Pulse */
+export interface PulseFileEvent {
+    path: string;
+    kind: 'create' | 'modify' | 'delete' | 'rename';
+    timestamp: ISODateTime;
+}
+/** A cluster of related file events forming a working set */
+export interface PulseWorkingSet {
+    files: string[];
+    modules: string[];
+    first_change: ISODateTime;
+    last_change: ISODateTime;
+}
+/** An inferred session from Pulse analysis */
+export interface PulseSession {
+    sessionId: string;
+    candidateIntent: string;
+    touchedFiles: string[];
+    dependencySurface: string[];
+    modules: string[];
+    timestamp: ISODateTime;
+    confidence: number;
+}
+/** Persistent Pulse state stored on disk */
+export interface PulseState {
+    schema_version: 'pulse/v1';
+    sessions: PulseSession[];
+    recentEvents: PulseFileEvent[];
+    lastScanTimestamp: ISODateTime;
+}
+/** An exported symbol entry from the public surface of a file */
+export interface PublicSurfaceEntry {
+    file: string;
+    symbol: string;
+    kind: 'function' | 'interface' | 'type' | 'class' | 'const' | 'enum';
+    signature: string;
+    lineNumber: number;
+}
+/** A session's collected public surface (all exported symbols) */
+export interface SessionPublicSurface {
+    sessionId: string;
+    entries: PublicSurfaceEntry[];
+    extractedAt: string;
+}
+/** A detected change in an exported symbol's signature */
+export interface SignatureChange {
+    symbol: string;
+    file: string;
+    kind: PublicSurfaceEntry['kind'];
+    previousSignature: string;
+    newSignature: string;
+    changeType: 'removal' | 'arity_change' | 'parameter_change' | 'rename' | 'type_change';
+    breaking: boolean;
+}
+/** A semantic conflict detected by Layer D */
+export interface LayerDConflict {
+    affectedSymbol: string;
+    file: string;
+    producerSession: string;
+    consumerSessions: string[];
+    change: SignatureChange;
+    severity: number;
+    description: string;
+}
+/** Aggregate result of Layer D analysis */
+export interface LayerDAnalysis {
+    conflicts: LayerDConflict[];
+    surfacesAnalyzed: number;
+    timestamp: ISODateTime;
+}
+/** Signal types used in conflict severity scoring */
+export type ConflictSignalType = 'exact_file_overlap' | 'direct_dependency' | 'shared_test_surface' | 'branch_divergence' | 'semantic_signature_overlap';
+/** A single conflict signal with its computed weight */
+export interface ConflictSignal {
+    type: ConflictSignalType;
+    weight: number;
+    details: string;
+}
+/** Severity level classification */
+export type ConflictSeverityLevel = 'HIGH' | 'MEDIUM' | 'LOW';
+/** Full severity assessment for a session pair */
+export interface ConflictSeverityAssessment {
+    signals: ConflictSignal[];
+    aggregateScore: number;
+    level: ConflictSeverityLevel;
+    shouldInterrupt: boolean;
+    shouldAdvise: boolean;
+    sessionPair: [string, string];
+}
+/** Per-signal-type weights for severity scoring */
+export interface SeverityWeights {
+    exact_file_overlap: number;
+    direct_dependency: number;
+    shared_test_surface: number;
+    branch_divergence: number;
+    semantic_signature_overlap: number;
+}
+/** Thresholds for severity level classification */
+export interface SeverityThresholds {
+    high: number;
+    medium: number;
+}
+/** Configuration for the severity scoring engine */
+export interface SeverityConfig {
+    weights: SeverityWeights;
+    thresholds: SeverityThresholds;
+}
+/** A soft claim representing advisory file ownership */
+export interface SoftClaim {
+    sessionId: string;
+    actorId: string;
+    timestamp: ISODateTime;
+    touchedFiles: string[];
+    dependencySurface: string[];
+    intentLabel: string;
+    expiresAt: ISODateTime;
+}
+/** Per-file presence information (who is working on what) */
+export interface ClaimPresence {
+    file: string;
+    actors: Array<{
+        actorId: string;
+        sessionId: string;
+        intentLabel: string;
+        timestamp: ISODateTime;
+    }>;
+}
+/** Staleness level for context freshness assessment */
+export type StalenessLevel = 'fresh' | 'low' | 'medium' | 'high';
+/** A file that has changed since the session's activation baseline */
+export interface ShadowChangedFile {
+    path: string;
+    changedBy: string;
+    changeKind: 'added' | 'deleted' | 'renamed' | 'modified';
+    inBundle: boolean;
+    inDependencySurface: boolean;
+    description: string;
+}
+/** A staleness update computed for a session */
+export interface ShadowUpdate {
+    sessionId: string;
+    changedFiles: ShadowChangedFile[];
+    summary: string;
+    computedAt: ISODateTime;
+    stalenessLevel: StalenessLevel;
+}
+/** Warning type for coalescing and dedup */
+export type WarningType = 'file_overlap' | 'severity_assessment' | 'staleness';
+/** A conflict/staleness warning to surface to the user */
+export interface ConflictWarning {
+    sessionId: string;
+    message: string;
+    severity: ConflictSeverityLevel;
+    overlappingFiles: string[];
+    relatedSessions: string[];
+    timestamp: ISODateTime;
+    /** Warning type for coalescing (defaults to 'file_overlap' for backwards compat) */
+    warningType?: WarningType;
+}
+/** Persistent throttle state for warning deduplication */
+export interface WarningThrottleState {
+    schema_version: 'warning-throttle/v1';
+    lastWarnings: Array<{
+        /** Content hash for dedup */
+        hash: string;
+        /** Dedup key (type + session pair) for severity tracking */
+        dedupKey: string;
+        /** Severity when last shown */
+        severity: ConflictSeverityLevel;
+        timestamp: ISODateTime;
+        /** Signal fingerprint for same-signal suppression (v2.5.1+) */
+        fingerprint?: string;
+    }>;
+}
+/** Overall PR readiness status */
+export type PRCheckStatus = 'CLEAN' | 'REVIEW' | 'STALE' | 'CONFLICTED';
+/** Result of a pre-PR freshness check */
+export interface PRCheckResult {
+    status: PRCheckStatus;
+    conflictRisk: ConflictSeverityLevel;
+    staleness: StalenessLevel;
+    /** Human-readable one-line summary */
+    summary: string;
+    /** Top 2-4 specific, high-signal findings */
+    findings: string[];
+    changedFilesSinceStart: string[];
+    overlappingSessions: string[];
+    /** Single best next action (preferred over list) */
+    recommendedAction: string;
+    /** Additional actions if needed */
+    recommendedActions: string[];
+    timestamp: ISODateTime;
+}
+/** Lifecycle state of a Command Capsule */
+export type CapsuleState = 'draft' | 'pending_policy' | 'pending_approval' | 'approved' | 'rejected' | 'executing' | 'completed' | 'failed' | 'revoked';
+/** Specification of the action a capsule governs */
+export interface ActionSpec {
+    operation: string;
+    description: string;
+    targetSystem: string;
+    targets: string[];
+    sideEffects: string[];
+}
+/** A state transition in a capsule's lifecycle */
+export interface CapsuleTransition {
+    from: CapsuleState;
+    to: CapsuleState;
+    trigger: string;
+    actor: string;
+    timestamp: ISODateTime;
+    metadata?: Record<string, unknown>;
+}
+/** A pre- or post-condition on execution */
+export interface ExecutionCondition {
+    name: string;
+    description: string;
+    required: boolean;
+    result?: {
+        passed: boolean;
+        message: string;
+        evaluatedAt: ISODateTime;
+    };
+}
+/** Risk assessment for a capsule */
+export interface CapsuleRiskAssessment {
+    score: number;
+    level: 'low' | 'medium' | 'high' | 'critical';
+    factors: RiskFactor[];
+    assessedAt: ISODateTime;
+}
+/** A single risk factor contributing to the overall score */
+export interface RiskFactor {
+    name: string;
+    weight: number;
+    score: number;
+    description: string;
+}
+/** Configuration for risk scoring weights */
+export interface RiskScoringConfig {
+    scopeWeight: number;
+    failureHistoryWeight: number;
+    sensitivityWeight: number;
+    magnitudeWeight: number;
+    coverageGapWeight: number;
+}
+/** File sensitivity map for risk scoring */
+export interface SensitivityMap {
+    patterns: Array<{
+        glob: string;
+        level: 'low' | 'medium' | 'high' | 'critical';
+    }>;
+}
+/** Execution outcome for a completed capsule */
+export interface CapsuleOutcome {
+    status: 'success' | 'failure';
+    message: string;
+    completedAt: ISODateTime;
+    summary?: string;
+    eclEntryId?: string;
+    testResults?: {
+        passed: number;
+        failed: number;
+        skipped: number;
+    };
+}
+/** An approval requirement derived from policy evaluation */
+export interface ApprovalRequirement {
+    policyId: string;
+    reason: string;
+    approverRole?: string;
+    targets?: string[];
+    ruleName?: string;
+    requiredScope?: string;
+    delegatable?: boolean;
+}
+/** A recorded approval, rejection, or delegation decision */
+export interface ApprovalDecision {
+    policyId: string;
+    decision: 'approved' | 'rejected' | 'delegated';
+    approver: string;
+    reason: string;
+    timestamp: ISODateTime;
+    authorityScope?: string;
+}
+/** The first-class Command Capsule domain object */
+export interface CommandCapsule {
+    id: string;
+    state: CapsuleState;
+    action: ActionSpec;
+    risk: CapsuleRiskAssessment;
+    policyIds: string[];
+    approvalRequirements: ApprovalRequirement[];
+    approvalDecisions: ApprovalDecision[];
+    preconditions: ExecutionCondition[];
+    postconditions: ExecutionCondition[];
+    transitions: CapsuleTransition[];
+    intentSignature?: string;
+    createdBy: string;
+    createdAt: ISODateTime;
+    updatedAt: ISODateTime;
+    outcome?: CapsuleOutcome;
+}
+/** An authority who can approve capsules matching file patterns */
+export interface ApprovalAuthority {
+    id: string;
+    name: string;
+    patterns: string[];
+    role: string;
+    canDelegate: boolean;
+    actorId?: string;
+    scope?: 'any_peer' | 'team_lead' | 'security' | 'owner';
+}
+/** Policy configuration for approval workflow */
+export interface ApprovalPolicyConfig {
+    version: number;
+    enabled: boolean;
+    authorities: ApprovalAuthority[];
+    preventSelfApproval: boolean;
+    maxDelegationDepth: number;
+    approvalThreshold: CapsuleRiskAssessment['level'];
+}
+/** Stage kind in the 7-stage execution timeline */
+export type TimelineStageKind = 'intent' | 'context' | 'policy' | 'approval' | 'execution' | 'outcome' | 'learning';
+/** A single stage in the execution timeline */
+export interface TimelineStage {
+    kind: TimelineStageKind;
+    label: string;
+    timestamp: ISODateTime;
+    sourceType: 'authoritative' | 'derived' | 'synthetic';
+    sourceRef: string;
+    data: Record<string, unknown>;
+}
+/** A full 7-stage execution timeline assembled from a capsule */
+export interface ExecutionTimeline {
+    capsuleId: string;
+    stages: TimelineStage[];
+    assembledAt: ISODateTime;
+    complete: boolean;
+}
+/** A learning signal derived from execution outcome */
+export interface LearningSignal {
+    intentSignature: string;
+    capsuleId: string;
+    direction: 'positive' | 'negative';
+    magnitude: number;
+    factors: string[];
+    recordedAt: ISODateTime;
+}
+/** A recommended policy adjustment from learning feedback */
+export interface PolicyAdjustment {
+    type?: 'tighten' | 'relax' | 'add_rule' | 'remove_rule';
+    target?: string;
+    reason: string;
+    confidence: number;
+    basedOnSignals?: number;
+    ruleId?: string;
+    adjustment?: 'tighten' | 'relax';
+    suggestedChange?: Record<string, unknown>;
+}
+/** Qualitative health rating */
+export type HealthRating = 'EXCELLENT' | 'GOOD' | 'FAIR' | 'POOR' | 'CRITICAL';
+/** Trend direction for a dashboard metric */
+export type TrendDirection = 'improving' | 'stable' | 'degrading';
+/** Computed dashboard metrics (5-component health score) */
+export interface DashboardMetrics {
+    ahs: number;
+    dri: number;
+    eds: number;
+    sts: number;
+    override_frequency: number;
+    overall: number;
+    timestamp: number;
+}
+/** A point-in-time snapshot of dashboard metrics */
+export interface DashboardSnapshot extends DashboardMetrics {
+    snapshot_source: string;
+}
+/** Trend analysis across dashboard metric history */
+export interface DashboardTrends {
+    ahs_trend: TrendDirection;
+    dri_trend: TrendDirection;
+    eds_trend: TrendDirection;
+    sts_trend: TrendDirection;
+    override_trend: TrendDirection;
+    overall_trend: TrendDirection;
+}
+/** Policy domain name */
+export type PolicyDomain = 'discovery' | 'enforcement' | 'source_of_truth' | 'overrides' | 'interventions' | 'dashboard';
+/** Definition of a policy field */
+export interface PolicyFieldDefinition {
+    name: string;
+    type: 'boolean' | 'number' | 'string' | 'string[]';
+    description: string;
+    default_value: unknown;
+    resolution: 'strictest' | 'union' | 'loosest' | 'override';
+}
+/** Definition of a policy domain */
+export interface PolicyDomainDefinition {
+    name: PolicyDomain;
+    description: string;
+    fields: PolicyFieldDefinition[];
+    defaults: Record<string, unknown>;
+}
+/** A validation error in a policy configuration */
+export interface PolicyValidationError {
+    domain: PolicyDomain;
+    field: string;
+    message: string;
+    value?: unknown;
+    severity: 'error' | 'warning';
+}
+/** Result from a real-time policy check during context selection */
+export interface PolicyCheckResult {
+    allowed: boolean;
+    violations: PolicyValidationError[];
+    advisory: string[];
+}
+/** Context provided to real-time policy checks */
+export interface RealtimePolicyContext {
+    task?: string;
+    target_files?: string[];
+    discovery_verdict?: DiscoveryVerdict;
+    confidence?: number;
+    drift?: number;
+}
+/** A single field-level difference between two policies */
+export interface PolicyDiffEntry {
+    domain: PolicyDomain;
+    field: string;
+    base_value: unknown;
+    target_value: unknown;
+    effective_value: unknown;
+    resolution_rule: string;
 }
 /** A checkpoint snapshot saved during a session for resume-after-interruption */
 export interface CheckpointRecord {
@@ -894,6 +1332,39 @@ export interface MustangPolicyV1 {
     block_post_hoc_reads?: boolean;
     /** Review Intelligence configuration (optional, additive) */
     review_intelligence?: ReviewIntelligencePolicyConfig;
+    /** Discovery gate domain settings */
+    discovery?: {
+        auto_run?: boolean;
+        block_on_no_go?: boolean;
+        cache_ttl_seconds?: number;
+    };
+    /** Source-of-truth domain settings */
+    source_of_truth?: {
+        require_stability?: boolean;
+        min_confidence?: number;
+        alert_on_fragmentation?: boolean;
+    };
+    /** Override governance domain settings */
+    overrides?: {
+        require_approval?: boolean;
+        max_depth?: number;
+        audit?: boolean;
+    };
+    /** Intervention engine domain settings */
+    interventions?: {
+        auto_generate?: boolean;
+        min_severity?: string;
+        escalation_enabled?: boolean;
+    };
+    /** Architecture health dashboard domain settings */
+    dashboard?: {
+        collection_enabled?: boolean;
+        snapshot_interval_minutes?: number;
+        alert_thresholds?: {
+            ahs_min?: number;
+            dri_max?: number;
+        };
+    };
 }
 /** Review Intelligence policy configuration (nested under MustangPolicyV1) */
 export interface ReviewIntelligencePolicyConfig {
@@ -916,7 +1387,7 @@ export interface ResolvedPolicyV1 extends MustangPolicyV1 {
     resolved_from: 'hardcoded-defaults' | 'org-default' | 'repo-override';
 }
 /** Stable violation codes — do not invent new ones without spec basis */
-export type ViolationCode = 'LOW_CONFIDENCE' | 'HIGH_DRIFT' | 'DENY_PATH_MATCH' | 'MISSING_TESTS' | 'BUNDLE_TOO_LARGE' | 'INSUFFICIENT_COVERAGE' | 'POST_HOC_READS';
+export type ViolationCode = 'LOW_CONFIDENCE' | 'HIGH_DRIFT' | 'DENY_PATH_MATCH' | 'MISSING_TESTS' | 'BUNDLE_TOO_LARGE' | 'INSUFFICIENT_COVERAGE' | 'POST_HOC_READS' | 'DISCOVERY_STRONG_OVERLAP' | 'DISCOVERY_PROHIBITED_FILE' | 'DISCOVERY_INSERTION_VIOLATION' | 'DISCOVERY_DUPLICATE_DETECTED' | 'DISCOVERY_SYMBOL_GROWTH';
 /** A single policy violation */
 export interface ViolationV1 {
     code: ViolationCode;
@@ -960,6 +1431,10 @@ export interface VerifyReportV1 {
     violations: ViolationV1[];
     /** Review Intelligence results (present when review intelligence is enabled) */
     review_intelligence?: VerifyReviewIntelligenceV1;
+    /** Insertion-point lock violations (present when discovery result is available) */
+    insertion_point_violations?: InsertionPointViolation[];
+    /** Symbol growth report (present when base branch comparison is available) */
+    symbol_growth?: SymbolGrowthReport;
 }
 /** Review Intelligence section of the verify report */
 export interface VerifyReviewIntelligenceV1 {
@@ -1282,68 +1757,687 @@ export interface ReviewConfig {
     /** Whether the gatekeeper hook is enabled. Default: true */
     gatekeeper_enabled: boolean;
 }
-/** Symbol kinds extracted by the SCE symbol graph */
-export type SymbolKind = 'function' | 'class' | 'interface' | 'type' | 'enum' | 'variable';
-/** A single named symbol node in the SCE symbol graph */
+/** Confidence tier for evidence gate findings */
+export type EvidenceTier = 'observed' | 'likely' | 'possible';
+/** Finding type for evidence gate rules */
+export type FindingType = 'unused_code' | 'untested_surface' | 'broken_wiring' | 'dead_dependency' | 'missing_guard' | 'architectural_violation';
+/** Type of required check for evidence gates */
+export type RequiredCheckType = 'grep' | 'ast_reference_check' | 'import_graph_check' | 'test_presence_check' | 'contract_check' | 'routing_check' | 'store_context_check' | 'policy_check';
+/** A single executable check required before surfacing a finding */
+export interface RequiredCheck {
+    id: string;
+    description: string;
+    type: RequiredCheckType;
+    /** Shell command to run; use {target} as a placeholder for the file/scope */
+    command?: string;
+}
+/** An evidence gate rule that must be satisfied before surfacing a finding type */
+export interface EvidenceRule {
+    findingType: FindingType;
+    minimumTier: EvidenceTier;
+    requiredChecks: RequiredCheck[];
+    /** Suppress findings below this tier from output */
+    suppressBelowTier?: EvidenceTier;
+    /** Only surface reviewer-visible findings at or above this tier */
+    reviewerVisibleFromTier?: EvidenceTier;
+}
+/** The full evidence gate ledger */
+export interface EvidenceGateLedger {
+    rules: EvidenceRule[];
+}
+/** How structural invalidation ripples through the dependency graph */
+export interface BlastRadius {
+    dependencyDepth: number;
+    invalidatesScopes?: string[];
+    severity: 'narrow' | 'moderate' | 'wide';
+}
+/** Rule that triggers invalidation of a clean surface */
+export interface InvalidationRule {
+    type: 'file_changed' | 'dependency_changed' | 'test_surface_changed' | 'policy_changed';
+    /** File or module that triggers this invalidation when it changes */
+    target?: string;
+}
+/** Reason a surface was invalidated */
+export interface ValidationInvalidationReason {
+    type: 'file_changed' | 'dependency_changed' | 'test_surface_changed' | 'manual_override';
+    detail: string;
+    detectedAt: string;
+}
+/** A scope that has been validated and is known-clean */
+export interface CleanSurfaceRecord {
+    id: string;
+    scopeType: 'file' | 'module' | 'subsystem';
+    scopeId: string;
+    /** sha256 hex hashes keyed by file path */
+    fileHashes: Record<string, string>;
+    dependencyHash?: string;
+    testSurfaceHash?: string;
+    blastRadius?: BlastRadius;
+    lastValidatedAt: string;
+    validationLevel: 'lint' | 'unit' | 'integration' | 'e2e' | 'mixed';
+    status: 'clean' | 'stale' | 'invalidated';
+    invalidationRules: InvalidationRule[];
+    invalidatedBy?: ValidationInvalidationReason[];
+}
+/** A round of validation that was run */
+export interface ValidationRoundRecord {
+    id: string;
+    timestamp: string;
+    scope: {
+        files?: string[];
+        modules?: string[];
+        subsystems?: string[];
+    };
+    validationLevel: 'lint' | 'unit' | 'integration' | 'e2e' | 'mixed';
+    result: 'pass' | 'fail' | 'partial';
+    outputs?: {
+        testsRun?: string[];
+        failures?: string[];
+        notes?: string[];
+    };
+}
+/** Tracks which surfaces are clean and recent validation rounds */
+export interface DeltaValidationLedger {
+    cleanSurfaces: CleanSurfaceRecord[];
+    validationRounds: ValidationRoundRecord[];
+}
+/** A single meaning for an ontology concept (handles polysemy) */
+export interface OntologyMeaning {
+    id: string;
+    label: string;
+    description: string;
+    relatedConcepts: string[];
+    fileHints: string[];
+    confidenceBase?: number;
+}
+/** An alias that maps a term to a canonical concept id */
+export interface OntologyAlias {
+    term: string;
+    conceptId: string;
+}
+/** A concept in the product ontology */
+export interface OntologyConcept {
+    id: string;
+    displayName: string;
+    description: string;
+    meanings: OntologyMeaning[];
+    relatedConceptIds?: string[];
+    fileHints: string[];
+    moduleHints?: string[];
+    docHints?: string[];
+    /** Prompt the agent should surface when the concept is ambiguous */
+    disambiguationPrompt?: string;
+    recencyBoost?: {
+        lastTouchedAt?: string;
+        boostReason?: string;
+    };
+}
+/** Full product ontology ledger */
+export interface ProductOntologyLedger {
+    concepts: OntologyConcept[];
+    aliases: OntologyAlias[];
+}
+/** A wiring neighborhood describing structural connections around an anchor */
+export interface WiringNeighborhood {
+    id: string;
+    anchor: {
+        type: 'file' | 'module' | 'component' | 'service';
+        id: string;
+    };
+    upstream: string[];
+    downstream: string[];
+    sharedContracts?: string[];
+    relatedStores?: string[];
+    relatedContexts?: string[];
+    relatedTests?: string[];
+    /**
+     * Connections that must not be bypassed or casually rewired.
+     * Changing local logic is fine; these structural links are immutable.
+     */
+    immutableWires?: string[];
+    trustLevel: 'low' | 'medium' | 'high';
+    trustReason?: string;
+    notes?: string[];
+}
+/** Structural trust ledger: wiring neighborhoods for the repo */
+export interface StructuralTrustLedger {
+    neighborhoods: WiringNeighborhood[];
+}
+/** An accepted change that is part of recent repo truth */
+export interface AcceptedChangeRecord {
+    id: string;
+    timestamp: string;
+    title: string;
+    summary: string;
+    concepts: string[];
+    files: string[];
+    modules?: string[];
+    status: 'accepted' | 'shipped' | 'validated';
+    source?: 'commit' | 'pr' | 'manual' | 'session';
+    /** 0..1 — higher = more relevant right now */
+    relevanceScore?: number;
+    ttlDays?: number;
+    evidence?: {
+        commitShas?: string[];
+        prNumbers?: string[];
+        testRounds?: string[];
+    };
+}
+/** An architecture decision record */
+export interface ArchitectureDecisionRecord {
+    id: string;
+    timestamp: string;
+    title: string;
+    decision: string;
+    relatedConcepts: string[];
+    affectedAreas: string[];
+    constraints?: string[];
+    supersedes?: string[];
+    relevanceScore?: number;
+    ttlDays?: number;
+}
+/** A recently introduced feature */
+export interface RecentFeatureRecord {
+    id: string;
+    name: string;
+    introducedAt: string;
+    concepts: string[];
+    fileHints: string[];
+    maturity: 'new' | 'stabilizing' | 'stable';
+    relevanceScore?: number;
+    ttlDays?: number;
+}
+/** Recent accepted truth ledger */
+export interface RecentTruthLedger {
+    acceptedChanges: AcceptedChangeRecord[];
+    architectureDecisions: ArchitectureDecisionRecord[];
+    recentFeatures: RecentFeatureRecord[];
+}
+/** Top-level CodeLedger memory model */
+export interface CodeLedgerMemory {
+    version: '1.0';
+    repoId: string;
+    updatedAt: string;
+    recentTruth: RecentTruthLedger;
+    validation: DeltaValidationLedger;
+    ontology: ProductOntologyLedger;
+    structure: StructuralTrustLedger;
+    evidence: EvidenceGateLedger;
+    lessons?: LessonsLedger;
+    metadata?: {
+        generatorVersion?: string;
+        notes?: string;
+    };
+}
+/** Ontology expansion section in a broker response */
+export interface BrokerOntologyExpansion {
+    concepts: string[];
+    meanings?: string[];
+    disambiguationPrompt?: string;
+}
+/** Recent truth section in a broker response */
+export interface BrokerRecentTruth {
+    highlights: string[];
+    acceptedChangeIds?: string[];
+}
+/** Safe zone section in a broker response */
+export interface BrokerSafeZones {
+    scopes: string[];
+    reason?: string;
+}
+/** Top-level broker response for task context resolution */
+export interface BrokerTaskContextResponse {
+    version: '1.0';
+    taskText: string;
+    normalizedIntent?: {
+        operation?: string;
+        entities?: string[];
+    };
+    ontologyExpansion: BrokerOntologyExpansion;
+    recentTruth: BrokerRecentTruth;
+    safeZones: BrokerSafeZones;
+    relevantFiles: string[];
+    relevantDocs?: string[];
+    preamble: string;
+}
+/** Broker response for validation status of a target */
+export interface BrokerValidationResponse {
+    target: string;
+    status: 'clean' | 'stale' | 'invalidated' | 'unknown';
+    validationLevel?: string;
+    lastValidatedAt?: string;
+    invalidatedBy?: string[];
+    blastRadius?: {
+        dependencyDepth: number;
+        invalidatesScopes?: string[];
+        severity: 'narrow' | 'moderate' | 'wide';
+    };
+}
+/** Broker response for structural neighborhood lookup */
+export interface BrokerNeighborhoodResponse {
+    target: string;
+    upstream: string[];
+    downstream: string[];
+    immutableWires?: string[];
+    relatedContracts?: string[];
+    relatedTests?: string[];
+    trustLevel?: 'low' | 'medium' | 'high';
+    summary?: string;
+}
+/** Broker response for evidence requirements */
+export interface BrokerEvidenceResponse {
+    findingType: string;
+    requiredChecks: Array<{
+        id: string;
+        description: string;
+        type: string;
+        command?: string;
+    }>;
+    minimumTier?: string;
+    reviewerVisibleFromTier?: string;
+}
+/** Broker response for completion state */
+export interface BrokerCompletionResponse {
+    taskId?: string;
+    completionState?: string;
+    verifiedClaims?: string[];
+    remainingUnchecked?: string[];
+    blockers?: string[];
+    summary?: string;
+}
+/** Architecture layer classification for intent decomposition */
+export type ArchitectureLayer = 'types' | 'routes' | 'services' | 'tests' | 'config' | 'infra' | 'models' | 'unknown';
+/** Structured intent object produced by IOLE intent decomposition */
+export interface IntentObject {
+    domain: string;
+    operation: 'bugfix' | 'feature' | 'refactor' | 'test_update' | 'config' | 'unknown';
+    layer: ArchitectureLayer;
+    entities: string[];
+    constraints: string[];
+    category: string;
+    intentConfidence: number;
+    raw_task: string;
+    decomposed_at: string;
+}
+/** Overlap classification from discovery gate */
+export type OverlapClassification = 'FEATURE_ALREADY_EXISTS' | 'STRONG_OVERLAP' | 'PARTIAL_OVERLAP' | 'NO_MATERIAL_OVERLAP';
+/** Implementation posture recommendation from discovery gate */
+export type ImplementationPosture = 'WRAP_EXISTING_SYSTEM' | 'EXTEND_EXISTING_SYSTEM' | 'ADD_ADAPTER_LAYER' | 'BUILD_NEW_CAPABILITY';
+/** Go/no-go verdict from discovery gate */
+export type DiscoveryVerdict = 'NO_GO_ALREADY_EXISTS' | 'GO_EXTENSION_ONLY' | 'GO_GENUINELY_NEW';
+/** A file match found during discovery scanning */
+export interface DiscoveryMatch {
+    file: string;
+    system: string;
+    description: string;
+    similarity: number;
+    overlap: 'direct' | 'indirect';
+    matched_symbols: string[];
+    kind: string;
+    why_relevant: string;
+    centrality: number;
+}
+/** Source of truth identification from discovery */
+export interface DiscoverySourceOfTruth {
+    system: string;
+    path: string;
+    confidence: number;
+    justification: string;
+    competitors: Array<{
+        system: string;
+        path: string;
+        similarity: number;
+    }>;
+    fragmented: boolean;
+}
+/** Blast radius analysis for a discovery target */
+export interface DiscoveryBlastRadius {
+    system: string;
+    path: string;
+    direct_dependents: string[];
+    transitive_dependents: string[];
+    shared_modules: string[];
+    impacted_tests: string[];
+    risk: 'low' | 'medium' | 'high';
+}
+/** Gap analysis from discovery gate */
+export interface DiscoveryGapAnalysis {
+    coverage_estimate: number;
+    missing_capabilities: string[];
+    recommended_extensions: Array<{
+        target: string;
+        description: string;
+    }>;
+    extension_targets: string[];
+    warning: string | null;
+    existing_exports: string[];
+}
+/** Full result from a discovery gate run */
+export interface DiscoveryResult {
+    requested_capability: string;
+    intent: IntentObject;
+    keywords_searched: string[];
+    files_scanned: number;
+    matches: DiscoveryMatch[];
+    related_standards: Array<{
+        helper_name: string;
+        example_paths: string[];
+        usage_count: number;
+    }>;
+    overlap: OverlapClassification;
+    duplication_risk: string;
+    posture: ImplementationPosture;
+    verdict: DiscoveryVerdict;
+    must_reuse: string[];
+    must_not_create: string[];
+    insertion_points: string[];
+    prohibited_files: string[];
+    source_of_truth: DiscoverySourceOfTruth | null;
+    blast_radius: DiscoveryBlastRadius[];
+    gap_analysis: DiscoveryGapAnalysis;
+    duration_ms: number;
+}
+/** An insertion-point lock violation detected during PR verification */
+export interface InsertionPointViolation {
+    file: string;
+    violation_type: 'ghost_file' | 'outside_insertion_point' | 'prohibited_path';
+    severity: 'P1' | 'P2';
+    reason: string;
+    similar_to?: string;
+    shared_symbols?: string[];
+}
+/** Per-file symbol growth entry */
+export interface SymbolGrowthEntry {
+    file: string;
+    added: string[];
+    removed: string[];
+    modified: string[];
+    net: number;
+}
+/** Symbol growth analysis report from PR verification */
+export interface SymbolGrowthReport {
+    total_symbols_added: number;
+    total_symbols_removed: number;
+    total_symbols_modified: number;
+    net_growth: number;
+    scope_creep_detected: boolean;
+    threshold: number;
+    per_file: SymbolGrowthEntry[];
+    api_surface_explosions: string[];
+}
+/** Task type classification for CIC neighborhood selection */
+export type CICTaskType = 'release_pipeline' | 'wizard_ux' | 'ci_change' | 'feature' | 'bugfix' | 'refactor' | 'docs' | 'unknown';
+/** Completion state in the CIC promotion ladder */
+export type CompletionState = 'incomplete' | 'edited' | 'implemented' | 'wired' | 'verified' | 'audited' | 'release_safe';
+/** Type of evidence collected during a CIC run (distinct from EvidenceTier) */
+export type EvidenceType = 'test_result' | 'execution_log' | 'validation_output' | 'ci_pass' | 'build_success' | 'lint_pass';
+/** A single claim made by the agent about what it completed */
+export interface CompletionClaim {
+    id: string;
+    description: string;
+    files: string[];
+    verified: boolean;
+    evidence?: CompletionEvidence[];
+}
+/** Evidence collected to support a completion claim */
+export interface CompletionEvidence {
+    type: EvidenceType;
+    content: string;
+    collected_at: ISODateTime;
+}
+/** A mismatch between what the agent claimed and what exists in the repo */
+export interface RealityMismatch {
+    claim: string;
+    expectedTarget: string;
+    actualDiffPresence: boolean;
+    severity: 'critical' | 'major' | 'minor';
+}
+/** A warning that the agent's summary terms drift from the actual edits */
+export interface SemanticDriftWarning {
+    term: string;
+    expectedConcept: string;
+    actualFiles: string[];
+    detail: string;
+}
+/** An intentional omission declared by the agent */
+export interface IntentionalOmission {
+    id: string;
+    description: string;
+    scope: string[];
+    reason: string;
+}
+/** Result of a self-audit check */
+export interface SelfAuditResult {
+    type: 'claim_vs_repo' | 'doc_consistency' | 'cross_reference' | 'semantic_drift' | 'release_readiness';
+    outcome: 'pass' | 'warn' | 'fail';
+    detail: string;
+}
+/** A surface checked during CIC neighborhood analysis */
+export interface NeighborhoodSurface {
+    name: string;
+    paths: string[];
+    required: boolean;
+    status: 'changed' | 'checked' | 'not_checked' | 'stale' | 'intentionally_skipped';
+    omission_reason?: string;
+}
+/** Assessment of confidence level vs evidence strength */
+export interface ConfidenceAssessment {
+    claimConfidence: 'low' | 'medium' | 'high';
+    evidenceStrength: 'weak' | 'moderate' | 'strong';
+    mismatch: boolean;
+    note?: string;
+}
+/** Full completion record produced by a CIC run */
+export interface CompletionRecord {
+    run_id: string;
+    checked_at: ISODateTime;
+    task: string;
+    taskType: CICTaskType;
+    completionState: CompletionState;
+    claims: CompletionClaim[];
+    diffFiles: string[];
+    neighborhood: NeighborhoodSurface[];
+    audits: SelfAuditResult[];
+    remainingUnchecked: string[];
+    completed: string[];
+    intentionalOmissions?: IntentionalOmission[];
+    confidenceAssessment: ConfidenceAssessment;
+    semanticDriftWarnings?: SemanticDriftWarning[];
+    realityMismatches?: RealityMismatch[];
+    guards?: GuardrailResult[];
+    triggeredLessons?: Array<{
+        lessonId: string;
+        title: string;
+        severity: string;
+        detail: string;
+    }>;
+}
+/** A summary entry appended to the completion history ledger */
+export interface CompletionHistoryEntry {
+    run_id: string;
+    checked_at: ISODateTime;
+    task: string;
+    taskType: CICTaskType;
+    completionState: CompletionState;
+    claim_count: number;
+    verified_claim_count: number;
+    mismatch_count: number;
+    drift_warning_count: number;
+    audit_pass_count: number;
+    audit_fail_count: number;
+}
+/** Category of engineering guardrail */
+export type GuardrailCategory = 'rename_integrity' | 'export_collision' | 'workspace_validation' | 'stale_artifact' | 'release_tag' | 'unused_parameter' | 'adversarial_trigger';
+/** Result of a single guardrail check */
+export interface GuardrailResult {
+    id: string;
+    category: GuardrailCategory;
+    outcome: 'pass' | 'warn' | 'fail';
+    detail: string;
+    remediation?: string;
+    files?: string[];
+}
+/** Input context for guardrail evaluation */
+export interface GuardrailInput {
+    cwd: string;
+    task: string;
+    taskType: CICTaskType;
+    diffFiles: string[];
+    claims: CompletionClaim[];
+}
+/** Aggregated guardrails report */
+export interface GuardrailsReport {
+    guards: GuardrailResult[];
+    /** Number of guards that passed */
+    pass_count: number;
+    /** Number of guards that warned */
+    warn_count: number;
+    /** Number of guards that failed */
+    fail_count: number;
+    /** Whether any guard failed (blocks promotion) */
+    blocks_promotion: boolean;
+}
+/** Lesson category classifying the engineering failure pattern */
+export type LessonCategory = 'rename_safety' | 'export_surface' | 'workspace_scope' | 'artifact_freshness' | 'typing_contract' | 'tsconfig_boundary' | 'branch_delivery' | 'release_integrity' | 'audit_trigger' | 'parameter_safety' | 'golden_path' | 'other';
+/** Lesson verification status — only 'verified' lessons influence CIC blocking */
+export type LessonStatus = 'proposed' | 'verified' | 'deprecated';
+/** Source that originated the lesson */
+export type LessonSource = 'manual' | 'audit' | 'completion' | 'guardrail' | 'session' | 'ci';
+/** Criteria that trigger a lesson when matched against a change set */
+export interface LessonTriggerCriteria {
+    files_changed?: string[];
+    content_contains?: string[];
+    content_not_contains?: string[];
+    file_types?: string[];
+    task_patterns?: string[];
+    tsconfig_conditions?: {
+        cross_package_includes?: boolean;
+        missing_references?: boolean;
+    };
+}
+/** A repo lesson — an encoded engineering failure/success pattern */
+export interface RepoLesson {
+    id: string;
+    title: string;
+    summary: string;
+    category: LessonCategory;
+    severity: 'low' | 'medium' | 'high';
+    status: LessonStatus;
+    source: LessonSource;
+    triggerCriteria: LessonTriggerCriteria;
+    concepts?: string[];
+    taskTypes?: string[];
+    fileHints?: string[];
+    packageHints?: string[];
+    recommendedChecks?: string[];
+    recommendedCommands?: string[];
+    rationale: string;
+    createdAt: string;
+    updatedAt?: string;
+    active: boolean;
+}
+/** Event type for lesson lifecycle tracking */
+export type LessonEventType = 'created' | 'updated' | 'triggered' | 'ignored' | 'escalated' | 'resolved';
+/** A lesson event recording a trigger, escalation, or resolution */
+export interface LessonEvent {
+    id: string;
+    lessonId: string;
+    timestamp: string;
+    eventType: LessonEventType;
+    riskMultiplier: number;
+    detail: string;
+    relatedFiles?: string[];
+}
+/** Full lessons ledger */
+export interface LessonsLedger {
+    lessons: RepoLesson[];
+    events: LessonEvent[];
+}
+/** Release readiness state */
+export type ReleaseState = 'not_ready' | 'ready_conditional' | 'ready' | 'ready_hardened';
+/** Severity of a release finding */
+export type ReleaseFindingSeverity = 'critical' | 'high' | 'medium' | 'low' | 'info';
+/** Category of a release finding */
+export type ReleaseFindingCategory = 'git_integrity' | 'core_tests' | 'full_suite' | 'binary_parity' | 'cli_wiring' | 'docs_alignment' | 'open_loop' | 'workspace_alignment' | 'lesson_stress';
+/** A single finding from a release check */
+export interface ReleaseFinding {
+    id: string;
+    category: ReleaseFindingCategory;
+    severity: ReleaseFindingSeverity;
+    title: string;
+    detail: string;
+    remediation?: string;
+    files?: string[];
+    isBaseline?: boolean;
+}
+/** Per-category confidence scores (0-1) */
+export interface ReleaseCategoryScores {
+    gitIntegrity: number;
+    coreTests: number;
+    fullSuite: number;
+    binaryParity: number;
+    cliWiring: number;
+    docsAlignment: number;
+    openLoopRisk: number;
+    workspaceAlignment: number;
+}
+/** Full release check result */
+export interface ReleaseCheckResult {
+    releaseState: ReleaseState;
+    confidenceScore: number;
+    categoryScores: ReleaseCategoryScores;
+    findings: ReleaseFinding[];
+    verified: string[];
+    remainingUnchecked: string[];
+    blockers: string[];
+    recommendations: string[];
+    knownDebt: ReleaseFinding[];
+    regressions: ReleaseFinding[];
+    shouldBlockCI: boolean;
+    checkedAt: string;
+    version: string;
+}
+export type SymbolKind = 'function' | 'class' | 'interface' | 'type' | 'enum';
 export interface SymbolNode {
-    /** Stable ID: "<file>::<symbolName>" */
     id: string;
-    /** Exported symbol name */
     name: string;
     kind: SymbolKind;
-    /** Absolute file path */
     file: string;
-    /** 1-based source line of the definition */
     line: number;
-    /** Symbols this node imports/depends on (by ID) */
     dependencies: string[];
-    /** Symbols that depend on this node (by ID, populated after full graph build) */
     dependents: string[];
 }
-/** Symbol-level dependency graph produced by the SCE */
 export interface SymbolGraph {
-    /** Map of symbol ID → SymbolNode */
     nodes: Record<string, SymbolNode>;
     file_count: number;
     symbol_count: number;
 }
-/** A single symbol-level slice entry in the MSCS */
 export interface CodeSlice {
     symbol_id: string;
     symbol_name: string;
     symbol_kind: SymbolKind;
     file: string;
     line: number;
-    /** Extracted source lines around the symbol definition */
     excerpt: string;
-    /** Relevance of this symbol to the task keywords [0,1] */
     relevance_score: number;
-    /** IDs of symbols this slice depends on */
     dependency_ids: string[];
 }
-/** Minimal Sufficient Code Slice — output of SCE slice builder */
 export interface MinimalSufficientCodeSlice {
     task_keywords: string[];
-    /** Seed symbol IDs that directly matched task keywords */
     seed_symbols: string[];
     slices: CodeSlice[];
     file_count: number;
     symbol_count: number;
-    /** Maximum dependency depth traversed to build this slice */
     dependency_depth_reached: number;
 }
-/** Stable task intent signature derived from the task prompt */
 export interface IntentSignature {
-    /** SHA-256 truncated to 16 hex chars — stable across sessions for same task */
     hash: string;
     task_normalized: string;
     keywords: string[];
     category: 'bug_fix' | 'feature_add' | 'refactor' | 'test_update' | 'config' | 'unknown';
-    derived_at: ISODateTime;
+    derived_at: string;
 }
-/** Kind of execution failure */
-export type FailureKind = 'test_failure' | 'build_error' | 'type_error' | 'runtime_error' | 'unknown';
-/** Structured failure vector parsed from agent execution output */
+export type FailureKind = 'test_failure' | 'build_error' | 'unknown';
 export interface FailureVector {
     kind: FailureKind;
     failures: Array<{
@@ -1353,164 +2447,73 @@ export interface FailureVector {
         line?: number;
         symbol?: string;
     }>;
-    /** Source files implicated by stack traces or test output */
     implicated_files: string[];
-    /** Symbol names referenced in error messages */
     implicated_symbols: string[];
-    /** FNV-1a hash of raw output (for deduplication) */
     raw_output_hash: string;
-    parsed_at: ISODateTime;
+    parsed_at: string;
 }
-/** Context expansion levels — higher levels include more context */
 export type ExpansionLevel = 1 | 2 | 3 | 4;
-/** A single entry in the expansion ladder log */
-export interface ExpansionEscalation {
-    from_level: ExpansionLevel;
-    to_level: ExpansionLevel;
-    at_iteration: number;
-    reason: string;
-    implicated_files: string[];
-}
-/** Running state of the IOLE expansion ladder */
 export interface ExpansionLadderState {
     intent_hash: string;
     task: string;
     current_level: ExpansionLevel;
-    max_level: 4;
+    max_level: number;
     iteration_count: number;
     failure_count: number;
-    escalation_log: ExpansionEscalation[];
+    escalation_log: Array<{
+        from_level: number;
+        to_level: ExpansionLevel;
+        at_iteration: number;
+        reason: string;
+        implicated_files: string[];
+    }>;
     resolved: boolean;
 }
-/** Outcome record for a single agent iteration */
 export interface OutcomeRecord {
     task_id: string;
     iteration: number;
     passed: boolean;
-    /** Context expansion level used during this iteration */
     context_level: number;
-    /** Severity score of failure [0,1] — 0 = no failure, 1 = catastrophic */
     failure_severity: number;
-    recorded_at: ISODateTime;
+    recorded_at: string;
 }
-/** Aggregate outcome score computed from multiple outcome records */
 export interface OutcomeScore {
     pass_rate: number;
     total_iterations: number;
     first_pass_rate: number;
     stability_signal: 'stable' | 'oscillating' | 'degrading' | 'improving' | 'unknown';
     improvement_trend: 'improving' | 'flat' | 'degrading';
-    /** Distribution of retry counts: { retries: count } */
     retry_distribution: Record<number, number>;
-    last_updated: ISODateTime;
-}
-/** A layer in the architectural graph */
-export type ArchitectureLayer = 'types' | 'models' | 'services' | 'routes' | 'tests' | 'config' | 'infra' | 'unknown';
-/** A Mermaid diagram produced by the AIL */
-export interface MermaidGraph {
-    /** Diagram type: flowchart, graph, etc. */
-    diagram_type: 'flowchart' | 'graph';
-    /** Complete Mermaid markup ready for rendering */
-    markup: string;
-    /** Files included as nodes in the diagram */
-    included_files: string[];
-    generated_at: ISODateTime;
-}
-/** Context diff between two bundle iterations */
-export interface ContextDiff {
-    from_bundle_id: string;
-    to_bundle_id: string;
-    /** Files added to the context in this iteration */
-    added: string[];
-    /** Files removed from the context */
-    removed: string[];
-    /** Files that stayed in context but changed relevance score */
-    score_changed: Array<{
-        path: string;
-        from_score: number;
-        to_score: number;
-    }>;
-    token_delta: number;
-    generated_at: ISODateTime;
-}
-/** Severity level of a validation issue */
-export type ValidationSeverity = 'error' | 'warning' | 'info';
-/** A single execution-aware validation issue */
-export interface ValidationIssue {
-    code: string;
-    severity: ValidationSeverity;
-    message: string;
-    file?: string;
-    symbol?: string;
-}
-/** Result of execution-aware context validation */
-export interface ValidationResult {
-    passed: boolean;
-    issues: ValidationIssue[];
-    /** Files that have missing or unresolvable type imports */
-    missing_dependencies: string[];
-    /** Files with no linked test coverage */
-    uncovered_files: string[];
-    /** Architecture boundary violations (importing across disallowed layers) */
-    boundary_violations: Array<{
-        from: string;
-        to: string;
-        reason: string;
-    }>;
-    validated_at: ISODateTime;
+    last_updated: string;
 }
-/** A single execution cycle recorded in the ECL-lite ledger */
 export interface EclLiteEntry {
-    /** Stable intent hash from IntentSignature */
     intentSignature: string;
-    /** Unix timestamp (ms) */
     timestamp: number;
-    /** Files included in the context bundle */
     files: string[];
-    /** Symbol names included in any MSCS slice */
     symbols: string[];
-    /** Expansion ladder level used (1–4) */
     expansionLevel: number;
     outcome: 'success' | 'failure';
-    /** Condensed failure vector (kind + implicated files) */
     failureVector?: {
         kind: string;
         implicated_files: string[];
     };
-    /** SHA-256 hash of the bundle file list (for dedup) */
     contextHash: string;
-    /** CCS score at time of execution (0–1) */
     confidenceScore: number;
-    /**
-     * Deterministic category from IntentObject: "{domain}_{operation}" or "general_task".
-     * Optional for backward compatibility with pre-v2.1.1 ledger entries.
-     */
     intentCategory?: string;
 }
-/** Deterministic integer weight entry for the success/failure index */
 export interface EclWeightEntry {
-    /** Intent signature this entry tracks */
     intentSignature: string;
-    /** Cumulative successes (each success increments by 1) */
     successWeight: number;
-    /** Cumulative failures (each failure increments by 1) */
     failureWeight: number;
     lastUpdated: number;
 }
-/** A file that frequently appears in failure vectors — a failure hotspot */
 export interface FailureHotspot {
     file: string;
     failureCount: number;
     successCount: number;
-    /** failureCount / (failureCount + successCount) */
     implicationRate: number;
-    /**
-     * Unix timestamp (ms) of the most recent failure implicating this file.
-     * Used for recency decay: recent failures have higher boost than stale ones.
-     */
     lastFailureTimestamp: number;
 }
-/** Summary of the ECL-lite ledger state */
 export interface EclLiteStatus {
     entry_count: number;
     success_count: number;
@@ -1521,166 +2524,135 @@ export interface EclLiteStatus {
     ledger_path: string;
     last_entry_at: ISODateTime | null;
 }
-/** Recommendation from the CCS assessment */
-export type CcsRecommendation = 'proceed' | 'expand' | 'block';
-/** Per-factor breakdown of the Context Confidence Score */
 export interface CcsFactors {
-    /** Fraction of imported deps present in the bundle [0,1] */
     dependencyCoverage: number;
-    /** Fraction of bundle source files with mapped tests [0,1] */
     testCoverageMapping: number;
-    /** Historical pass rate for this intent type from ECL-lite [0,1] */
     historicalSuccessRate: number;
-    /** Fraction of task keywords matched by bundle symbols [0,1] */
     symbolCompleteness: number;
-    /** Penalty applied based on current expansion level (L1=0, L4=0.3) */
     expansionLevelPenalty: number;
-    /**
-     * Number of ledger entries used to compute historicalSuccessRate.
-     * Low sample sizes reduce the weight of the historical factor to avoid
-     * early-data instability (< 5 → weight 0, 5–19 → scaled, ≥ 20 → full).
-     */
     historySampleSize: number;
-    /**
-     * Effective weight applied to the historical success factor after maturity scaling.
-     * Between 0 (empty/tiny ledger) and the configured W_HISTORICAL_SUCCESS (0.20).
-     */
     adjustedHistoricalWeight: number;
 }
-/** Full Context Confidence Score assessment */
+export type CcsRecommendation = 'proceed' | 'expand' | 'block';
 export interface ContextConfidenceScore {
-    /** Weighted composite score [0,1] */
     score: number;
     level: 'high' | 'medium' | 'low';
     factors: CcsFactors;
     recommendation: CcsRecommendation;
-    /** Suggested expansion level when recommendation = 'expand' */
     suggestedExpansionLevel?: number;
-    /** Human-readable issues explaining score deductions */
     issues: string[];
-    computed_at: ISODateTime;
-}
-/** Structured decomposition of a task prompt — no embeddings, pure keyword parsing */
-export interface IntentObject {
-    /** Primary domain inferred from task (e.g., "auth", "api", "database", "ui") */
-    domain: string;
-    /** Operation type */
-    operation: 'bugfix' | 'feature' | 'refactor' | 'test_update' | 'config' | 'unknown';
-    /** Architectural layer the task targets */
-    layer: ArchitectureLayer;
-    /** Specific entities extracted: function names, module names, type names */
-    entities: string[];
-    /** Inferred constraints: "no breaking changes", "must keep backward compat", etc. */
-    constraints: string[];
-    /**
-     * Deterministic category: "{domain}_{operation}" (e.g., "auth_bugfix", "api_feature").
-     * Falls back to "general_task" when domain or operation is unknown.
-     * Used for aggregated historical success lookups and hotspot grouping.
-     */
-    category: string;
-    /**
-     * Extraction confidence [0,1]. Low values (< 0.4) indicate ambiguous input
-     * where domain/operation fell back to defaults. Used by CCS to apply a small
-     * confidence penalty when intent structure is unclear.
-     */
-    intentConfidence: number;
-    /** Raw task string this was decomposed from */
-    raw_task: string;
-    decomposed_at: ISODateTime;
+    computed_at: string;
 }
-/**
- * Per-factor breakdown for an Intent Sufficiency Check.
- * Each score is [0,1]; the weighted composite produces IntentSufficiencyCheck.score.
- */
 export interface IntentSufficiencyFactors {
-    /**
-     * Token signal score [0,1].
-     * Penalizes ultra-short prompts (< 3 tokens) and rewards richer descriptions.
-     * Weight: 0.20
-     */
     tokenSignalScore: number;
-    /**
-     * Operation clarity score [0,1].
-     * 1.0 when a clear action verb (fix, add, refactor, …) is detected; 0.0 otherwise.
-     * Weight: 0.30
-     */
     operationClarityScore: number;
-    /**
-     * Domain clarity score [0,1].
-     * 1.0 when a recognisable domain keyword (auth, api, database, …) is present.
-     * Weight: 0.25
-     */
     domainClarityScore: number;
-    /**
-     * Target specificity score [0,1].
-     * Rewards naming concrete targets: file paths, module names, function names, quoted
-     * identifiers, or camelCase/snake_case tokens.
-     * Weight: 0.15
-     */
     targetSpecificityScore: number;
-    /**
-     * Constraint presence score [0,1].
-     * 1.0 when scope or quality constraints are present (e.g., "without breaking …",
-     * "must keep backward compat", "in packages/…").
-     * Weight: 0.10
-     */
     constraintPresenceScore: number;
 }
-/**
- * Result of an Intent Sufficiency Check.
- *
- * ISC is the PRE-CONTEXT certification layer — it answers:
- *   "Is this task prompt specific enough to justify context construction?"
- *
- * Decision thresholds:
- *   SUFFICIENT  ≥ 0.75  — proceed normally
- *   WEAK        0.50–0.74 — proceed with -0.05 CCS penalty
- *   INSUFFICIENT < 0.50  — block context construction; surface recommendations
- */
 export interface IntentSufficiencyCheck {
-    /** Weighted composite score [0,1] */
     score: number;
-    /** Gate decision */
     decision: 'SUFFICIENT' | 'WEAK' | 'INSUFFICIENT';
-    /** Per-factor breakdown */
     factors: IntentSufficiencyFactors;
-    /** Human-readable issues explaining score deductions */
     issues: string[];
-    /** Actionable suggestions to improve the prompt */
     recommendations: string[];
-    /** The operation keyword detected, if any */
     detectedOperation?: string;
-    /** The domain keyword detected, if any */
     detectedDomain?: string;
-    /** Specific target tokens detected (file paths, identifiers, module names) */
     detectedTargets?: string[];
 }
-/** An entry in the team-shared context ledger (team-ledger/entries.jsonl). */
+export type InterventionCategory = 'drift_spike' | 'duplication_pressure' | 'governance_breakdown' | 'architectural_violation' | 'test_gap' | 'scope_creep' | 'sot_instability' | 'coverage_gap' | 'extension_failure';
+export interface AggregatedSignal {
+    id: string;
+    source: 'drift' | 'review_intelligence' | 'discovery' | 'layer_d' | 'policy';
+    severity: 'critical' | 'high' | 'medium' | 'low';
+    category: InterventionCategory;
+    description: string;
+    affected_files: string[];
+    timestamp: number;
+    metadata?: Record<string, unknown>;
+}
+export interface EscalationResult {
+    level: 'none' | 'advisory' | 'warning' | 'blocking';
+    reason: string;
+    compound_escalation: boolean;
+    signal_summary: Record<string, number>;
+}
+export type InterventionPriority = 'critical' | 'high' | 'medium' | 'low';
+export interface Intervention {
+    id: string;
+    priority: InterventionPriority;
+    title: string;
+    description: string;
+    action_type: 'refactor' | 'consolidate_duplicates' | 'update_policy' | 'fix_violation' | 'add_test' | 'extend_existing';
+    category: InterventionCategory;
+    affected_files: string[];
+    affected_systems: string[];
+    suggested_fix: string;
+    suggested_actions: string[];
+    estimated_impact: number;
+    agent_template?: string;
+    apply_command?: string;
+}
+export interface FileReservation {
+    file: string;
+    agentId: string;
+    claimedAt: number;
+    expiresAt: number;
+    active: boolean;
+}
+export interface TaskPartition {
+    agentId: string;
+    files: string[];
+    dependsOn: string[];
+}
+export interface ReservationResult {
+    granted: boolean;
+    reservation?: FileReservation;
+    heldBy?: string;
+    heldSince?: number;
+}
+export interface OrchestrationState {
+    reservations: FileReservation[];
+    partitions: TaskPartition[];
+    dependencyOrder: string[];
+    updatedAt: number;
+}
+export interface ProvenanceNode {
+    id: string;
+    kind: 'task' | 'intent' | 'bundle' | 'file' | 'edit' | 'commit' | 'outcome';
+    label: string;
+    timestamp: number;
+    metadata: Record<string, unknown>;
+}
+export interface ProvenanceEdge {
+    source: string;
+    target: string;
+    kind: 'GENERATED_CONTEXT' | 'INCLUDED_FILE' | 'MODIFIED_FILE' | 'PRODUCED_OUTCOME' | 'DERIVED_INTENT' | 'COMMITTED_CHANGE';
+}
+export interface ProvenanceGraph {
+    nodes: ProvenanceNode[];
+    edges: ProvenanceEdge[];
+}
+export interface ProvenanceTrace {
+    taskId: string;
+    taskLabel: string;
+    chain: ProvenanceNode[];
+    chainEdges: ProvenanceEdge[];
+    outcome: 'success' | 'failure' | 'pending';
+}
 export interface TeamLedgerEntry {
-    /** Intent category (e.g. 'bug_fix', 'feature_add', 'refactor') */
     intentCategory: string;
-    /** SHA-256 hash of sorted context files */
     contextHash: string;
-    /** Execution outcome */
     outcome: 'success' | 'failure';
-    /** Context confidence score at execution time */
     confidenceScore: number;
-    /** Files included in the context bundle */
     files: string[];
-    /** Symbols included in the context bundle */
     symbols: string[];
-    /** Epoch ms */
     timestamp: number;
-    /** Developer identifier (redactable) */
     actor?: string;
-    /** Expansion level used (0-3) */
     expansionLevel: number;
-    /** Success weight (incremented on merge dedup) */
     successWeight: number;
-    /** Failure weight (incremented on merge dedup) */
     failureWeight: number;
 }
-/** Aggregated weight entry in team-ledger/weights.json */
 export interface TeamWeightEntry {
     intentCategory: string;
     contextHash: string;
@@ -1688,17 +2660,14 @@ export interface TeamWeightEntry {
     failureWeight: number;
     lastUpdated: number;
 }
-/** Team-level failure hotspot (team-ledger/hotspots.json) */
 export interface TeamHotspot {
     file: string;
     failureCount: number;
     successCount: number;
     implicationRate: number;
     lastFailureTimestamp: number;
-    /** Number of distinct developers who hit this hotspot */
     actorCount: number;
 }
-/** Status summary for the team ledger */
 export interface TeamLedgerStatus {
     entryCount: number;
     successCount: number;
@@ -1710,190 +2679,433 @@ export interface TeamLedgerStatus {
     lastEntryAt: ISODateTime | null;
     ledgerPath: string;
 }
-/** A single required-context rule in team policy */
-export interface TeamPolicyRule {
-    /** Human-readable rule name (e.g. 'auth', 'payments', 'api-routes') */
-    name: string;
-    /** Files that MUST be included when this rule's keywords match the task */
-    requiredFiles: string[];
-    /** Whether matching tests must also be included */
-    requiredTests: boolean;
-    /** Keywords that trigger this rule (matched against task description) */
-    triggerKeywords: string[];
-    /** Action when required files are missing: 'boost' scores or 'block' validation */
-    enforcement: 'boost' | 'block';
-}
-/** Team context policy config (codeledger.team-policy.json) */
-export interface TeamPolicyConfig {
-    /** Schema version */
-    version: 1;
-    /** Whether team policy enforcement is enabled */
-    enabled: boolean;
-    /** Policy rules keyed by domain name */
-    rules: TeamPolicyRule[];
-}
-/** Result of evaluating team policy against a bundle */
-export interface TeamPolicyEvaluation {
-    /** Whether all required files are present */
-    passed: boolean;
-    /** Rules that were triggered by the task */
-    triggeredRules: string[];
-    /** Rules that passed (all required files present) */
-    satisfiedRules: string[];
-    /** Rules that failed (missing required files) */
-    violatedRules: Array<{
-        rule: string;
-        missingFiles: string[];
-        enforcement: 'boost' | 'block';
-    }>;
+export interface TeamWeakArea {
+    area: 'recall' | 'precision' | 'drift' | 'context_confidence' | 'intent_sufficiency';
+    description: string;
+    score: number;
 }
-/** Aggregated team-level quality metrics */
 export interface TeamMetrics {
-    /** Composite team context quality score [0, 1] */
     score: number;
-    /** Number of sessions aggregated */
     sessionCount: number;
-    /** Average bundle recall across sessions */
     avgRecall: number;
-    /** Average bundle precision across sessions */
     avgPrecision: number;
-    /** Average intent drift score [0, 1] (0 = no drift) */
     avgDrift: number;
-    /** Average CCS across sessions */
     avgCcs: number;
-    /** Average ISC across sessions */
     avgIsc: number;
-    /** Trend: change in score over last 7 days */
     trend: number;
-    /** Weak areas identified */
     weakAreas: TeamWeakArea[];
-    /** Timestamp of computation */
     computedAt: ISODateTime;
-    /** Time range: start epoch ms */
     rangeStartMs: number;
-    /** Time range: end epoch ms */
     rangeEndMs: number;
 }
-/** A weak area identified in team metrics */
-export interface TeamWeakArea {
-    area: string;
-    description: string;
-    score: number;
-}
-/** Node types in the provenance graph */
-export type ProvenanceNodeKind = 'task' | 'intent' | 'bundle' | 'file' | 'edit' | 'commit' | 'outcome';
-/** A node in the provenance graph */
-export interface ProvenanceNode {
-    /** Unique node ID (e.g. 'task:abc123', 'file:src/auth.ts') */
-    id: string;
-    /** Node kind */
-    kind: ProvenanceNodeKind;
-    /** Human-readable label */
-    label: string;
-    /** Epoch ms of creation */
-    timestamp: number;
-    /** Arbitrary metadata */
-    metadata: Record<string, unknown>;
-}
-/** Edge types in the provenance graph */
-export type ProvenanceEdgeKind = 'GENERATED_CONTEXT' | 'INCLUDED_FILE' | 'MODIFIED_FILE' | 'PRODUCED_OUTCOME' | 'DERIVED_INTENT' | 'COMMITTED_CHANGE';
-/** An edge in the provenance graph */
-export interface ProvenanceEdge {
-    /** Source node ID */
-    source: string;
-    /** Target node ID */
-    target: string;
-    /** Edge kind */
-    kind: ProvenanceEdgeKind;
-    /** Epoch ms */
-    timestamp: number;
-    /** Arbitrary metadata */
-    metadata: Record<string, unknown>;
+export interface TeamPolicyRule {
+    name: string;
+    triggerKeywords: string[];
+    requiredFiles: string[];
+    enforcement: 'block' | 'warn';
 }
-/** Full provenance graph (in-memory representation) */
-export interface ProvenanceGraph {
-    nodes: ProvenanceNode[];
-    edges: ProvenanceEdge[];
+export interface TeamPolicyConfig {
+    version: number;
+    enabled: boolean;
+    rules: TeamPolicyRule[];
 }
-/** A causal trace from task to outcome */
-export interface ProvenanceTrace {
-    /** The task that started this trace */
-    taskId: string;
-    /** Human-readable task description */
-    taskLabel: string;
-    /** Ordered chain of provenance nodes */
-    chain: ProvenanceNode[];
-    /** Edges connecting the chain */
-    chainEdges: ProvenanceEdge[];
-    /** Final outcome (if reached) */
-    outcome?: 'success' | 'failure' | 'pending';
+export interface TeamPolicyEvaluation {
+    passed: boolean;
+    triggeredRules: string[];
+    satisfiedRules: string[];
+    violatedRules: Array<{
+        rule: string;
+        missingFiles: string[];
+        enforcement: 'block' | 'warn';
+    }>;
 }
-/** Result of a policy simulation run */
 export interface PolicySimulationResult {
-    /** Total historical entries evaluated */
     totalEntries: number;
-    /** Entries that would be blocked */
     blockedCount: number;
-    /** Entries that would receive warnings */
     warnedCount: number;
-    /** Block rate as a fraction [0, 1] */
     blockRate: number;
-    /** Top violation reasons sorted by frequency */
     topViolations: Array<{
         reason: string;
         count: number;
         percentage: number;
     }>;
-    /** Simulation scope: 'team' or 'org' */
     scope: 'team' | 'org';
-    /** Timestamp of simulation */
     simulatedAt: ISODateTime;
 }
-/** A file reservation claimed by an agent */
-export interface FileReservation {
-    /** Path to the reserved file (relative to repo root) */
+/** Scope level for architecture policies */
+export type PolicyScope = 'global' | 'repo' | 'zone' | 'system';
+/** Lifecycle status of a policy document */
+export type PolicyStatus = 'draft' | 'active' | 'deprecated';
+/** A single rule within an architecture policy document */
+export interface ArchitecturePolicyRule {
+    id: string;
+    name?: string;
+    domain: PolicyDomain;
+    scope: PolicyScope;
+    condition: string;
+    action: 'block' | 'warn' | 'allow';
+    enabled: boolean;
+    description?: string;
+}
+/** A full architecture policy document */
+export interface ArchitecturePolicyDocument {
+    schema_version: 'codeledger/arch-policy/v1';
+    name: string;
+    description?: string;
+    scope: PolicyScope;
+    status?: PolicyStatus;
+    created_at?: string;
+    updated_at?: string;
+    rules: ArchitecturePolicyRule[];
+}
+/** A conflict between two rules at different scopes */
+export interface PolicyConflict {
+    rule_id: string;
+    winning_scope: PolicyScope;
+    losing_scope: PolicyScope;
+    resolution: string;
+}
+/** Result of resolving all architecture policies with strictest-wins */
+export interface ResolvedArchitecturePolicy {
+    rules: ArchitecturePolicyRule[];
+    sources: Array<{
+        path: string;
+        scope: PolicyScope;
+        rule_count: number;
+    }>;
+    conflicts: PolicyConflict[];
+    skipped_policies: Array<{
+        path: string;
+        name: string;
+        status: PolicyStatus;
+        reason: string;
+    }>;
+}
+/** Result of simulating architecture policy against historical discoveries */
+export interface ArchPolicySimulationResult {
+    rules_evaluated: number;
+    would_block: number;
+    would_warn: number;
+    would_allow: number;
+    affected_discoveries: Array<{
+        task: string;
+        verdict: DiscoveryVerdict;
+        triggered_rules: string[];
+        action: 'block' | 'warn' | 'allow';
+    }>;
+    summary: string;
+}
+/** Diff between two context bundles */
+export interface ContextDiff {
+    from_bundle_id: string;
+    to_bundle_id: string;
+    added: string[];
+    removed: string[];
+    score_changed: Array<{
+        path: string;
+        from_score: number;
+        to_score: number;
+    }>;
+    token_delta: number;
+    generated_at: string;
+}
+/** Mermaid dependency diagram from a context bundle */
+export interface MermaidGraph {
+    diagram_type: string;
+    markup: string;
+    included_files: string[];
+    generated_at: string;
+}
+/** A single validation issue in a context bundle */
+export interface ValidationIssue {
+    code: string;
+    severity: 'error' | 'warning' | 'info';
+    message: string;
+    file?: string;
+    symbol?: string;
+}
+/** Result of validating a context bundle */
+export interface ValidationResult {
+    passed: boolean;
+    issues: ValidationIssue[];
+    missing_dependencies: string[];
+    uncovered_files: string[];
+    boundary_violations: Array<{
+        from: string;
+        to: string;
+        reason: string;
+    }>;
+    validated_at: string;
+}
+/** A cached discovery result entry */
+export interface DiscoveryCacheEntry {
+    taskHash: string;
+    task: string;
+    verdict: DiscoveryVerdict;
+    overlap: OverlapClassification;
+    posture: ImplementationPosture;
+    guardrails: {
+        must_reuse: string[];
+        must_not_create: string[];
+        insertion_points: string[];
+        prohibited_files: string[];
+    };
+    timestamp: number;
+    ttl_seconds: number;
+}
+/** Result from enforcing discovery guardrails */
+export interface DiscoveryEnforcementResult {
+    blocked: boolean;
+    reason: string;
+    guidance: string;
+    verdict: DiscoveryVerdict | null;
+}
+/** A single diff compliance violation */
+export interface DiffComplianceViolation {
+    type: 'prohibited_file' | 'outside_insertion_points' | 'parallel_directory';
     file: string;
-    /** Agent or session ID that holds the reservation */
-    agentId: string;
-    /** Epoch ms when reservation was created */
-    claimedAt: number;
-    /** Epoch ms when reservation expires (0 = no expiry) */
-    expiresAt: number;
-    /** Whether the agent is actively editing this file */
-    active: boolean;
+    message: string;
+    severity: 'error' | 'warn';
+}
+/** Result of checking PR diff against discovery constraints */
+export interface DiffComplianceResult {
+    status: 'pass' | 'warn' | 'fail';
+    violations: DiffComplianceViolation[];
+    files_checked: number;
+}
+/** A single duplicate detection match */
+export interface DuplicateEntry {
+    new_file: string;
+    existing_file: string;
+    similarity: number;
+    message: string;
 }
-/** A task partition assigning files to agents */
-export interface TaskPartition {
-    /** Agent or session ID */
-    agentId: string;
-    /** Files assigned to this agent */
-    files: string[];
-    /** Dependencies this agent's files have on other partitions */
-    dependsOn: string[];
+/** Result of content-based duplicate detection */
+export interface DuplicateDetectionResult {
+    duplicates: DuplicateEntry[];
+    files_checked: number;
 }
-/** Result of attempting to claim a file reservation */
-export interface ReservationResult {
-    /** Whether the reservation was granted */
-    granted: boolean;
-    /** If denied, the agent that holds the current reservation */
-    heldBy?: string;
-    /** If denied, when the current reservation was claimed */
-    heldSince?: number;
-    /** The reservation record (if granted) */
-    reservation?: FileReservation;
+/** A discovery override artifact */
+export interface DiscoveryOverride {
+    task: string;
+    reason: string;
+    approved_by: string;
+    timestamp: string;
 }
-/** Orchestration state for multi-agent coordination */
-export interface OrchestrationState {
-    /** All active file reservations */
-    reservations: FileReservation[];
-    /** Current task partitions (if partitioned) */
-    partitions: TaskPartition[];
-    /** Dependency ordering constraints */
-    dependencyOrder: Array<{
-        before: string;
-        after: string;
+/** Result of validating a discovery override */
+export interface DiscoveryOverrideValidation {
+    valid: boolean;
+    reason: string;
+    approved_by: string | null;
+}
+/** Configuration for discovery enforcement policy */
+export interface DiscoveryPolicyConfig {
+    block_on_strong_overlap: boolean;
+    enforce_symbol_growth: boolean;
+    max_new_exports: number;
+    duplicate_similarity_threshold: number;
+    require_human_override: boolean;
+    insertion_point_strictness: 'block' | 'warn';
+}
+/** Default discovery enforcement policy */
+export declare const DEFAULT_DISCOVERY_POLICY: DiscoveryPolicyConfig;
+/** Architectural file kind classification for discovery scoring */
+export type DiscoveryFileKind = 'route' | 'service' | 'model' | 'schema' | 'type' | 'test' | 'doc' | 'config' | 'ui' | 'util' | 'migration' | 'unknown';
+/** Symbol growth analysis result from discover-check */
+export interface SymbolGrowthResult {
+    status: 'pass' | 'warn' | 'fail';
+    total_new_exports: number;
+    unrelated_count: number;
+    new_symbols: Array<{
+        file: string;
+        symbol: string;
+        classification: 'expected' | 'suspicious' | 'unrelated';
+        reason: string;
     }>;
-    /** Last updated timestamp */
-    updatedAt: number;
+    files_analyzed: number;
+}
+/** Full result from discover-check */
+export interface DiscoveryCheckResult {
+    verdict: DiscoveryVerdict;
+    overlap: OverlapClassification;
+    diff_compliance: DiffComplianceResult;
+    symbol_growth: SymbolGrowthResult;
+    duplicate_detection: DuplicateDetectionResult;
+    override: DiscoveryOverrideValidation | null;
+    policy: DiscoveryPolicyConfig;
+    passed: boolean;
+    summary: string;
+}
+/** A recommendation from the architecture health advisor */
+export interface AdvisorRecommendation {
+    rule_id: string;
+    name: string;
+    severity: 'critical' | 'warning' | 'info';
+    message: string;
+    affected_systems: string[];
+    suggested_actions: string[];
+}
+/** Result from discovery hook evaluation */
+export interface DiscoveryHookResult {
+    verdict: string;
+    taskHash: string;
+    cached: boolean;
+    guardrails: {
+        must_reuse: string[];
+        must_not_create: string[];
+        insertion_points: string[];
+        prohibited_files: string[];
+    };
+    guidance: string;
+}
+/** Composite architecture health score with 5 components */
+export interface ArchitectureHealthScore {
+    overall: number;
+    components: {
+        dri: number;
+        eds: number;
+        sts: number;
+        ofs: number;
+        dcs: number;
+    };
+    grade: 'A' | 'B' | 'C' | 'D' | 'F';
+    trend: 'improving' | 'stable' | 'declining';
+}
+/** Override log entry for health tracking */
+export interface OverrideLogEntry {
+    task: string;
+    approved_by: string;
+    verdict_overridden: DiscoveryVerdict;
+    timestamp: string;
+    reason: string;
+}
+/** Source-of-truth path change across discovery runs */
+export interface SoTChange {
+    system: string;
+    previous_path: string;
+    current_path: string;
+    confidence_delta: number;
+    timestamp: string;
+}
+/** Hotspot from duplication pressure */
+export interface HealthHotspot {
+    system: string;
+    path: string;
+    duplication_pressure: number;
+    recent_violations: number;
+    risk: 'low' | 'medium' | 'high' | 'critical';
+}
+/** Point-in-time health snapshot */
+export interface HealthSnapshot {
+    timestamp: string;
+    commit_sha: string | null;
+    score: ArchitectureHealthScore;
+    hotspots: HealthHotspot[];
+    sot_changes: SoTChange[];
+    override_log: OverrideLogEntry[];
+}
+/** Alert from health metric thresholds */
+export interface HealthAlert {
+    severity: 'warning' | 'critical';
+    message: string;
+    system: string | null;
+    metric: string;
+    value: number;
+    threshold: number;
+}
+/** Full health dashboard output */
+export interface HealthDashboard {
+    current: HealthSnapshot;
+    history: HealthSnapshot[];
+    alerts: HealthAlert[];
+}
+/** Drift velocity classification level */
+export type DriftVelocityLevel = 'LOW' | 'RISING' | 'HIGH' | 'CRITICAL';
+/** Drift velocity measurement from task history */
+export interface DriftVelocity {
+    level: DriftVelocityLevel;
+    unique_tasks_1h: number;
+    unique_tasks_24h: number;
+    acceleration: number;
+}
+/** Overall pre-PR verdict */
+export type PrePRVerdict = 'PASS' | 'WARN' | 'FAIL';
+/** Severity of a pre-PR finding */
+export type PrePRSeverity = 'critical' | 'high' | 'medium' | 'low';
+/** Category of a pre-PR check */
+export type PrePRCategory = 'completion' | 'type_contract' | 'cross_package' | 'staleness' | 'structural_trust' | 'build_test' | 'neighborhood' | 'release' | 'review_complexity' | 'adversarial';
+/** Individual pre-PR finding */
+export interface PrePRFinding {
+    category: PrePRCategory;
+    severity: PrePRSeverity;
+    title: string;
+    detail: string;
+    remediation?: string;
+    files?: string[];
+}
+/** Result of a single pre-PR check */
+export interface PrePRCheckResult {
+    category: PrePRCategory;
+    verdict: PrePRVerdict;
+    findings: PrePRFinding[];
+    durationMs: number;
+}
+/** Aggregated pre-PR report */
+export interface PrePRReport {
+    verdict: PrePRVerdict;
+    checks: PrePRCheckResult[];
+    blockers: PrePRFinding[];
+    warnings: PrePRFinding[];
+    nextAction: string;
+    timestamp: string;
+    durationMs: number;
+}
+/** A single prevented issue with verifiable provenance */
+export interface InsightPreventedIssue {
+    id: string;
+    description: string;
+    severity: 'critical' | 'high' | 'medium';
+    source: 'guardrail' | 'pre_pr' | 'release_check' | 'cic';
+    recursiveImpact?: string;
+}
+/** Work avoided metrics */
+export interface InsightWorkAvoided {
+    surfaces: number;
+    tests: number;
+    contextScansAvoided: number;
+    estimatedTimeSavedSec?: number;
+}
+/** Truth established via state promotions */
+export interface InsightTruthEstablished {
+    completionState?: CompletionState;
+    releaseState?: ReleaseState;
+}
+/** A state transition record */
+export interface InsightStateTransition {
+    from: string;
+    to: string;
+    label: string;
+    delta: number;
+}
+/** Full insight result — the value dashboard output */
+export interface InsightResult {
+    preventedIssues: number;
+    preventedDetails: InsightPreventedIssue[];
+    workAvoided: InsightWorkAvoided;
+    truthEstablished: InsightTruthEstablished;
+    confidenceDelta: number;
+    stateTransitions: InsightStateTransition[];
+    recommendedAction?: string;
+    silent: boolean;
+    healthPulse: boolean;
+    timestamp: string;
+    sessionId?: string;
+}
+/** Session insight storage entry */
+export interface InsightSessionEntry {
+    sessionId: string;
+    command: string;
+    result: InsightResult;
+    timestamp: string;
 }
 //# sourceMappingURL=index.d.ts.map