@codeledger/types 0.7.3 → 0.7.5

package/dist/index.d.ts

@@ -1757,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<{
@@ -1828,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;
@@ -1996,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;
+    computed_at: string;
 }
-/** 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;
-}
-/**
- * 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;
@@ -2163,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;
@@ -2185,517 +2679,84 @@ 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;
-}
-/** Composite metrics for architecture health monitoring */
-export interface DashboardMetrics {
-    ahs: number;
-    dri: number;
-    eds: number;
-    sts: number;
-    override_frequency: number;
-    overall: number;
-    timestamp: number;
-}
-/** A dashboard metrics snapshot with provenance */
-export interface DashboardSnapshot extends DashboardMetrics {
-    snapshot_source: string;
-}
-/** Trend direction for each dashboard metric */
-export interface DashboardTrends {
-    ahs_trend: 'improving' | 'stable' | 'degrading';
-    dri_trend: 'improving' | 'stable' | 'degrading';
-    eds_trend: 'improving' | 'stable' | 'degrading';
-    sts_trend: 'improving' | 'stable' | 'degrading';
-    override_trend: 'improving' | 'stable' | 'degrading';
-    overall_trend: 'improving' | 'stable' | 'degrading';
-}
-/** 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) */
-    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;
-}
-/** 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 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;
-}
-/** 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;
-    }>;
-    /** Last updated timestamp */
-    updatedAt: number;
-}
-/** Overlap classification for a discovery result */
-export type OverlapClassification = 'NO_MATERIAL_OVERLAP' | 'PARTIAL_OVERLAP' | 'STRONG_OVERLAP' | 'FEATURE_ALREADY_EXISTS';
-/** Recommended implementation posture */
-export type ImplementationPosture = 'EXTEND_EXISTING_SYSTEM' | 'WRAP_EXISTING_SYSTEM' | 'ADD_ADAPTER_LAYER' | 'BUILD_NEW_CAPABILITY';
-/** Go/No-Go verdict for a discovery gate */
-export type DiscoveryVerdict = 'GO_GENUINELY_NEW' | 'GO_EXTENSION_ONLY' | 'NO_GO_ALREADY_EXISTS';
-/** Kind of file in the architecture */
-export type DiscoveryFileKind = 'route' | 'service' | 'model' | 'schema' | 'type' | 'migration' | 'test' | 'doc' | 'config' | 'util' | 'ui' | 'unknown';
-/** A system found during discovery that relates to the requested capability */
-export interface DiscoveryMatch {
-    /** File path (relative to repo root) */
-    file: string;
-    /** System or module name */
-    system: string;
-    /** Short description of what it does */
-    description: string;
-    /** Similarity score 0–1 (combined keyword + centrality + structural signals) */
-    similarity: number;
-    /** Type of overlap */
-    overlap: 'direct' | 'indirect';
-    /** Exported symbols that matched */
-    matched_symbols: string[];
-    /** Architectural kind of this file */
-    kind: DiscoveryFileKind;
-    /** Why this file is relevant */
-    why_relevant: string;
-    /** Centrality score (dependents-based) [0-1] */
-    centrality: number;
-}
-/** Source-of-truth for a discovered system */
-export interface DiscoverySourceOfTruth {
-    /** Canonical system name */
-    system: string;
-    /** Primary file path (highest centrality in cluster) */
-    path: string;
-    /** Confidence in this being the true owner [0-1] */
-    confidence: number;
-    /** Why this was selected as source of truth */
-    justification: string;
-    /** Competing systems that implement similar capability */
-    competitors: Array<{
-        system: string;
-        path: string;
-        similarity: number;
-    }>;
-    /** Whether fragmentation was detected (same concept across 3+ unrelated dirs) */
-    fragmented: boolean;
-}
-/** Blast radius for a discovered system */
-export interface DiscoveryBlastRadius {
-    /** System name */
-    system: string;
-    /** Primary file path */
-    path: string;
-    /** Direct dependents (files that import it) */
-    direct_dependents: string[];
-    /** Transitive dependents (full chain) */
-    transitive_dependents: string[];
-    /** Shared modules/types this system uses */
-    shared_modules: string[];
-    /** Impacted tests */
-    impacted_tests: string[];
-    /** Risk classification */
-    risk: 'low' | 'medium' | 'high';
-}
-/** Gap analysis for a discovery result */
-export interface DiscoveryGapAnalysis {
-    /** Estimated coverage: what % of requested capability exists [0-1] */
-    coverage_estimate: number;
-    /** Specific missing capabilities (entities/concepts not found in SoT) */
-    missing_capabilities: string[];
-    /** Recommended extensions with target file/module */
-    recommended_extensions: Array<{
-        target: string;
-        description: string;
-    }>;
-    /** Exact files/modules to extend */
-    extension_targets: string[];
-    /** Warning when coverage is high (>70%) — "DO NOT BUILD NEW — EXTEND" */
-    warning: string | null;
-    /** Source-of-truth exports that align with the task */
-    existing_exports: string[];
-}
-/** Full discovery artifact (versioned, persisted to .codeledger/discovery/) */
-export interface DiscoveryArtifactV1 {
-    /** Schema version */
-    schema_version: 'discovery/v1';
-    /** Task description */
-    task: string;
-    /** Normalized task (lowercased, stopwords removed) */
-    normalized_task: string;
-    /** Search evidence */
-    search_evidence: {
-        keywords: string[];
-        expanded_terms: string[];
-        semantic_neighbors: Array<{
-            term: string;
-            reason: string;
-        }>;
-        files_scanned: number;
-    };
-    /** Intent decomposition */
-    intent: IntentObject;
-    /** Top similarity matches (grouped by system) */
-    matches: DiscoveryMatch[];
-    /** Source of truth detection */
-    source_of_truth: DiscoverySourceOfTruth | null;
-    /** Blast radius for top systems */
-    blast_radius: DiscoveryBlastRadius[];
-    /** Gap analysis */
-    gap_analysis: DiscoveryGapAnalysis;
-    /** Overlap classification */
-    overlap_classification: OverlapClassification;
-    /** Duplication risk description */
-    duplication_risk: string;
-    /** Recommended implementation posture */
-    recommended_posture: ImplementationPosture;
-    /** Proposed insertion points (file paths to extend) */
-    proposed_insertion_points: string[];
-    /** Prohibited files (paths where parallel systems MUST NOT be created) */
-    prohibited_files: string[];
-    /** Things that must NOT be created */
-    must_not_create: string[];
-    /** Things that MUST be reused */
-    must_reuse: string[];
-    /** Go/No-Go verdict */
-    verdict: DiscoveryVerdict;
-    /** Related repo standards */
-    related_standards: Array<{
-        helper_name: string;
-        example_paths: string[];
-        usage_count: number;
-    }>;
-    /** Duration in milliseconds */
-    duration_ms: number;
-    /** Timestamp */
-    generated_at: ISODateTime;
-}
-/** Result of running the discovery gate (backward-compatible + enhanced) */
-export interface DiscoveryResult {
-    /** The requested capability (task description) */
-    requested_capability: string;
-    /** Intent decomposition of the task */
-    intent: IntentObject;
-    /** Keywords and synonyms searched */
-    keywords_searched: string[];
-    /** Files scanned (count) */
-    files_scanned: number;
-    /** Top similarity matches */
-    matches: DiscoveryMatch[];
-    /** Existing repo standards that relate */
-    related_standards: Array<{
-        helper_name: string;
-        example_paths: string[];
-        usage_count: number;
-    }>;
-    /** Overlap classification */
-    overlap: OverlapClassification;
-    /** Duplication risk explanation */
-    duplication_risk: string;
-    /** Recommended implementation posture */
-    posture: ImplementationPosture;
-    /** Go/No-Go verdict */
-    verdict: DiscoveryVerdict;
-    /** Guardrails: what must be reused */
-    must_reuse: string[];
-    /** Guardrails: what must NOT be created */
-    must_not_create: string[];
-    /** Proposed insertion points (file paths) */
-    insertion_points: string[];
-    /** Prohibited files (paths where parallel systems must NOT be created) */
-    prohibited_files: string[];
-    /** Source-of-truth detection result */
-    source_of_truth: DiscoverySourceOfTruth | null;
-    /** Blast radius for top systems */
-    blast_radius: DiscoveryBlastRadius[];
-    /** Gap analysis */
-    gap_analysis: DiscoveryGapAnalysis | null;
-    /** Duration in milliseconds */
-    duration_ms: number;
-}
-/** Result from the discovery hook (run automatically on implementation tasks) */
-export interface DiscoveryHookResult {
-    verdict: DiscoveryVerdict;
-    taskHash: string;
-    cached: boolean;
-    guardrails: {
-        must_reuse: string[];
-        must_not_create: string[];
-        insertion_points: string[];
-        prohibited_files: string[];
-    };
-    guidance: string;
-}
-/** Cache entry for a discovery result (keyed by task hash) */
-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 the discovery enforcement check on Edit/Write operations */
-export interface DiscoveryEnforcementResult {
-    blocked: boolean;
-    reason: string;
-    guidance: string;
-    verdict: DiscoveryVerdict | null;
-}
-/** A single insertion-point or ghost-file violation */
-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[];
-}
-/** Aggregate symbol growth report for a PR */
-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[];
-}
-/** Per-file symbol growth entry */
-export interface SymbolGrowthEntry {
-    file: string;
-    added: string[];
-    removed: string[];
-    modified: string[];
-    net: number;
-}
-export interface AggregatedSignal {
-    id: string;
-    source: 'drift' | 'discovery' | 'review_intelligence' | 'layer_d' | 'policy' | 'verify';
-    severity: 'critical' | 'high' | 'medium' | 'low';
-    category: InterventionCategory;
-    description: string;
-    affected_files: string[];
-    timestamp: number;
-    metadata?: Record<string, unknown>;
-}
-export type InterventionCategory = 'drift_spike' | 'duplication_pressure' | 'governance_breakdown' | 'architectural_violation' | 'test_gap' | 'scope_creep' | 'sot_instability' | 'coverage_gap' | 'extension_failure';
-export interface EscalationResult {
-    level: 'none' | 'advisory' | 'warning' | 'blocking';
-    reason: string;
-    compound_escalation: boolean;
-    signal_summary: Record<InterventionCategory, number>;
-}
-export interface Intervention {
-    id: string;
-    priority: InterventionPriority;
-    title: string;
-    description: string;
-    action_type: 'refactor' | 'extend_existing' | 'add_test' | 'fix_violation' | 'consolidate_duplicates' | 'update_policy';
-    category: InterventionCategory;
-    affected_files: string[];
-    affected_systems: string[];
-    suggested_fix: string;
-    suggested_actions: string[];
-    apply_command?: string;
-    estimated_impact: number;
-    agent_template?: string;
+    blockedCount: number;
+    warnedCount: number;
+    blockRate: number;
+    topViolations: Array<{
+        reason: string;
+        count: number;
+        percentage: number;
+    }>;
+    scope: 'team' | 'org';
+    simulatedAt: ISODateTime;
 }
-/** Scope levels for architecture policies (strictest wins) */
+/** 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 architecture policy rule */
+/** A single rule within an architecture policy document */
 export interface ArchitecturePolicyRule {
     id: string;
     name?: string;
-    description?: string;
+    domain: PolicyDomain;
     scope: PolicyScope;
-    domain: 'discovery' | 'enforcement' | 'source_of_truth' | 'overrides' | 'interventions' | 'dashboard';
     condition: string;
     action: 'block' | 'warn' | 'allow';
     enabled: boolean;
+    description?: string;
 }
-/** A policy document containing rules */
+/** A full architecture policy document */
 export interface ArchitecturePolicyDocument {
     schema_version: 'codeledger/arch-policy/v1';
     name: string;
     description?: string;
     scope: PolicyScope;
     status?: PolicyStatus;
-    rules: ArchitecturePolicyRule[];
     created_at?: string;
     updated_at?: string;
+    rules: ArchitecturePolicyRule[];
 }
 /** A conflict between two rules at different scopes */
 export interface PolicyConflict {
@@ -2704,7 +2765,7 @@ export interface PolicyConflict {
     losing_scope: PolicyScope;
     resolution: string;
 }
-/** Resolved policy after cascade resolution */
+/** Result of resolving all architecture policies with strictest-wins */
 export interface ResolvedArchitecturePolicy {
     rules: ArchitecturePolicyRule[];
     sources: Array<{
@@ -2720,7 +2781,7 @@ export interface ResolvedArchitecturePolicy {
         reason: string;
     }>;
 }
-/** Result of simulating a policy against historical data */
+/** Result of simulating architecture policy against historical discoveries */
 export interface ArchPolicySimulationResult {
     rules_evaluated: number;
     would_block: number;
@@ -2728,133 +2789,98 @@ export interface ArchPolicySimulationResult {
     would_allow: number;
     affected_discoveries: Array<{
         task: string;
-        verdict: string;
+        verdict: DiscoveryVerdict;
         triggered_rules: string[];
         action: 'block' | 'warn' | 'allow';
     }>;
     summary: string;
 }
-/** Architecture Health Score (5-component, 0-100 scale) */
-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';
-}
-/** A hotspot detected in the architecture */
-export interface HealthHotspot {
-    system: string;
-    path: string;
-    duplication_pressure: number;
-    recent_violations: number;
-    risk: 'low' | 'medium' | 'high' | 'critical';
-}
-/** A change in source-of-truth assignment */
-export interface SoTChange {
-    system: string;
-    previous_path: string | null;
-    current_path: string;
-    confidence_delta: number;
-    timestamp: string;
-}
-/** An entry in the override log */
-export interface OverrideLogEntry {
-    task: string;
-    approved_by: string;
-    verdict_overridden: DiscoveryVerdict;
-    timestamp: string;
-    reason: string;
-}
-/** A health alert triggered by threshold breach */
-export interface HealthAlert {
-    severity: 'critical' | 'warning';
-    message: string;
-    system: string | null;
-    metric: string;
-    value: number;
-    threshold: number;
-}
-/** A point-in-time health snapshot */
-export interface HealthSnapshot {
-    timestamp: string;
-    commit_sha: string | null;
-    score: ArchitectureHealthScore;
-    hotspots: HealthHotspot[];
-    sot_changes: SoTChange[];
-    override_log: OverrideLogEntry[];
+/** 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;
 }
-/** Full health dashboard with current state, history, and alerts */
-export interface HealthDashboard {
-    current: HealthSnapshot;
-    history: HealthSnapshot[];
-    alerts: HealthAlert[];
+/** Mermaid dependency diagram from a context bundle */
+export interface MermaidGraph {
+    diagram_type: string;
+    markup: string;
+    included_files: string[];
+    generated_at: string;
 }
-/** An advisor recommendation for architecture improvements */
-export interface AdvisorRecommendation {
-    rule_id: string;
-    name: string;
-    severity: 'critical' | 'warning' | 'info';
+/** A single validation issue in a context bundle */
+export interface ValidationIssue {
+    code: string;
+    severity: 'error' | 'warning' | 'info';
     message: string;
-    affected_systems: string[];
-    suggested_actions: string[];
+    file?: string;
+    symbol?: string;
 }
-/** Drift velocity — rate of architectural change */
-export type DriftVelocityLevel = 'LOW' | 'RISING' | 'HIGH' | 'CRITICAL';
-export interface DriftVelocity {
-    level: DriftVelocityLevel;
-    unique_tasks_1h: number;
-    unique_tasks_24h: number;
-    acceleration: number;
+/** 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;
 }
-/** Priority level for interventions */
-export type InterventionPriority = 'critical' | 'high' | 'medium' | 'low';
-/** Result of running the intervention engine */
-export interface InterventionResult {
-    interventions: Intervention[];
-    total_count: number;
-    critical_count: number;
-    high_count: number;
-    estimated_ahs_improvement: number;
-    generated_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;
 }
-/** Policy configuration for discovery enforcement */
-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';
+/** Result from enforcing discovery guardrails */
+export interface DiscoveryEnforcementResult {
+    blocked: boolean;
+    reason: string;
+    guidance: string;
+    verdict: DiscoveryVerdict | null;
 }
-/** Sensible defaults for discovery policy */
-export declare const DEFAULT_DISCOVERY_POLICY: DiscoveryPolicyConfig;
-/** A diff compliance violation */
+/** A single diff compliance violation */
 export interface DiffComplianceViolation {
     type: 'prohibited_file' | 'outside_insertion_points' | 'parallel_directory';
     file: string;
     message: string;
     severity: 'error' | 'warn';
 }
-/** Result of diff compliance check */
+/** Result of checking PR diff against discovery constraints */
 export interface DiffComplianceResult {
     status: 'pass' | 'warn' | 'fail';
     violations: DiffComplianceViolation[];
     files_checked: number;
 }
-/** A detected duplicate file */
+/** A single duplicate detection match */
 export interface DuplicateEntry {
     new_file: string;
     existing_file: string;
     similarity: number;
     message: string;
 }
-/** Result of duplicate detection */
+/** Result of content-based duplicate detection */
 export interface DuplicateDetectionResult {
     duplicates: DuplicateEntry[];
     files_checked: number;
@@ -2866,35 +2892,220 @@ export interface DiscoveryOverride {
     approved_by: string;
     timestamp: string;
 }
-/** Validation result for a discovery override */
+/** Result of validating a discovery override */
 export interface DiscoveryOverrideValidation {
     valid: boolean;
     reason: string;
     approved_by: string | null;
 }
-/** Result of the discovery check command */
-export interface DiscoveryCheckResult {
-    verdict: DiscoveryVerdict;
-    overlap: OverlapClassification;
-    diff_compliance: DiffComplianceResult | null;
-    symbol_growth: SymbolGrowthResult | null;
-    duplicate_detection: DuplicateDetectionResult | null;
-    override: DiscoveryOverrideValidation | null;
-    policy: DiscoveryPolicyConfig | null;
-    passed: boolean;
-    summary: string;
+/** 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';
 }
-/** Result of symbol growth analysis */
+/** 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';
-    files_analyzed: number;
+    total_new_exports: number;
+    unrelated_count: number;
     new_symbols: Array<{
         file: string;
         symbol: string;
         classification: 'expected' | 'suspicious' | 'unrelated';
         reason: string;
     }>;
-    total_new_exports: number;
-    unrelated_count: 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