@harness-engineering/core 0.5.0

package/dist/index.d.mts

@@ -0,0 +1,2310 @@
+import { WorkflowStep, WorkflowStepResult, Workflow, WorkflowResult, SkillLifecycleHooks, SkillContext, SkillResult, TurnContext } from '@harness-engineering/types';
+export * from '@harness-engineering/types';
+import { z } from 'zod';
+
+type Result<T, E = Error> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: E;
+};
+declare const Ok: <T>(value: T) => Result<T, never>;
+declare function isOk<T, E>(result: Result<T, E>): result is {
+    ok: true;
+    value: T;
+};
+declare const Err: <E>(error: E) => Result<never, E>;
+declare function isErr<T, E>(result: Result<T, E>): result is {
+    ok: false;
+    error: E;
+};
+
+/**
+ * Abstract Syntax Tree representation
+ */
+interface AST {
+    type: string;
+    body: unknown;
+    language: string;
+}
+/**
+ * Source code location
+ */
+interface Location {
+    file: string;
+    line: number;
+    column: number;
+}
+/**
+ * Import declaration extracted from source
+ */
+interface Import {
+    source: string;
+    specifiers: string[];
+    default?: string;
+    namespace?: string;
+    location: Location;
+    kind: 'value' | 'type';
+}
+/**
+ * Export declaration extracted from source
+ */
+interface Export {
+    name: string;
+    type: 'named' | 'default' | 'namespace';
+    location: Location;
+    isReExport: boolean;
+    source?: string;
+}
+/**
+ * Parser error with structured details
+ */
+interface ParseError extends BaseError {
+    code: 'TIMEOUT' | 'SUBPROCESS_FAILED' | 'SYNTAX_ERROR' | 'NOT_FOUND' | 'PARSER_UNAVAILABLE';
+    details: {
+        exitCode?: number;
+        stderr?: string;
+        path?: string;
+        parser?: string;
+    };
+}
+/**
+ * Health check result indicating parser availability
+ */
+interface HealthCheckResult {
+    available: boolean;
+    version?: string;
+    message?: string;
+}
+/**
+ * Language-agnostic parser interface
+ * Implementations provide language-specific parsing
+ */
+interface LanguageParser {
+    name: string;
+    extensions: string[];
+    parseFile(path: string): Promise<Result<AST, ParseError>>;
+    extractImports(ast: AST): Result<Import[], ParseError>;
+    extractExports(ast: AST): Result<Export[], ParseError>;
+    health(): Promise<Result<HealthCheckResult, ParseError>>;
+}
+/**
+ * Create a ParseError with standard structure
+ */
+declare function createParseError(code: ParseError['code'], message: string, details?: ParseError['details'], suggestions?: string[]): ParseError;
+
+declare class TypeScriptParser implements LanguageParser {
+    name: string;
+    extensions: string[];
+    parseFile(path: string): Promise<Result<AST, ParseError>>;
+    extractImports(ast: AST): Result<Import[], ParseError>;
+    extractExports(ast: AST): Result<Export[], ParseError>;
+    health(): Promise<Result<HealthCheckResult, ParseError>>;
+}
+
+interface Layer {
+    name: string;
+    patterns: string[];
+    allowedDependencies: string[];
+}
+interface LayerConfig {
+    layers: Layer[];
+    rootDir: string;
+    parser: LanguageParser;
+    fallbackBehavior?: 'skip' | 'error' | 'warn';
+}
+interface DependencyEdge {
+    from: string;
+    to: string;
+    importType: 'static' | 'dynamic' | 'type-only';
+    line: number;
+}
+interface DependencyGraph {
+    nodes: string[];
+    edges: DependencyEdge[];
+}
+interface DependencyViolation {
+    file: string;
+    imports: string;
+    fromLayer: string;
+    toLayer: string;
+    reason: 'WRONG_LAYER' | 'CIRCULAR_DEP' | 'FORBIDDEN_IMPORT';
+    line: number;
+    suggestion: string;
+}
+interface DependencyValidation {
+    valid: boolean;
+    violations: DependencyViolation[];
+    graph: DependencyGraph;
+    skipped?: boolean;
+    reason?: string;
+}
+interface CircularDependency {
+    cycle: string[];
+    severity: 'error' | 'warning';
+    size: number;
+}
+interface CircularDepsResult {
+    hasCycles: boolean;
+    cycles: CircularDependency[];
+    largestCycle: number;
+}
+interface BoundaryDefinition {
+    name: string;
+    layer: string;
+    schema: z.ZodSchema<unknown>;
+    direction: 'input' | 'output';
+}
+interface BoundaryViolation {
+    boundary: string;
+    direction: 'input' | 'output';
+    error: z.ZodError;
+    data: unknown;
+}
+interface BoundaryValidation {
+    valid: boolean;
+    violations: BoundaryViolation[];
+}
+interface BoundaryValidator<T> {
+    name: string;
+    parse(input: unknown): Result<T, ConstraintError>;
+    validate(input: unknown): Result<boolean, ConstraintError>;
+    schema: z.ZodSchema<T>;
+}
+
+interface EntropyError extends BaseError {
+    code: 'SNAPSHOT_BUILD_FAILED' | 'PARSE_ERROR' | 'ENTRY_POINT_NOT_FOUND' | 'INVALID_CONFIG' | 'CONFIG_VALIDATION_ERROR' | 'FIX_FAILED' | 'BACKUP_FAILED';
+    details: {
+        file?: string;
+        reason?: string;
+        issues?: unknown[];
+        originalError?: Error;
+    };
+}
+interface InternalSymbol {
+    name: string;
+    type: 'function' | 'class' | 'variable' | 'type';
+    line: number;
+    references: number;
+    calledBy: string[];
+}
+interface JSDocComment {
+    content: string;
+    line: number;
+    associatedSymbol?: string;
+}
+interface CodeBlock {
+    language: string;
+    content: string;
+    line: number;
+}
+interface InlineReference {
+    reference: string;
+    line: number;
+    column: number;
+}
+interface SourceFile {
+    path: string;
+    ast: AST;
+    imports: Import[];
+    exports: Export[];
+    internalSymbols: InternalSymbol[];
+    jsDocComments: JSDocComment[];
+}
+interface DocumentationFile {
+    path: string;
+    type: 'markdown' | 'jsdoc' | 'typedoc' | 'text';
+    content: string;
+    codeBlocks: CodeBlock[];
+    inlineRefs: InlineReference[];
+}
+interface CodeReference {
+    docFile: string;
+    line: number;
+    column: number;
+    reference: string;
+    context: 'code-block' | 'inline' | 'link' | 'jsdoc';
+    resolvedTo?: string;
+}
+interface ExportMap {
+    byFile: Map<string, Export[]>;
+    byName: Map<string, {
+        file: string;
+        export: Export;
+    }[]>;
+}
+interface CodebaseSnapshot {
+    files: SourceFile[];
+    dependencyGraph: DependencyGraph;
+    exportMap: ExportMap;
+    docs: DocumentationFile[];
+    codeReferences: CodeReference[];
+    entryPoints: string[];
+    rootDir: string;
+    config: EntropyConfig;
+    buildTime: number;
+}
+interface DriftConfig {
+    docPaths: string[];
+    checkApiSignatures: boolean;
+    checkExamples: boolean;
+    checkStructure: boolean;
+    ignorePatterns: string[];
+}
+interface DeadCodeConfig {
+    entryPoints?: string[];
+    includeTypes: boolean;
+    includeInternals: boolean;
+    ignorePatterns: string[];
+    treatDynamicImportsAs: 'used' | 'unknown';
+}
+interface EntropyConfig {
+    rootDir: string;
+    parser?: LanguageParser;
+    entryPoints?: string[];
+    analyze: {
+        drift?: boolean | Partial<DriftConfig>;
+        deadCode?: boolean | Partial<DeadCodeConfig>;
+        patterns?: boolean | PatternConfig;
+    };
+    include?: string[];
+    exclude?: string[];
+    docPaths?: string[];
+}
+interface DocumentationDrift {
+    type: 'api-signature' | 'example-code' | 'structure';
+    docFile: string;
+    line: number;
+    reference: string;
+    context: string;
+    issue: 'NOT_FOUND' | 'RENAMED' | 'SIGNATURE_CHANGED' | 'SYNTAX_ERROR' | 'IMPORT_ERROR';
+    details: string;
+    suggestion?: string;
+    possibleMatches?: string[];
+    confidence: 'high' | 'medium' | 'low';
+}
+interface DriftReport {
+    drifts: DocumentationDrift[];
+    stats: {
+        docsScanned: number;
+        referencesChecked: number;
+        driftsFound: number;
+        byType: {
+            api: number;
+            example: number;
+            structure: number;
+        };
+    };
+    severity: 'high' | 'medium' | 'low' | 'none';
+}
+interface DeadExport {
+    file: string;
+    name: string;
+    line: number;
+    type: 'function' | 'class' | 'variable' | 'type' | 'interface' | 'enum';
+    isDefault: boolean;
+    reason: 'NO_IMPORTERS' | 'IMPORTERS_ALSO_DEAD';
+}
+interface DeadFile {
+    path: string;
+    reason: 'NO_IMPORTERS' | 'NOT_ENTRY_POINT' | 'ALL_EXPORTS_DEAD';
+    exportCount: number;
+    lineCount: number;
+}
+interface DeadInternal {
+    file: string;
+    name: string;
+    line: number;
+    type: 'function' | 'class' | 'variable';
+    reason: 'NEVER_CALLED' | 'ONLY_CALLED_BY_DEAD';
+}
+interface UnusedImport {
+    file: string;
+    line: number;
+    source: string;
+    specifiers: string[];
+    isFullyUnused: boolean;
+}
+interface ReachabilityNode {
+    file: string;
+    reachable: boolean;
+    importedBy: string[];
+    imports: string[];
+}
+interface DeadCodeReport {
+    deadExports: DeadExport[];
+    deadFiles: DeadFile[];
+    deadInternals: DeadInternal[];
+    unusedImports: UnusedImport[];
+    stats: {
+        filesAnalyzed: number;
+        entryPointsUsed: string[];
+        totalExports: number;
+        deadExportCount: number;
+        totalFiles: number;
+        deadFileCount: number;
+        estimatedDeadLines: number;
+    };
+    reachabilityTree?: ReachabilityNode;
+}
+interface ConfigPattern {
+    name: string;
+    description: string;
+    severity: 'error' | 'warning';
+    files: string[];
+    rule: {
+        type: 'must-export';
+        names: string[];
+    } | {
+        type: 'must-export-default';
+        kind?: 'class' | 'function' | 'object';
+    } | {
+        type: 'no-export';
+        names: string[];
+    } | {
+        type: 'must-import';
+        from: string;
+        names?: string[];
+    } | {
+        type: 'no-import';
+        from: string;
+    } | {
+        type: 'naming';
+        match: string;
+        convention: 'camelCase' | 'PascalCase' | 'UPPER_SNAKE' | 'kebab-case';
+    } | {
+        type: 'max-exports';
+        count: number;
+    } | {
+        type: 'max-lines';
+        count: number;
+    } | {
+        type: 'require-jsdoc';
+        for: ('function' | 'class' | 'export')[];
+    };
+    message?: string;
+}
+interface CodePattern {
+    name: string;
+    description: string;
+    severity: 'error' | 'warning';
+    check: (file: SourceFile, snapshot: CodebaseSnapshot) => PatternMatch[];
+}
+interface PatternMatch {
+    line: number;
+    column?: number;
+    message: string;
+    suggestion?: string;
+}
+interface PatternConfig {
+    patterns: ConfigPattern[];
+    customPatterns?: CodePattern[];
+    ignoreFiles?: string[];
+}
+interface PatternViolation {
+    pattern: string;
+    file: string;
+    line: number;
+    column?: number;
+    severity: 'error' | 'warning';
+    message: string;
+    suggestion?: string;
+}
+interface PatternReport {
+    violations: PatternViolation[];
+    stats: {
+        filesChecked: number;
+        patternsApplied: number;
+        violationCount: number;
+        errorCount: number;
+        warningCount: number;
+    };
+    passRate: number;
+}
+type FixType = 'unused-imports' | 'dead-files' | 'trailing-whitespace' | 'broken-links' | 'sort-imports';
+interface FixConfig {
+    dryRun: boolean;
+    fixTypes: FixType[];
+    createBackup: boolean;
+    backupDir?: string;
+}
+interface Fix {
+    type: FixType;
+    file: string;
+    description: string;
+    action: 'delete-file' | 'delete-lines' | 'replace' | 'insert';
+    line?: number;
+    oldContent?: string;
+    newContent?: string;
+    safe: true;
+    reversible: boolean;
+}
+interface FixResult {
+    applied: Fix[];
+    skipped: Fix[];
+    errors: {
+        fix: Fix;
+        error: string;
+    }[];
+    stats: {
+        filesModified: number;
+        filesDeleted: number;
+        linesRemoved: number;
+        backupPath?: string;
+    };
+}
+interface Suggestion {
+    type: 'rename' | 'move' | 'merge' | 'split' | 'delete' | 'update-docs' | 'add-export' | 'refactor';
+    priority: 'high' | 'medium' | 'low';
+    source: 'drift' | 'dead-code' | 'pattern';
+    relatedIssues: string[];
+    title: string;
+    description: string;
+    files: string[];
+    steps: string[];
+    preview?: {
+        file: string;
+        diff: string;
+    };
+    whyManual: string;
+}
+interface SuggestionReport {
+    suggestions: Suggestion[];
+    byPriority: {
+        high: Suggestion[];
+        medium: Suggestion[];
+        low: Suggestion[];
+    };
+    estimatedEffort: 'trivial' | 'small' | 'medium' | 'large';
+}
+interface AnalysisError {
+    analyzer: 'drift' | 'deadCode' | 'patterns';
+    error: EntropyError;
+}
+interface EntropyReport {
+    snapshot: CodebaseSnapshot;
+    drift?: DriftReport;
+    deadCode?: DeadCodeReport;
+    patterns?: PatternReport;
+    analysisErrors: AnalysisError[];
+    summary: {
+        totalIssues: number;
+        errors: number;
+        warnings: number;
+        fixableCount: number;
+        suggestionCount: number;
+    };
+    timestamp: string;
+    duration: number;
+}
+
+type ErrorCode = string;
+interface BaseError {
+    code: ErrorCode;
+    message: string;
+    details: Record<string, unknown>;
+    suggestions: string[];
+}
+interface ValidationError extends BaseError {
+    code: 'INVALID_TYPE' | 'MISSING_FIELD' | 'VALIDATION_FAILED' | 'PARSE_ERROR';
+}
+interface ContextError extends BaseError {
+    code: 'PARSE_ERROR' | 'SCHEMA_VIOLATION' | 'MISSING_SECTION' | 'BROKEN_LINK';
+}
+interface ConstraintError extends BaseError {
+    code: 'WRONG_LAYER' | 'CIRCULAR_DEP' | 'FORBIDDEN_IMPORT' | 'BOUNDARY_ERROR' | 'PARSER_UNAVAILABLE';
+}
+
+interface FeedbackError$1 extends BaseError {
+    code: 'AGENT_SPAWN_ERROR' | 'AGENT_TIMEOUT' | 'TELEMETRY_ERROR' | 'TELEMETRY_UNAVAILABLE' | 'REVIEW_ERROR' | 'DIFF_PARSE_ERROR' | 'SINK_ERROR';
+    details: {
+        agentId?: string;
+        service?: string;
+        reason?: string;
+        originalError?: Error;
+    };
+}
+declare function createError<T extends BaseError>(code: T['code'], message: string, details?: Record<string, unknown>, suggestions?: string[]): T;
+
+interface Convention {
+    pattern: string;
+    required: boolean;
+    description: string;
+    examples: string[];
+}
+interface StructureValidation {
+    valid: boolean;
+    missing: string[];
+    unexpected: string[];
+    conformance: number;
+}
+interface ConfigError extends ValidationError {
+    code: 'INVALID_TYPE' | 'MISSING_FIELD' | 'VALIDATION_FAILED';
+    details: {
+        zodError?: unknown;
+        path?: string[];
+    };
+}
+type CommitFormat = 'conventional' | 'angular' | 'custom';
+interface CommitValidation {
+    valid: boolean;
+    type?: string;
+    scope?: string;
+    breaking: boolean;
+    issues: string[];
+}
+
+declare function validateFileStructure(projectPath: string, conventions: Convention[]): Promise<Result<StructureValidation, ValidationError>>;
+
+/**
+ * Validates configuration data against a Zod schema
+ * Returns a Result type with validated data or ConfigError
+ *
+ * @template T - The type of data being validated
+ * @param data - The configuration data to validate
+ * @param schema - Zod schema to validate against
+ * @returns Result<T, ConfigError> - Success with validated data or error
+ */
+declare function validateConfig<T>(data: unknown, schema: z.ZodSchema<T>): Result<T, ConfigError>;
+
+/**
+ * Validates a commit message according to the specified format
+ * Returns a Result type with validation details
+ *
+ * @param message - The commit message to validate
+ * @param format - The commit format to validate against ('conventional', 'angular', 'custom')
+ * @returns Result<CommitValidation, ValidationError> - Success with validation details or error
+ */
+declare function validateCommitMessage(message: string, format?: CommitFormat): Result<CommitValidation, ValidationError>;
+
+interface AgentMapLink {
+    text: string;
+    path: string;
+    exists: boolean;
+    line: number;
+    error?: ContextError;
+}
+interface AgentMapSection {
+    title: string;
+    level: number;
+    links: AgentMapLink[];
+    description?: string;
+    line: number;
+}
+interface AgentMapValidation {
+    valid: boolean;
+    sections: AgentMapSection[];
+    totalLinks: number;
+    brokenLinks: AgentMapLink[];
+    missingSections: string[];
+    errors?: ContextError[];
+}
+interface DocumentationGap {
+    file: string;
+    suggestedSection: string;
+    importance: 'high' | 'medium' | 'low';
+}
+interface CoverageReport {
+    domain: string;
+    documented: string[];
+    undocumented: string[];
+    coveragePercentage: number;
+    gaps: DocumentationGap[];
+}
+interface CoverageOptions {
+    docsDir?: string;
+    sourceDir?: string;
+    excludePatterns?: string[];
+}
+interface BrokenLink {
+    text: string;
+    path: string;
+    line: number;
+    section: string;
+    reason: 'NOT_FOUND' | 'PERMISSION_DENIED' | 'INVALID_PATH';
+    suggestion: string;
+}
+interface IntegrityReport {
+    totalLinks: number;
+    brokenLinks: BrokenLink[];
+    validLinks: number;
+    integrity: number;
+}
+interface GenerationSection {
+    name: string;
+    pattern: string;
+    description: string;
+}
+interface AgentsMapConfig {
+    rootDir: string;
+    includePaths: string[];
+    excludePaths: string[];
+    template?: string;
+    sections?: GenerationSection[];
+}
+declare const REQUIRED_SECTIONS: readonly ["Project Overview", "Repository Structure", "Development Workflow"];
+
+interface ExtractedLink {
+    text: string;
+    path: string;
+    line: number;
+}
+/**
+ * Extract markdown links from content
+ * Pattern: [text](path)
+ */
+declare function extractMarkdownLinks(content: string): ExtractedLink[];
+/**
+ * Extract sections from markdown content
+ * Pattern: # Heading or ## Heading etc.
+ */
+declare function extractSections(content: string): AgentMapSection[];
+/**
+ * Validate an AGENTS.md file
+ * - Parses sections and links
+ * - Checks for required sections
+ * - Verifies all links point to existing files
+ */
+declare function validateAgentsMap(path?: string): Promise<Result<AgentMapValidation, ContextError>>;
+
+/**
+ * Check documentation coverage for a domain
+ */
+declare function checkDocCoverage(domain: string, options?: CoverageOptions): Promise<Result<CoverageReport, ContextError>>;
+
+/**
+ * Validate knowledge map integrity (all links in AGENTS.md and docs)
+ */
+declare function validateKnowledgeMap(rootDir?: string): Promise<Result<IntegrityReport, ContextError>>;
+
+/**
+ * Generate AGENTS.md content from project structure
+ */
+declare function generateAgentsMap(config: AgentsMapConfig): Promise<Result<string, ContextError>>;
+
+interface TokenBudget {
+    total: number;
+    systemPrompt: number;
+    projectManifest: number;
+    taskSpec: number;
+    activeCode: number;
+    interfaces: number;
+    reserve: number;
+}
+interface TokenBudgetOverrides {
+    systemPrompt?: number;
+    projectManifest?: number;
+    taskSpec?: number;
+    activeCode?: number;
+    interfaces?: number;
+    reserve?: number;
+}
+
+declare function contextBudget(totalTokens: number, overrides?: TokenBudgetOverrides): TokenBudget;
+
+type WorkflowPhase = 'implement' | 'review' | 'debug' | 'plan';
+interface FileCategory {
+    category: string;
+    patterns: string[];
+    priority: number;
+}
+interface ContextFilterResult {
+    phase: WorkflowPhase;
+    includedCategories: string[];
+    excludedCategories: string[];
+    filePatterns: string[];
+}
+
+declare function contextFilter(phase: WorkflowPhase, maxCategories?: number): ContextFilterResult;
+declare function getPhaseCategories(phase: WorkflowPhase): FileCategory[];
+
+/**
+ * Create a layer definition
+ */
+declare function defineLayer(name: string, patterns: string[], allowedDependencies: string[]): Layer;
+/**
+ * Resolve a file path to its layer
+ */
+declare function resolveFileToLayer(file: string, layers: Layer[]): Layer | undefined;
+
+/**
+ * Build a dependency graph from a list of files
+ * Note: buildDependencyGraph is exported as an addition beyond spec for advanced use cases
+ */
+declare function buildDependencyGraph(files: string[], parser: LanguageParser): Promise<Result<DependencyGraph, ConstraintError>>;
+/**
+ * Validate dependencies against layer rules
+ */
+declare function validateDependencies(config: LayerConfig): Promise<Result<DependencyValidation, ConstraintError>>;
+
+/**
+ * Detect circular dependencies in a dependency graph
+ */
+declare function detectCircularDeps(graph: DependencyGraph): Result<CircularDepsResult, ConstraintError>;
+/**
+ * Detect circular dependencies from a list of files
+ */
+declare function detectCircularDepsInFiles(files: string[], parser: LanguageParser): Promise<Result<CircularDepsResult, ConstraintError>>;
+
+/**
+ * Create a boundary validator from a Zod schema
+ */
+declare function createBoundaryValidator<T>(schema: z.ZodSchema<T>, name: string): BoundaryValidator<T>;
+/**
+ * Validate multiple boundaries at once
+ */
+declare function validateBoundaries(boundaries: BoundaryDefinition[], data: Map<string, unknown>): Result<BoundaryValidation, ConstraintError>;
+
+/**
+ * Main entropy analysis orchestrator
+ */
+declare class EntropyAnalyzer {
+    private config;
+    private snapshot?;
+    private report?;
+    constructor(config: EntropyConfig);
+    /**
+     * Run full entropy analysis
+     */
+    analyze(): Promise<Result<EntropyReport, EntropyError>>;
+    /**
+     * Get the built snapshot (must call analyze first)
+     */
+    getSnapshot(): CodebaseSnapshot | undefined;
+    /**
+     * Get the last report (must call analyze first)
+     */
+    getReport(): EntropyReport | undefined;
+    /**
+     * Generate suggestions from the last analysis
+     */
+    getSuggestions(): SuggestionReport;
+    /**
+     * Build snapshot without running analysis
+     */
+    buildSnapshot(): Promise<Result<CodebaseSnapshot, EntropyError>>;
+    /**
+     * Ensure snapshot is built, returning the snapshot or an error
+     */
+    private ensureSnapshot;
+    /**
+     * Run drift detection only (snapshot must be built first)
+     */
+    detectDrift(config?: Partial<DriftConfig>): Promise<Result<DriftReport, EntropyError>>;
+    /**
+     * Run dead code detection only (snapshot must be built first)
+     */
+    detectDeadCode(): Promise<Result<DeadCodeReport, EntropyError>>;
+    /**
+     * Run pattern detection only (snapshot must be built first)
+     */
+    detectPatterns(config: PatternConfig): Promise<Result<PatternReport, EntropyError>>;
+}
+
+/**
+ * Resolve entry points for dead code analysis
+ *
+ * Entry points are the starting files from which reachability analysis begins.
+ * The resolution order is:
+ * 1. Explicit entries provided as arguments
+ * 2. package.json exports/main/bin fields
+ * 3. Conventional entry files (src/index.ts, index.ts, etc.)
+ */
+declare function resolveEntryPoints(rootDir: string, explicitEntries?: string[]): Promise<Result<string[], EntropyError>>;
+/**
+ * Parse a documentation file
+ */
+declare function parseDocumentationFile(path: string): Promise<Result<DocumentationFile, EntropyError>>;
+/**
+ * Build a complete CodebaseSnapshot
+ */
+declare function buildSnapshot(config: EntropyConfig): Promise<Result<CodebaseSnapshot, EntropyError>>;
+
+/**
+ * Calculate Levenshtein distance between two strings
+ */
+declare function levenshteinDistance(a: string, b: string): number;
+/**
+ * Find possible matches for a reference in a list of exports
+ */
+declare function findPossibleMatches(reference: string, exportNames: string[], maxDistance?: number): string[];
+/**
+ * Detect documentation drift in a codebase
+ */
+declare function detectDocDrift(snapshot: CodebaseSnapshot, config?: Partial<DriftConfig>): Promise<Result<DriftReport, EntropyError>>;
+
+/**
+ * Build a map of file reachability from entry points
+ */
+declare function buildReachabilityMap(snapshot: CodebaseSnapshot): Map<string, boolean>;
+/**
+ * Detect dead code in a codebase snapshot.
+ * Analyzes exports, files, imports, and internal symbols to find unused code.
+ */
+declare function detectDeadCode(snapshot: CodebaseSnapshot): Promise<Result<DeadCodeReport, EntropyError>>;
+
+/**
+ * Check a single config pattern against a file
+ */
+declare function checkConfigPattern(pattern: ConfigPattern, file: SourceFile, rootDir: string): PatternMatch[];
+/**
+ * Detect pattern violations across a codebase
+ */
+declare function detectPatternViolations(snapshot: CodebaseSnapshot, config?: PatternConfig): Promise<Result<PatternReport, EntropyError>>;
+
+/**
+ * Create fixes from dead code report
+ */
+declare function createFixes(deadCodeReport: DeadCodeReport, config?: Partial<FixConfig>): Fix[];
+/**
+ * Preview what a fix would do
+ */
+declare function previewFix(fix: Fix): string;
+/**
+ * Apply fixes to codebase
+ */
+declare function applyFixes(fixes: Fix[], config?: Partial<FixConfig>): Promise<Result<FixResult, EntropyError>>;
+
+/**
+ * Generate all suggestions from analysis reports
+ */
+declare function generateSuggestions(deadCode?: DeadCodeReport, drift?: DriftReport, patterns?: PatternReport): SuggestionReport;
+
+declare const PatternConfigSchema: z.ZodObject<{
+    patterns: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodString;
+        severity: z.ZodEnum<["error", "warning"]>;
+        files: z.ZodArray<z.ZodString, "many">;
+        rule: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+            type: z.ZodLiteral<"must-export">;
+            names: z.ZodArray<z.ZodString, "many">;
+        }, "strip", z.ZodTypeAny, {
+            type: "must-export";
+            names: string[];
+        }, {
+            type: "must-export";
+            names: string[];
+        }>, z.ZodObject<{
+            type: z.ZodLiteral<"must-export-default">;
+            kind: z.ZodOptional<z.ZodEnum<["class", "function", "object"]>>;
+        }, "strip", z.ZodTypeAny, {
+            type: "must-export-default";
+            kind?: "object" | "function" | "class" | undefined;
+        }, {
+            type: "must-export-default";
+            kind?: "object" | "function" | "class" | undefined;
+        }>, z.ZodObject<{
+            type: z.ZodLiteral<"no-export">;
+            names: z.ZodArray<z.ZodString, "many">;
+        }, "strip", z.ZodTypeAny, {
+            type: "no-export";
+            names: string[];
+        }, {
+            type: "no-export";
+            names: string[];
+        }>, z.ZodObject<{
+            type: z.ZodLiteral<"must-import">;
+            from: z.ZodString;
+            names: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            type: "must-import";
+            from: string;
+            names?: string[] | undefined;
+        }, {
+            type: "must-import";
+            from: string;
+            names?: string[] | undefined;
+        }>, z.ZodObject<{
+            type: z.ZodLiteral<"no-import">;
+            from: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            type: "no-import";
+            from: string;
+        }, {
+            type: "no-import";
+            from: string;
+        }>, z.ZodObject<{
+            type: z.ZodLiteral<"naming">;
+            match: z.ZodString;
+            convention: z.ZodEnum<["camelCase", "PascalCase", "UPPER_SNAKE", "kebab-case"]>;
+        }, "strip", z.ZodTypeAny, {
+            match: string;
+            type: "naming";
+            convention: "camelCase" | "PascalCase" | "UPPER_SNAKE" | "kebab-case";
+        }, {
+            match: string;
+            type: "naming";
+            convention: "camelCase" | "PascalCase" | "UPPER_SNAKE" | "kebab-case";
+        }>, z.ZodObject<{
+            type: z.ZodLiteral<"max-exports">;
+            count: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            type: "max-exports";
+            count: number;
+        }, {
+            type: "max-exports";
+            count: number;
+        }>, z.ZodObject<{
+            type: z.ZodLiteral<"max-lines">;
+            count: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            type: "max-lines";
+            count: number;
+        }, {
+            type: "max-lines";
+            count: number;
+        }>, z.ZodObject<{
+            type: z.ZodLiteral<"require-jsdoc">;
+            for: z.ZodArray<z.ZodEnum<["function", "class", "export"]>, "many">;
+        }, "strip", z.ZodTypeAny, {
+            type: "require-jsdoc";
+            for: ("function" | "class" | "export")[];
+        }, {
+            type: "require-jsdoc";
+            for: ("function" | "class" | "export")[];
+        }>]>;
+        message: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        files: string[];
+        name: string;
+        description: string;
+        severity: "error" | "warning";
+        rule: {
+            type: "must-export";
+            names: string[];
+        } | {
+            type: "must-export-default";
+            kind?: "object" | "function" | "class" | undefined;
+        } | {
+            type: "no-export";
+            names: string[];
+        } | {
+            type: "must-import";
+            from: string;
+            names?: string[] | undefined;
+        } | {
+            type: "no-import";
+            from: string;
+        } | {
+            match: string;
+            type: "naming";
+            convention: "camelCase" | "PascalCase" | "UPPER_SNAKE" | "kebab-case";
+        } | {
+            type: "max-exports";
+            count: number;
+        } | {
+            type: "max-lines";
+            count: number;
+        } | {
+            type: "require-jsdoc";
+            for: ("function" | "class" | "export")[];
+        };
+        message?: string | undefined;
+    }, {
+        files: string[];
+        name: string;
+        description: string;
+        severity: "error" | "warning";
+        rule: {
+            type: "must-export";
+            names: string[];
+        } | {
+            type: "must-export-default";
+            kind?: "object" | "function" | "class" | undefined;
+        } | {
+            type: "no-export";
+            names: string[];
+        } | {
+            type: "must-import";
+            from: string;
+            names?: string[] | undefined;
+        } | {
+            type: "no-import";
+            from: string;
+        } | {
+            match: string;
+            type: "naming";
+            convention: "camelCase" | "PascalCase" | "UPPER_SNAKE" | "kebab-case";
+        } | {
+            type: "max-exports";
+            count: number;
+        } | {
+            type: "max-lines";
+            count: number;
+        } | {
+            type: "require-jsdoc";
+            for: ("function" | "class" | "export")[];
+        };
+        message?: string | undefined;
+    }>, "many">;
+    customPatterns: z.ZodOptional<z.ZodArray<z.ZodAny, "many">>;
+    ignoreFiles: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    patterns: {
+        files: string[];
+        name: string;
+        description: string;
+        severity: "error" | "warning";
+        rule: {
+            type: "must-export";
+            names: string[];
+        } | {
+            type: "must-export-default";
+            kind?: "object" | "function" | "class" | undefined;
+        } | {
+            type: "no-export";
+            names: string[];
+        } | {
+            type: "must-import";
+            from: string;
+            names?: string[] | undefined;
+        } | {
+            type: "no-import";
+            from: string;
+        } | {
+            match: string;
+            type: "naming";
+            convention: "camelCase" | "PascalCase" | "UPPER_SNAKE" | "kebab-case";
+        } | {
+            type: "max-exports";
+            count: number;
+        } | {
+            type: "max-lines";
+            count: number;
+        } | {
+            type: "require-jsdoc";
+            for: ("function" | "class" | "export")[];
+        };
+        message?: string | undefined;
+    }[];
+    customPatterns?: any[] | undefined;
+    ignoreFiles?: string[] | undefined;
+}, {
+    patterns: {
+        files: string[];
+        name: string;
+        description: string;
+        severity: "error" | "warning";
+        rule: {
+            type: "must-export";
+            names: string[];
+        } | {
+            type: "must-export-default";
+            kind?: "object" | "function" | "class" | undefined;
+        } | {
+            type: "no-export";
+            names: string[];
+        } | {
+            type: "must-import";
+            from: string;
+            names?: string[] | undefined;
+        } | {
+            type: "no-import";
+            from: string;
+        } | {
+            match: string;
+            type: "naming";
+            convention: "camelCase" | "PascalCase" | "UPPER_SNAKE" | "kebab-case";
+        } | {
+            type: "max-exports";
+            count: number;
+        } | {
+            type: "max-lines";
+            count: number;
+        } | {
+            type: "require-jsdoc";
+            for: ("function" | "class" | "export")[];
+        };
+        message?: string | undefined;
+    }[];
+    customPatterns?: any[] | undefined;
+    ignoreFiles?: string[] | undefined;
+}>;
+declare const EntropyConfigSchema: z.ZodObject<{
+    rootDir: z.ZodString;
+    parser: z.ZodOptional<z.ZodAny>;
+    entryPoints: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    analyze: z.ZodObject<{
+        drift: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodObject<{
+            docPaths: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            checkApiSignatures: z.ZodOptional<z.ZodBoolean>;
+            checkExamples: z.ZodOptional<z.ZodBoolean>;
+            checkStructure: z.ZodOptional<z.ZodBoolean>;
+            ignorePatterns: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            docPaths?: string[] | undefined;
+            checkApiSignatures?: boolean | undefined;
+            checkExamples?: boolean | undefined;
+            checkStructure?: boolean | undefined;
+            ignorePatterns?: string[] | undefined;
+        }, {
+            docPaths?: string[] | undefined;
+            checkApiSignatures?: boolean | undefined;
+            checkExamples?: boolean | undefined;
+            checkStructure?: boolean | undefined;
+            ignorePatterns?: string[] | undefined;
+        }>]>>;
+        deadCode: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodObject<{
+            entryPoints: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            includeTypes: z.ZodOptional<z.ZodBoolean>;
+            includeInternals: z.ZodOptional<z.ZodBoolean>;
+            ignorePatterns: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            treatDynamicImportsAs: z.ZodOptional<z.ZodEnum<["used", "unknown"]>>;
+        }, "strip", z.ZodTypeAny, {
+            ignorePatterns?: string[] | undefined;
+            entryPoints?: string[] | undefined;
+            includeTypes?: boolean | undefined;
+            includeInternals?: boolean | undefined;
+            treatDynamicImportsAs?: "used" | "unknown" | undefined;
+        }, {
+            ignorePatterns?: string[] | undefined;
+            entryPoints?: string[] | undefined;
+            includeTypes?: boolean | undefined;
+            includeInternals?: boolean | undefined;
+            treatDynamicImportsAs?: "used" | "unknown" | undefined;
+        }>]>>;
+        patterns: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodObject<{
+            patterns: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                description: z.ZodString;
+                severity: z.ZodEnum<["error", "warning"]>;
+                files: z.ZodArray<z.ZodString, "many">;
+                rule: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+                    type: z.ZodLiteral<"must-export">;
+                    names: z.ZodArray<z.ZodString, "many">;
+                }, "strip", z.ZodTypeAny, {
+                    type: "must-export";
+                    names: string[];
+                }, {
+                    type: "must-export";
+                    names: string[];
+                }>, z.ZodObject<{
+                    type: z.ZodLiteral<"must-export-default">;
+                    kind: z.ZodOptional<z.ZodEnum<["class", "function", "object"]>>;
+                }, "strip", z.ZodTypeAny, {
+                    type: "must-export-default";
+                    kind?: "object" | "function" | "class" | undefined;
+                }, {
+                    type: "must-export-default";
+                    kind?: "object" | "function" | "class" | undefined;
+                }>, z.ZodObject<{
+                    type: z.ZodLiteral<"no-export">;
+                    names: z.ZodArray<z.ZodString, "many">;
+                }, "strip", z.ZodTypeAny, {
+                    type: "no-export";
+                    names: string[];
+                }, {
+                    type: "no-export";
+                    names: string[];
+                }>, z.ZodObject<{
+                    type: z.ZodLiteral<"must-import">;
+                    from: z.ZodString;
+                    names: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+                }, "strip", z.ZodTypeAny, {
+                    type: "must-import";
+                    from: string;
+                    names?: string[] | undefined;
+                }, {
+                    type: "must-import";
+                    from: string;
+                    names?: string[] | undefined;
+                }>, z.ZodObject<{
+                    type: z.ZodLiteral<"no-import">;
+                    from: z.ZodString;
+                }, "strip", z.ZodTypeAny, {
+                    type: "no-import";
+                    from: string;
+                }, {
+                    type: "no-import";
+                    from: string;
+                }>, z.ZodObject<{
+                    type: z.ZodLiteral<"naming">;
+                    match: z.ZodString;
+                    convention: z.ZodEnum<["camelCase", "PascalCase", "UPPER_SNAKE", "kebab-case"]>;
+                }, "strip", z.ZodTypeAny, {
+                    match: string;
+                    type: "naming";
+                    convention: "camelCase" | "PascalCase" | "UPPER_SNAKE" | "kebab-case";
+                }, {
+                    match: string;
+                    type: "naming";
+                    convention: "camelCase" | "PascalCase" | "UPPER_SNAKE" | "kebab-case";
+                }>, z.ZodObject<{
+                    type: z.ZodLiteral<"max-exports">;
+                    count: z.ZodNumber;
+                }, "strip", z.ZodTypeAny, {
+                    type: "max-exports";
+                    count: number;
+                }, {
+                    type: "max-exports";
+                    count: number;
+                }>, z.ZodObject<{
+                    type: z.ZodLiteral<"max-lines">;
+                    count: z.ZodNumber;
+                }, "strip", z.ZodTypeAny, {
+                    type: "max-lines";
+                    count: number;
+                }, {
+                    type: "max-lines";
+                    count: number;
+                }>, z.ZodObject<{
+                    type: z.ZodLiteral<"require-jsdoc">;
+                    for: z.ZodArray<z.ZodEnum<["function", "class", "export"]>, "many">;
+                }, "strip", z.ZodTypeAny, {
+                    type: "require-jsdoc";
+                    for: ("function" | "class" | "export")[];
+                }, {
+                    type: "require-jsdoc";
+                    for: ("function" | "class" | "export")[];
+                }>]>;
+                message: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                files: string[];
+                name: string;
+                description: string;
+                severity: "error" | "warning";
+                rule: {
+                    type: "must-export";
+                    names: string[];
+                } | {
+                    type: "must-export-default";
+                    kind?: "object" | "function" | "class" | undefined;
+                } | {
+                    type: "no-export";
+                    names: string[];
+                } | {
+                    type: "must-import";
+                    from: string;
+                    names?: string[] | undefined;
+                } | {
+                    type: "no-import";
+                    from: string;
+                } | {
+                    match: string;
+                    type: "naming";
+                    convention: "camelCase" | "PascalCase" | "UPPER_SNAKE" | "kebab-case";
+                } | {
+                    type: "max-exports";
+                    count: number;
+                } | {
+                    type: "max-lines";
+                    count: number;
+                } | {
+                    type: "require-jsdoc";
+                    for: ("function" | "class" | "export")[];
+                };
+                message?: string | undefined;
+            }, {
+                files: string[];
+                name: string;
+                description: string;
+                severity: "error" | "warning";
+                rule: {
+                    type: "must-export";
+                    names: string[];
+                } | {
+                    type: "must-export-default";
+                    kind?: "object" | "function" | "class" | undefined;
+                } | {
+                    type: "no-export";
+                    names: string[];
+                } | {
+                    type: "must-import";
+                    from: string;
+                    names?: string[] | undefined;
+                } | {
+                    type: "no-import";
+                    from: string;
+                } | {
+                    match: string;
+                    type: "naming";
+                    convention: "camelCase" | "PascalCase" | "UPPER_SNAKE" | "kebab-case";
+                } | {
+                    type: "max-exports";
+                    count: number;
+                } | {
+                    type: "max-lines";
+                    count: number;
+                } | {
+                    type: "require-jsdoc";
+                    for: ("function" | "class" | "export")[];
+                };
+                message?: string | undefined;
+            }>, "many">;
+            customPatterns: z.ZodOptional<z.ZodArray<z.ZodAny, "many">>;
+            ignoreFiles: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            patterns: {
+                files: string[];
+                name: string;
+                description: string;
+                severity: "error" | "warning";
+                rule: {
+                    type: "must-export";
+                    names: string[];
+                } | {
+                    type: "must-export-default";
+                    kind?: "object" | "function" | "class" | undefined;
+                } | {
+                    type: "no-export";
+                    names: string[];
+                } | {
+                    type: "must-import";
+                    from: string;
+                    names?: string[] | undefined;
+                } | {
+                    type: "no-import";
+                    from: string;
+                } | {
+                    match: string;
+                    type: "naming";
+                    convention: "camelCase" | "PascalCase" | "UPPER_SNAKE" | "kebab-case";
+                } | {
+                    type: "max-exports";
+                    count: number;
+                } | {
+                    type: "max-lines";
+                    count: number;
+                } | {
+                    type: "require-jsdoc";
+                    for: ("function" | "class" | "export")[];
+                };
+                message?: string | undefined;
+            }[];
+            customPatterns?: any[] | undefined;
+            ignoreFiles?: string[] | undefined;
+        }, {
+            patterns: {
+                files: string[];
+                name: string;
+                description: string;
+                severity: "error" | "warning";
+                rule: {
+                    type: "must-export";
+                    names: string[];
+                } | {
+                    type: "must-export-default";
+                    kind?: "object" | "function" | "class" | undefined;
+                } | {
+                    type: "no-export";
+                    names: string[];
+                } | {
+                    type: "must-import";
+                    from: string;
+                    names?: string[] | undefined;
+                } | {
+                    type: "no-import";
+                    from: string;
+                } | {
+                    match: string;
+                    type: "naming";
+                    convention: "camelCase" | "PascalCase" | "UPPER_SNAKE" | "kebab-case";
+                } | {
+                    type: "max-exports";
+                    count: number;
+                } | {
+                    type: "max-lines";
+                    count: number;
+                } | {
+                    type: "require-jsdoc";
+                    for: ("function" | "class" | "export")[];
+                };
+                message?: string | undefined;
+            }[];
+            customPatterns?: any[] | undefined;
+            ignoreFiles?: string[] | undefined;
+        }>]>>;
+    }, "strip", z.ZodTypeAny, {
+        drift?: boolean | {
+            docPaths?: string[] | undefined;
+            checkApiSignatures?: boolean | undefined;
+            checkExamples?: boolean | undefined;
+            checkStructure?: boolean | undefined;
+            ignorePatterns?: string[] | undefined;
+        } | undefined;
+        deadCode?: boolean | {
+            ignorePatterns?: string[] | undefined;
+            entryPoints?: string[] | undefined;
+            includeTypes?: boolean | undefined;
+            includeInternals?: boolean | undefined;
+            treatDynamicImportsAs?: "used" | "unknown" | undefined;
+        } | undefined;
+        patterns?: boolean | {
+            patterns: {
+                files: string[];
+                name: string;
+                description: string;
+                severity: "error" | "warning";
+                rule: {
+                    type: "must-export";
+                    names: string[];
+                } | {
+                    type: "must-export-default";
+                    kind?: "object" | "function" | "class" | undefined;
+                } | {
+                    type: "no-export";
+                    names: string[];
+                } | {
+                    type: "must-import";
+                    from: string;
+                    names?: string[] | undefined;
+                } | {
+                    type: "no-import";
+                    from: string;
+                } | {
+                    match: string;
+                    type: "naming";
+                    convention: "camelCase" | "PascalCase" | "UPPER_SNAKE" | "kebab-case";
+                } | {
+                    type: "max-exports";
+                    count: number;
+                } | {
+                    type: "max-lines";
+                    count: number;
+                } | {
+                    type: "require-jsdoc";
+                    for: ("function" | "class" | "export")[];
+                };
+                message?: string | undefined;
+            }[];
+            customPatterns?: any[] | undefined;
+            ignoreFiles?: string[] | undefined;
+        } | undefined;
+    }, {
+        drift?: boolean | {
+            docPaths?: string[] | undefined;
+            checkApiSignatures?: boolean | undefined;
+            checkExamples?: boolean | undefined;
+            checkStructure?: boolean | undefined;
+            ignorePatterns?: string[] | undefined;
+        } | undefined;
+        deadCode?: boolean | {
+            ignorePatterns?: string[] | undefined;
+            entryPoints?: string[] | undefined;
+            includeTypes?: boolean | undefined;
+            includeInternals?: boolean | undefined;
+            treatDynamicImportsAs?: "used" | "unknown" | undefined;
+        } | undefined;
+        patterns?: boolean | {
+            patterns: {
+                files: string[];
+                name: string;
+                description: string;
+                severity: "error" | "warning";
+                rule: {
+                    type: "must-export";
+                    names: string[];
+                } | {
+                    type: "must-export-default";
+                    kind?: "object" | "function" | "class" | undefined;
+                } | {
+                    type: "no-export";
+                    names: string[];
+                } | {
+                    type: "must-import";
+                    from: string;
+                    names?: string[] | undefined;
+                } | {
+                    type: "no-import";
+                    from: string;
+                } | {
+                    match: string;
+                    type: "naming";
+                    convention: "camelCase" | "PascalCase" | "UPPER_SNAKE" | "kebab-case";
+                } | {
+                    type: "max-exports";
+                    count: number;
+                } | {
+                    type: "max-lines";
+                    count: number;
+                } | {
+                    type: "require-jsdoc";
+                    for: ("function" | "class" | "export")[];
+                };
+                message?: string | undefined;
+            }[];
+            customPatterns?: any[] | undefined;
+            ignoreFiles?: string[] | undefined;
+        } | undefined;
+    }>;
+    include: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    exclude: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    docPaths: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    rootDir: string;
+    analyze: {
+        drift?: boolean | {
+            docPaths?: string[] | undefined;
+            checkApiSignatures?: boolean | undefined;
+            checkExamples?: boolean | undefined;
+            checkStructure?: boolean | undefined;
+            ignorePatterns?: string[] | undefined;
+        } | undefined;
+        deadCode?: boolean | {
+            ignorePatterns?: string[] | undefined;
+            entryPoints?: string[] | undefined;
+            includeTypes?: boolean | undefined;
+            includeInternals?: boolean | undefined;
+            treatDynamicImportsAs?: "used" | "unknown" | undefined;
+        } | undefined;
+        patterns?: boolean | {
+            patterns: {
+                files: string[];
+                name: string;
+                description: string;
+                severity: "error" | "warning";
+                rule: {
+                    type: "must-export";
+                    names: string[];
+                } | {
+                    type: "must-export-default";
+                    kind?: "object" | "function" | "class" | undefined;
+                } | {
+                    type: "no-export";
+                    names: string[];
+                } | {
+                    type: "must-import";
+                    from: string;
+                    names?: string[] | undefined;
+                } | {
+                    type: "no-import";
+                    from: string;
+                } | {
+                    match: string;
+                    type: "naming";
+                    convention: "camelCase" | "PascalCase" | "UPPER_SNAKE" | "kebab-case";
+                } | {
+                    type: "max-exports";
+                    count: number;
+                } | {
+                    type: "max-lines";
+                    count: number;
+                } | {
+                    type: "require-jsdoc";
+                    for: ("function" | "class" | "export")[];
+                };
+                message?: string | undefined;
+            }[];
+            customPatterns?: any[] | undefined;
+            ignoreFiles?: string[] | undefined;
+        } | undefined;
+    };
+    parser?: any;
+    docPaths?: string[] | undefined;
+    entryPoints?: string[] | undefined;
+    include?: string[] | undefined;
+    exclude?: string[] | undefined;
+}, {
+    rootDir: string;
+    analyze: {
+        drift?: boolean | {
+            docPaths?: string[] | undefined;
+            checkApiSignatures?: boolean | undefined;
+            checkExamples?: boolean | undefined;
+            checkStructure?: boolean | undefined;
+            ignorePatterns?: string[] | undefined;
+        } | undefined;
+        deadCode?: boolean | {
+            ignorePatterns?: string[] | undefined;
+            entryPoints?: string[] | undefined;
+            includeTypes?: boolean | undefined;
+            includeInternals?: boolean | undefined;
+            treatDynamicImportsAs?: "used" | "unknown" | undefined;
+        } | undefined;
+        patterns?: boolean | {
+            patterns: {
+                files: string[];
+                name: string;
+                description: string;
+                severity: "error" | "warning";
+                rule: {
+                    type: "must-export";
+                    names: string[];
+                } | {
+                    type: "must-export-default";
+                    kind?: "object" | "function" | "class" | undefined;
+                } | {
+                    type: "no-export";
+                    names: string[];
+                } | {
+                    type: "must-import";
+                    from: string;
+                    names?: string[] | undefined;
+                } | {
+                    type: "no-import";
+                    from: string;
+                } | {
+                    match: string;
+                    type: "naming";
+                    convention: "camelCase" | "PascalCase" | "UPPER_SNAKE" | "kebab-case";
+                } | {
+                    type: "max-exports";
+                    count: number;
+                } | {
+                    type: "max-lines";
+                    count: number;
+                } | {
+                    type: "require-jsdoc";
+                    for: ("function" | "class" | "export")[];
+                };
+                message?: string | undefined;
+            }[];
+            customPatterns?: any[] | undefined;
+            ignoreFiles?: string[] | undefined;
+        } | undefined;
+    };
+    parser?: any;
+    docPaths?: string[] | undefined;
+    entryPoints?: string[] | undefined;
+    include?: string[] | undefined;
+    exclude?: string[] | undefined;
+}>;
+/**
+ * Validate pattern config
+ */
+declare function validatePatternConfig(config: unknown): Result<PatternConfig, EntropyError>;
+
+interface FeedbackError extends BaseError {
+    code: 'AGENT_SPAWN_ERROR' | 'AGENT_TIMEOUT' | 'TELEMETRY_ERROR' | 'TELEMETRY_UNAVAILABLE' | 'REVIEW_ERROR' | 'DIFF_PARSE_ERROR' | 'SINK_ERROR';
+    details: {
+        agentId?: string;
+        service?: string;
+        reason?: string;
+        originalError?: Error;
+    };
+}
+interface ReviewItem {
+    id: string;
+    category: 'harness' | 'custom' | 'diff';
+    check: string;
+    passed: boolean;
+    severity: 'error' | 'warning' | 'info';
+    details: string;
+    suggestion?: string;
+    file?: string;
+    line?: number;
+}
+interface ReviewChecklist {
+    items: ReviewItem[];
+    passed: boolean;
+    summary: {
+        total: number;
+        passed: number;
+        failed: number;
+        errors: number;
+        warnings: number;
+    };
+    duration: number;
+}
+interface CodeChanges {
+    diff: string;
+    files: ChangedFile[];
+    commitMessage?: string;
+    branch?: string;
+}
+interface ChangedFile {
+    path: string;
+    status: 'added' | 'modified' | 'deleted' | 'renamed';
+    additions: number;
+    deletions: number;
+}
+interface SelfReviewConfig {
+    harness?: {
+        context?: boolean;
+        constraints?: boolean;
+        entropy?: boolean;
+    };
+    customRules?: CustomRule[];
+    diffAnalysis?: {
+        enabled: boolean;
+        checkTestCoverage?: boolean;
+        checkDocumentation?: boolean;
+        maxFileSize?: number;
+        maxChangedFiles?: number;
+        forbiddenPatterns?: ForbiddenPattern[];
+    };
+    rootDir: string;
+}
+interface CustomRule {
+    id: string;
+    name: string;
+    description: string;
+    severity: 'error' | 'warning' | 'info';
+    check: (changes: CodeChanges, rootDir: string) => Promise<CustomRuleResult>;
+}
+interface CustomRuleResult {
+    passed: boolean;
+    details: string;
+    suggestion?: string;
+    file?: string;
+    line?: number;
+}
+interface ForbiddenPattern {
+    pattern: string | RegExp;
+    message: string;
+    severity: 'error' | 'warning';
+    fileGlob?: string;
+}
+type AgentType = 'architecture-enforcer' | 'documentation-maintainer' | 'test-reviewer' | 'entropy-cleaner' | 'custom';
+interface AgentConfig {
+    type: AgentType;
+    customType?: string;
+    context: ReviewContext;
+    skills?: string[];
+    timeout?: number;
+}
+interface ReviewContext {
+    files: string[];
+    diff?: string;
+    commitMessage?: string;
+    metadata?: Record<string, unknown>;
+}
+interface AgentProcess {
+    id: string;
+    status: 'pending' | 'running' | 'completed' | 'failed' | 'timeout';
+    startedAt: string;
+    config: AgentConfig;
+}
+interface PeerReview {
+    agentId: string;
+    agentType: AgentType;
+    approved: boolean;
+    comments: ReviewComment[];
+    suggestions: string[];
+    duration: number;
+    completedAt: string;
+}
+interface ReviewComment {
+    file: string;
+    line?: number;
+    severity: 'error' | 'warning' | 'suggestion';
+    message: string;
+    code?: string;
+}
+interface PeerReviewOptions {
+    skills?: string[];
+    timeout?: number;
+    wait?: boolean;
+    customAgentType?: string;
+}
+interface TimeRange {
+    start: Date | string;
+    end: Date | string;
+}
+interface Metric {
+    name: string;
+    value: number;
+    unit: string;
+    timestamp: string;
+    labels: Record<string, string>;
+}
+interface Span {
+    traceId: string;
+    spanId: string;
+    parentSpanId?: string;
+    name: string;
+    service: string;
+    startTime: string;
+    endTime: string;
+    duration: number;
+    status: 'ok' | 'error';
+    attributes: Record<string, unknown>;
+    events: SpanEvent[];
+}
+interface SpanEvent {
+    name: string;
+    timestamp: string;
+    attributes: Record<string, unknown>;
+}
+interface Trace {
+    traceId: string;
+    spans: Span[];
+    rootSpan: Span;
+    duration: number;
+    service: string;
+}
+interface LogEntry {
+    timestamp: string;
+    level: 'debug' | 'info' | 'warn' | 'error';
+    message: string;
+    service: string;
+    attributes: Record<string, unknown>;
+    traceId?: string;
+    spanId?: string;
+}
+interface LogFilter {
+    level?: LogEntry['level'] | LogEntry['level'][];
+    search?: string;
+    attributes?: Record<string, unknown>;
+    limit?: number;
+}
+interface TelemetryHealth {
+    available: boolean;
+    latency?: number;
+    message?: string;
+}
+interface ExecutorHealth {
+    available: boolean;
+    maxConcurrent?: number;
+    activeProcesses?: number;
+    message?: string;
+}
+type ActionType = 'self-review' | 'peer-review' | 'telemetry-query' | 'spawn-agent' | 'kill-agent' | 'fix-apply' | 'custom';
+interface AgentAction {
+    id: string;
+    type: ActionType;
+    agentId?: string;
+    timestamp: string;
+    duration?: number;
+    status: 'started' | 'completed' | 'failed';
+    context: ActionContext;
+    result?: ActionResult;
+    error?: {
+        code: string;
+        message: string;
+    };
+}
+interface ActionContext {
+    trigger: 'manual' | 'ci' | 'scheduled' | 'agent';
+    files?: string[];
+    commitSha?: string;
+    prNumber?: number;
+    branch?: string;
+    metadata?: Record<string, unknown>;
+}
+interface ActionResult {
+    outcome: 'success' | 'partial' | 'failure';
+    summary: string;
+    data?: unknown;
+}
+type ActionEventType = 'action:started' | 'action:completed' | 'action:failed' | 'action:*';
+interface ActionEvent {
+    type: ActionEventType;
+    action: AgentAction;
+    timestamp: string;
+}
+type ActionEventHandler = (event: ActionEvent) => void | Promise<void>;
+interface TelemetryAdapter {
+    readonly name: string;
+    health(): Promise<Result<TelemetryHealth, FeedbackError>>;
+    getMetrics(service: string, timeRange: TimeRange, metricNames?: string[]): Promise<Result<Metric[], FeedbackError>>;
+    getTraces(service: string, timeRange: TimeRange, traceId?: string): Promise<Result<Trace[], FeedbackError>>;
+    getLogs(service: string, timeRange: TimeRange, filter?: LogFilter): Promise<Result<LogEntry[], FeedbackError>>;
+}
+interface AgentExecutor {
+    readonly name: string;
+    health(): Promise<Result<ExecutorHealth, FeedbackError>>;
+    spawn(config: AgentConfig): Promise<Result<AgentProcess, FeedbackError>>;
+    status(processId: string): Promise<Result<AgentProcess, FeedbackError>>;
+    wait(processId: string, timeout?: number): Promise<Result<PeerReview, FeedbackError>>;
+    kill(processId: string): Promise<Result<void, FeedbackError>>;
+}
+interface ActionSink {
+    readonly name: string;
+    write(action: AgentAction): Promise<Result<void, FeedbackError>>;
+    flush?(): Promise<Result<void, FeedbackError>>;
+    close?(): Promise<void>;
+}
+interface ActionTracker {
+    readonly action: AgentAction;
+    complete(result: ActionResult): Promise<Result<AgentAction, FeedbackError>>;
+    fail(error: {
+        code: string;
+        message: string;
+    }): Promise<Result<AgentAction, FeedbackError>>;
+}
+
+interface FeedbackConfig {
+    telemetry?: TelemetryAdapter;
+    executor?: AgentExecutor;
+    sinks?: ActionSink[];
+    emitEvents?: boolean;
+    defaultTimeout?: number;
+    rootDir?: string;
+}
+declare function configureFeedback(config: Partial<FeedbackConfig>): void;
+declare function getFeedbackConfig(): Readonly<FeedbackConfig>;
+declare function resetFeedbackConfig(): void;
+
+declare class ChecklistBuilder {
+    private rootDir;
+    private harnessOptions?;
+    private customRules;
+    private diffOptions?;
+    constructor(rootDir: string);
+    withHarnessChecks(options?: SelfReviewConfig['harness']): this;
+    addRule(rule: CustomRule): this;
+    addRules(rules: CustomRule[]): this;
+    withDiffAnalysis(options: SelfReviewConfig['diffAnalysis']): this;
+    run(changes: CodeChanges): Promise<Result<ReviewChecklist, FeedbackError>>;
+}
+
+declare function createSelfReview(changes: CodeChanges, config: SelfReviewConfig): Promise<Result<ReviewChecklist, FeedbackError>>;
+
+declare function parseDiff(diff: string): Result<CodeChanges, FeedbackError>;
+declare function analyzeDiff(changes: CodeChanges, options: SelfReviewConfig['diffAnalysis']): Promise<Result<ReviewItem[], FeedbackError>>;
+
+declare function requestPeerReview(agentType: AgentType, context: ReviewContext, options?: PeerReviewOptions): Promise<Result<PeerReview, FeedbackError>>;
+declare function requestMultiplePeerReviews(requests: Array<{
+    agentType: AgentType;
+    context: ReviewContext;
+    options?: PeerReviewOptions;
+}>): Promise<Result<PeerReview[], FeedbackError>>;
+
+declare class NoOpTelemetryAdapter implements TelemetryAdapter {
+    readonly name = "noop";
+    health(): Promise<Result<TelemetryHealth, FeedbackError>>;
+    getMetrics(): Promise<Result<Metric[], FeedbackError>>;
+    getTraces(): Promise<Result<Trace[], FeedbackError>>;
+    getLogs(): Promise<Result<LogEntry[], FeedbackError>>;
+}
+
+declare class NoOpExecutor implements AgentExecutor {
+    readonly name = "noop";
+    private processes;
+    health(): Promise<Result<ExecutorHealth, FeedbackError>>;
+    spawn(config: AgentConfig): Promise<Result<AgentProcess, FeedbackError>>;
+    status(processId: string): Promise<Result<AgentProcess, FeedbackError>>;
+    wait(processId: string): Promise<Result<PeerReview, FeedbackError>>;
+    kill(processId: string): Promise<Result<void, FeedbackError>>;
+}
+
+declare class AgentActionEmitter {
+    private listeners;
+    on(eventType: ActionEventType, handler: ActionEventHandler): () => void;
+    once(eventType: ActionEventType, handler: ActionEventHandler): () => void;
+    off(eventType: ActionEventType, handler: ActionEventHandler): void;
+    emit(event: ActionEvent): void;
+    listenerCount(eventType: ActionEventType): number;
+    removeAllListeners(): void;
+}
+declare function getActionEmitter(): AgentActionEmitter;
+declare function logAgentAction(action: Omit<AgentAction, 'id' | 'timestamp'>): Promise<Result<AgentAction, FeedbackError>>;
+declare function trackAction(type: ActionType, context: ActionContext): ActionTracker;
+
+interface ConsoleSinkOptions {
+    level?: 'debug' | 'info' | 'warn' | 'error';
+    format?: 'pretty' | 'json';
+    verbose?: boolean;
+}
+declare class ConsoleSink implements ActionSink {
+    readonly name = "console";
+    private options;
+    constructor(options?: ConsoleSinkOptions);
+    write(action: AgentAction): Promise<Result<void, FeedbackError>>;
+    private formatPretty;
+}
+
+interface FileSinkOptions {
+    mode?: 'append' | 'overwrite';
+    bufferSize?: number;
+    flushInterval?: number;
+}
+declare class FileSink implements ActionSink {
+    readonly name = "file";
+    private filePath;
+    private options;
+    private buffer;
+    private flushTimer?;
+    private initialized;
+    constructor(filePath: string, options?: FileSinkOptions);
+    private ensureDirectory;
+    write(action: AgentAction): Promise<Result<void, FeedbackError>>;
+    flush(): Promise<Result<void, FeedbackError>>;
+    close(): Promise<void>;
+}
+
+declare class NoOpSink implements ActionSink {
+    readonly name = "noop";
+    write(): Promise<Result<void, FeedbackError>>;
+}
+
+declare const FailureEntrySchema: z.ZodObject<{
+    date: z.ZodString;
+    skill: z.ZodString;
+    type: z.ZodString;
+    description: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: string;
+    date: string;
+    description: string;
+    skill: string;
+}, {
+    type: string;
+    date: string;
+    description: string;
+    skill: string;
+}>;
+type FailureEntry = z.infer<typeof FailureEntrySchema>;
+declare const HandoffSchema: z.ZodObject<{
+    timestamp: z.ZodString;
+    fromSkill: z.ZodString;
+    phase: z.ZodString;
+    summary: z.ZodString;
+    completed: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    pending: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    concerns: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    decisions: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        what: z.ZodString;
+        why: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        what: string;
+        why: string;
+    }, {
+        what: string;
+        why: string;
+    }>, "many">>;
+    blockers: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    contextKeywords: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    pending: string[];
+    completed: string[];
+    timestamp: string;
+    fromSkill: string;
+    phase: string;
+    summary: string;
+    concerns: string[];
+    decisions: {
+        what: string;
+        why: string;
+    }[];
+    blockers: string[];
+    contextKeywords: string[];
+}, {
+    timestamp: string;
+    fromSkill: string;
+    phase: string;
+    summary: string;
+    pending?: string[] | undefined;
+    completed?: string[] | undefined;
+    concerns?: string[] | undefined;
+    decisions?: {
+        what: string;
+        why: string;
+    }[] | undefined;
+    blockers?: string[] | undefined;
+    contextKeywords?: string[] | undefined;
+}>;
+type Handoff = z.infer<typeof HandoffSchema>;
+declare const GateResultSchema: z.ZodObject<{
+    passed: z.ZodBoolean;
+    checks: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        passed: z.ZodBoolean;
+        command: z.ZodString;
+        output: z.ZodOptional<z.ZodString>;
+        duration: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        passed: boolean;
+        command: string;
+        output?: string | undefined;
+        duration?: number | undefined;
+    }, {
+        name: string;
+        passed: boolean;
+        command: string;
+        output?: string | undefined;
+        duration?: number | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    passed: boolean;
+    checks: {
+        name: string;
+        passed: boolean;
+        command: string;
+        output?: string | undefined;
+        duration?: number | undefined;
+    }[];
+}, {
+    passed: boolean;
+    checks: {
+        name: string;
+        passed: boolean;
+        command: string;
+        output?: string | undefined;
+        duration?: number | undefined;
+    }[];
+}>;
+type GateResult = z.infer<typeof GateResultSchema>;
+declare const GateConfigSchema: z.ZodObject<{
+    checks: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        command: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        command: string;
+    }, {
+        name: string;
+        command: string;
+    }>, "many">>;
+    trace: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    checks?: {
+        name: string;
+        command: string;
+    }[] | undefined;
+    trace?: boolean | undefined;
+}, {
+    checks?: {
+        name: string;
+        command: string;
+    }[] | undefined;
+    trace?: boolean | undefined;
+}>;
+type GateConfig = z.infer<typeof GateConfigSchema>;
+declare const HarnessStateSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    position: z.ZodDefault<z.ZodObject<{
+        phase: z.ZodOptional<z.ZodString>;
+        task: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        phase?: string | undefined;
+        task?: string | undefined;
+    }, {
+        phase?: string | undefined;
+        task?: string | undefined;
+    }>>;
+    decisions: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        date: z.ZodString;
+        decision: z.ZodString;
+        context: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        date: string;
+        context: string;
+        decision: string;
+    }, {
+        date: string;
+        context: string;
+        decision: string;
+    }>, "many">>;
+    blockers: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        description: z.ZodString;
+        status: z.ZodEnum<["open", "resolved"]>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        status: "open" | "resolved";
+        description: string;
+    }, {
+        id: string;
+        status: "open" | "resolved";
+        description: string;
+    }>, "many">>;
+    progress: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodEnum<["pending", "in_progress", "complete"]>>>;
+    lastSession: z.ZodOptional<z.ZodObject<{
+        date: z.ZodString;
+        summary: z.ZodString;
+        lastSkill: z.ZodOptional<z.ZodString>;
+        pendingTasks: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        date: string;
+        summary: string;
+        lastSkill?: string | undefined;
+        pendingTasks?: string[] | undefined;
+    }, {
+        date: string;
+        summary: string;
+        lastSkill?: string | undefined;
+        pendingTasks?: string[] | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    decisions: {
+        date: string;
+        context: string;
+        decision: string;
+    }[];
+    blockers: {
+        id: string;
+        status: "open" | "resolved";
+        description: string;
+    }[];
+    schemaVersion: 1;
+    position: {
+        phase?: string | undefined;
+        task?: string | undefined;
+    };
+    progress: Record<string, "pending" | "in_progress" | "complete">;
+    lastSession?: {
+        date: string;
+        summary: string;
+        lastSkill?: string | undefined;
+        pendingTasks?: string[] | undefined;
+    } | undefined;
+}, {
+    schemaVersion: 1;
+    decisions?: {
+        date: string;
+        context: string;
+        decision: string;
+    }[] | undefined;
+    blockers?: {
+        id: string;
+        status: "open" | "resolved";
+        description: string;
+    }[] | undefined;
+    position?: {
+        phase?: string | undefined;
+        task?: string | undefined;
+    } | undefined;
+    progress?: Record<string, "pending" | "in_progress" | "complete"> | undefined;
+    lastSession?: {
+        date: string;
+        summary: string;
+        lastSkill?: string | undefined;
+        pendingTasks?: string[] | undefined;
+    } | undefined;
+}>;
+type HarnessState = z.infer<typeof HarnessStateSchema>;
+declare const DEFAULT_STATE: HarnessState;
+
+declare function loadState(projectPath: string): Promise<Result<HarnessState, Error>>;
+declare function saveState(projectPath: string, state: HarnessState): Promise<Result<void, Error>>;
+declare function appendLearning(projectPath: string, learning: string, skillName?: string, outcome?: string): Promise<Result<void, Error>>;
+declare function loadRelevantLearnings(projectPath: string, skillName?: string): Promise<Result<string[], Error>>;
+declare function appendFailure(projectPath: string, description: string, skillName: string, type: string): Promise<Result<void, Error>>;
+declare function loadFailures(projectPath: string): Promise<Result<Array<{
+    date: string;
+    skill: string;
+    type: string;
+    description: string;
+}>, Error>>;
+declare function archiveFailures(projectPath: string): Promise<Result<void, Error>>;
+declare function saveHandoff(projectPath: string, handoff: Handoff): Promise<Result<void, Error>>;
+declare function loadHandoff(projectPath: string): Promise<Result<Handoff | null, Error>>;
+declare function runMechanicalGate(projectPath: string): Promise<Result<GateResult, Error>>;
+
+type StepExecutor = (step: WorkflowStep, previousArtifact?: string) => Promise<WorkflowStepResult>;
+declare function executeWorkflow(workflow: Workflow, executor: StepExecutor): Promise<WorkflowResult>;
+
+interface PipelineOptions {
+    hooks?: SkillLifecycleHooks;
+    maxTurns?: number;
+}
+interface PipelineResult {
+    success: boolean;
+    context: SkillContext;
+    result?: SkillResult;
+    error?: string;
+    turnsExecuted: number;
+    durationMs: number;
+}
+type SkillExecutor = (context: SkillContext) => Promise<SkillResult>;
+type TurnExecutor = (context: TurnContext) => Promise<{
+    result: unknown;
+    done: boolean;
+}>;
+declare function runPipeline(initialContext: SkillContext, executor: SkillExecutor, options?: PipelineOptions): Promise<PipelineResult>;
+declare function runMultiTurnPipeline(initialContext: SkillContext, turnExecutor: TurnExecutor, options?: PipelineOptions): Promise<PipelineResult>;
+
+/**
+ * @harness-engineering/core
+ *
+ * Core library for Harness Engineering toolkit
+ */
+
+declare const VERSION = "0.5.0";
+
+export { type AST, type ActionContext, type ActionEvent, type ActionEventHandler, type ActionEventType, type ActionResult, type ActionSink, type ActionTracker, type ActionType, type AgentAction, AgentActionEmitter, type AgentConfig, type AgentExecutor, type AgentMapLink, type AgentMapSection, type AgentMapValidation, type AgentProcess, type AgentType, type AgentsMapConfig, type BaseError, type BoundaryDefinition, type BoundaryValidation, type BoundaryValidator, type BoundaryViolation, type BrokenLink, type ChangedFile, ChecklistBuilder, type CircularDependency, type CircularDepsResult, type CodeBlock, type CodeChanges, type CodePattern, type CodeReference, type CodebaseSnapshot, type CommitFormat, type CommitValidation, type ConfigError, type ConfigPattern, ConsoleSink, type ConstraintError, type ContextError, type ContextFilterResult, type Convention, type CoverageOptions, type CoverageReport, type CustomRule, type CustomRuleResult, DEFAULT_STATE, type DeadCodeConfig, type DeadCodeReport, type DeadExport, type DeadFile, type DeadInternal, type DependencyEdge, type DependencyGraph, type DependencyValidation, type DependencyViolation, type DocumentationDrift, type DocumentationFile, type DocumentationGap, type DriftConfig, type DriftReport, EntropyAnalyzer, type EntropyConfig, EntropyConfigSchema, type EntropyError, type EntropyReport, Err, type ExecutorHealth, type Export, type ExportMap, type FailureEntry, FailureEntrySchema, type FeedbackConfig, type FeedbackError$1 as FeedbackError, type FileCategory, FileSink, type Fix, type FixConfig, type FixResult, type FixType, type ForbiddenPattern, type GateConfig, GateConfigSchema, type GateResult, GateResultSchema, type GenerationSection, type Handoff, HandoffSchema, type HarnessState, HarnessStateSchema, type HealthCheckResult, type Import, type InlineReference, type IntegrityReport, type InternalSymbol, type JSDocComment, type LanguageParser, type Layer, type LayerConfig, type LogEntry, type LogFilter, type Metric, NoOpExecutor, NoOpSink, NoOpTelemetryAdapter, Ok, type ParseError, type PatternConfig, PatternConfigSchema, type PatternMatch, type PatternReport, type PatternViolation, type PeerReview, type PeerReviewOptions, type PipelineOptions, type PipelineResult, REQUIRED_SECTIONS, type ReachabilityNode, type Result, type ReviewChecklist, type ReviewComment, type ReviewContext, type ReviewItem, type SelfReviewConfig, type SkillExecutor, type SourceFile, type Span, type SpanEvent, type StepExecutor, type StructureValidation, type Suggestion, type SuggestionReport, type TelemetryAdapter, type TelemetryHealth, type TimeRange, type TokenBudget, type TokenBudgetOverrides, type Trace, type TurnExecutor, TypeScriptParser, type UnusedImport, VERSION, type ValidationError, type WorkflowPhase, analyzeDiff, appendFailure, appendLearning, applyFixes, archiveFailures, buildDependencyGraph, buildReachabilityMap, buildSnapshot, checkConfigPattern, checkDocCoverage, configureFeedback, contextBudget, contextFilter, createBoundaryValidator, createError, createFixes, createParseError, createSelfReview, defineLayer, detectCircularDeps, detectCircularDepsInFiles, detectDeadCode, detectDocDrift, detectPatternViolations, executeWorkflow, extractMarkdownLinks, extractSections, findPossibleMatches, generateAgentsMap, generateSuggestions, getActionEmitter, getFeedbackConfig, getPhaseCategories, isErr, isOk, levenshteinDistance, loadFailures, loadHandoff, loadRelevantLearnings, loadState, logAgentAction, parseDiff, parseDocumentationFile, previewFix, requestMultiplePeerReviews, requestPeerReview, resetFeedbackConfig, resolveEntryPoints, resolveFileToLayer, runMechanicalGate, runMultiTurnPipeline, runPipeline, saveHandoff, saveState, trackAction, validateAgentsMap, validateBoundaries, validateCommitMessage, validateConfig, validateDependencies, validateFileStructure, validateKnowledgeMap, validatePatternConfig };