@harness-engineering/core 0.10.1 → 0.12.0

package/dist/index.d.mts

@@ -1,41 +1,94 @@
 import { Result, WorkflowStep, WorkflowStepResult, Workflow, WorkflowResult, SkillLifecycleHooks, SkillContext, SkillResult, TurnContext, CICheckName, CIFailOnSeverity, CICheckReport, Roadmap, FeatureStatus } from '@harness-engineering/types';
 export * from '@harness-engineering/types';
 import { z } from 'zod';
+import { C as Collector, A as ArchConfig, a as ConstraintRule, M as MetricResult, b as ArchMetricCategory, c as ArchBaseline, d as ArchDiffResult, T as ThresholdConfig } from './matchers-D20x48U9.mjs';
+export { e as ArchBaselineSchema, f as ArchConfigSchema, g as ArchDiffResultSchema, h as ArchHandle, i as ArchMetricCategorySchema, j as ArchitectureOptions, k as CategoryBaseline, l as CategoryBaselineSchema, m as CategoryRegression, n as CategoryRegressionSchema, o as ConstraintRuleSchema, p as MetricResultSchema, q as ThresholdConfigSchema, V as Violation, r as ViolationSchema, s as archMatchers, t as archModule, u as architecture } from './matchers-D20x48U9.mjs';
 
+/**
+ * Represents an error code for identifying specific error types.
+ */
 type ErrorCode = string;
+/**
+ * Base interface for all Harness Engineering errors.
+ * Provides a standardized structure for error reporting and suggestions.
+ */
 interface BaseError {
+    /** A unique code identifying the type of error. */
     code: ErrorCode;
+    /** A human-readable message describing the error. */
     message: string;
+    /** Additional structured data providing context about the error. */
     details: Record<string, unknown>;
+    /** A list of suggested actions to resolve the error. */
     suggestions: string[];
 }
+/**
+ * Error type for validation failures.
+ */
 interface ValidationError extends BaseError {
+    /** Validation-specific error codes. */
     code: 'INVALID_TYPE' | 'MISSING_FIELD' | 'VALIDATION_FAILED' | 'PARSE_ERROR';
 }
+/**
+ * Error type for context-related issues.
+ */
 interface ContextError extends BaseError {
+    /** Context-specific error codes. */
     code: 'PARSE_ERROR' | 'SCHEMA_VIOLATION' | 'MISSING_SECTION' | 'BROKEN_LINK';
 }
+/**
+ * Error type for architectural constraint violations.
+ */
 interface ConstraintError extends BaseError {
+    /** Constraint-specific error codes. */
     code: 'WRONG_LAYER' | 'CIRCULAR_DEP' | 'FORBIDDEN_IMPORT' | 'BOUNDARY_ERROR' | 'PARSER_UNAVAILABLE';
 }
+/**
+ * Error type for entropy and drift-related issues.
+ */
 interface EntropyError extends BaseError {
+    /** Entropy-specific error codes. */
     code: 'SNAPSHOT_BUILD_FAILED' | 'PARSE_ERROR' | 'ENTRY_POINT_NOT_FOUND' | 'INVALID_CONFIG' | 'CONFIG_VALIDATION_ERROR' | 'FIX_FAILED' | 'BACKUP_FAILED';
+    /** Entropy-specific error details. */
     details: {
+        /** Path to the file where the error occurred. */
         file?: string;
+        /** Reason for the error. */
         reason?: string;
+        /** List of issues detected. */
         issues?: unknown[];
+        /** The original Error object, if any. */
         originalError?: Error;
     };
 }
+/**
+ * Error type for agent feedback and review issues.
+ */
 interface FeedbackError$1 extends BaseError {
+    /** Feedback-specific error codes. */
     code: 'AGENT_SPAWN_ERROR' | 'AGENT_TIMEOUT' | 'TELEMETRY_ERROR' | 'TELEMETRY_UNAVAILABLE' | 'REVIEW_ERROR' | 'DIFF_PARSE_ERROR' | 'SINK_ERROR';
+    /** Feedback-specific error details. */
     details: {
+        /** ID of the agent involved. */
         agentId?: string;
+        /** Name of the service where the error occurred. */
         service?: string;
+        /** Reason for the error. */
         reason?: string;
+        /** The original Error object, if any. */
         originalError?: Error;
     };
 }
+/**
+ * Creates a standardized error object.
+ *
+ * @template T - The specific error type to create.
+ * @param code - The error code identifying the type of error.
+ * @param message - A human-readable message describing the error.
+ * @param details - Additional structured data providing context (default: empty record).
+ * @param suggestions - A list of suggested actions to resolve the error (default: empty array).
+ * @returns A new error object of the specified type.
+ */
 declare function createError<T extends BaseError>(code: T['code'], message: string, details?: Record<string, unknown>, suggestions?: string[]): T;
 
 interface Convention {
@@ -444,6 +497,597 @@ declare function createBoundaryValidator<T>(schema: z.ZodSchema<T>, name: string
  */
 declare function validateBoundaries(boundaries: BoundaryDefinition[], data: Map<string, unknown>): Result<BoundaryValidation, ConstraintError>;
 
+declare const ManifestSchema: z.ZodObject<{
+    name: z.ZodString;
+    version: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    include: z.ZodArray<z.ZodString, "many">;
+    minHarnessVersion: z.ZodOptional<z.ZodString>;
+    keywords: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+    layers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString, "many">>>;
+    boundaries: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        layer: z.ZodString;
+        direction: z.ZodEnum<["input", "output"]>;
+        schema: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        layer: string;
+        direction: "input" | "output";
+        schema: string;
+    }, {
+        name: string;
+        layer: string;
+        direction: "input" | "output";
+        schema: string;
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    version: string;
+    include: string[];
+    keywords: string[];
+    layers?: Record<string, string[]> | undefined;
+    description?: string | undefined;
+    minHarnessVersion?: string | undefined;
+    boundaries?: {
+        name: string;
+        layer: string;
+        direction: "input" | "output";
+        schema: string;
+    }[] | undefined;
+}, {
+    name: string;
+    version: string;
+    include: string[];
+    layers?: Record<string, string[]> | undefined;
+    description?: string | undefined;
+    minHarnessVersion?: string | undefined;
+    keywords?: string[] | undefined;
+    boundaries?: {
+        name: string;
+        layer: string;
+        direction: "input" | "output";
+        schema: string;
+    }[] | undefined;
+}>;
+type Manifest = z.infer<typeof ManifestSchema>;
+declare const BundleConstraintsSchema: z.ZodObject<{
+    layers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        pattern: z.ZodString;
+        allowedDependencies: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        pattern: string;
+        allowedDependencies: string[];
+    }, {
+        name: string;
+        pattern: string;
+        allowedDependencies: string[];
+    }>, "many">>;
+    forbiddenImports: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        from: z.ZodString;
+        disallow: z.ZodArray<z.ZodString, "many">;
+        message: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        from: string;
+        disallow: string[];
+        message?: string | undefined;
+    }, {
+        from: string;
+        disallow: string[];
+        message?: string | undefined;
+    }>, "many">>;
+    boundaries: z.ZodOptional<z.ZodObject<{
+        requireSchema: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        requireSchema?: string[] | undefined;
+    }, {
+        requireSchema?: string[] | undefined;
+    }>>;
+    architecture: z.ZodOptional<z.ZodObject<{
+        thresholds: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        modules: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    }, "strip", z.ZodTypeAny, {
+        thresholds?: Record<string, unknown> | undefined;
+        modules?: Record<string, Record<string, unknown>> | undefined;
+    }, {
+        thresholds?: Record<string, unknown> | undefined;
+        modules?: Record<string, Record<string, unknown>> | undefined;
+    }>>;
+    security: z.ZodOptional<z.ZodObject<{
+        rules: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        rules?: Record<string, string> | undefined;
+    }, {
+        rules?: Record<string, string> | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    architecture?: {
+        thresholds?: Record<string, unknown> | undefined;
+        modules?: Record<string, Record<string, unknown>> | undefined;
+    } | undefined;
+    layers?: {
+        name: string;
+        pattern: string;
+        allowedDependencies: string[];
+    }[] | undefined;
+    boundaries?: {
+        requireSchema?: string[] | undefined;
+    } | undefined;
+    forbiddenImports?: {
+        from: string;
+        disallow: string[];
+        message?: string | undefined;
+    }[] | undefined;
+    security?: {
+        rules?: Record<string, string> | undefined;
+    } | undefined;
+}, {
+    architecture?: {
+        thresholds?: Record<string, unknown> | undefined;
+        modules?: Record<string, Record<string, unknown>> | undefined;
+    } | undefined;
+    layers?: {
+        name: string;
+        pattern: string;
+        allowedDependencies: string[];
+    }[] | undefined;
+    boundaries?: {
+        requireSchema?: string[] | undefined;
+    } | undefined;
+    forbiddenImports?: {
+        from: string;
+        disallow: string[];
+        message?: string | undefined;
+    }[] | undefined;
+    security?: {
+        rules?: Record<string, string> | undefined;
+    } | undefined;
+}>;
+declare const BundleSchema: z.ZodObject<{
+    name: z.ZodString;
+    version: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    minHarnessVersion: z.ZodOptional<z.ZodString>;
+    manifest: z.ZodObject<{
+        name: z.ZodString;
+        version: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        include: z.ZodArray<z.ZodString, "many">;
+        minHarnessVersion: z.ZodOptional<z.ZodString>;
+        keywords: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+        layers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString, "many">>>;
+        boundaries: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            layer: z.ZodString;
+            direction: z.ZodEnum<["input", "output"]>;
+            schema: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            layer: string;
+            direction: "input" | "output";
+            schema: string;
+        }, {
+            name: string;
+            layer: string;
+            direction: "input" | "output";
+            schema: string;
+        }>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        version: string;
+        include: string[];
+        keywords: string[];
+        layers?: Record<string, string[]> | undefined;
+        description?: string | undefined;
+        minHarnessVersion?: string | undefined;
+        boundaries?: {
+            name: string;
+            layer: string;
+            direction: "input" | "output";
+            schema: string;
+        }[] | undefined;
+    }, {
+        name: string;
+        version: string;
+        include: string[];
+        layers?: Record<string, string[]> | undefined;
+        description?: string | undefined;
+        minHarnessVersion?: string | undefined;
+        keywords?: string[] | undefined;
+        boundaries?: {
+            name: string;
+            layer: string;
+            direction: "input" | "output";
+            schema: string;
+        }[] | undefined;
+    }>;
+    constraints: z.ZodObject<{
+        layers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            pattern: z.ZodString;
+            allowedDependencies: z.ZodArray<z.ZodString, "many">;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            pattern: string;
+            allowedDependencies: string[];
+        }, {
+            name: string;
+            pattern: string;
+            allowedDependencies: string[];
+        }>, "many">>;
+        forbiddenImports: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            from: z.ZodString;
+            disallow: z.ZodArray<z.ZodString, "many">;
+            message: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            from: string;
+            disallow: string[];
+            message?: string | undefined;
+        }, {
+            from: string;
+            disallow: string[];
+            message?: string | undefined;
+        }>, "many">>;
+        boundaries: z.ZodOptional<z.ZodObject<{
+            requireSchema: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            requireSchema?: string[] | undefined;
+        }, {
+            requireSchema?: string[] | undefined;
+        }>>;
+        architecture: z.ZodOptional<z.ZodObject<{
+            thresholds: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            modules: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+        }, "strip", z.ZodTypeAny, {
+            thresholds?: Record<string, unknown> | undefined;
+            modules?: Record<string, Record<string, unknown>> | undefined;
+        }, {
+            thresholds?: Record<string, unknown> | undefined;
+            modules?: Record<string, Record<string, unknown>> | undefined;
+        }>>;
+        security: z.ZodOptional<z.ZodObject<{
+            rules: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        }, "strip", z.ZodTypeAny, {
+            rules?: Record<string, string> | undefined;
+        }, {
+            rules?: Record<string, string> | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        architecture?: {
+            thresholds?: Record<string, unknown> | undefined;
+            modules?: Record<string, Record<string, unknown>> | undefined;
+        } | undefined;
+        layers?: {
+            name: string;
+            pattern: string;
+            allowedDependencies: string[];
+        }[] | undefined;
+        boundaries?: {
+            requireSchema?: string[] | undefined;
+        } | undefined;
+        forbiddenImports?: {
+            from: string;
+            disallow: string[];
+            message?: string | undefined;
+        }[] | undefined;
+        security?: {
+            rules?: Record<string, string> | undefined;
+        } | undefined;
+    }, {
+        architecture?: {
+            thresholds?: Record<string, unknown> | undefined;
+            modules?: Record<string, Record<string, unknown>> | undefined;
+        } | undefined;
+        layers?: {
+            name: string;
+            pattern: string;
+            allowedDependencies: string[];
+        }[] | undefined;
+        boundaries?: {
+            requireSchema?: string[] | undefined;
+        } | undefined;
+        forbiddenImports?: {
+            from: string;
+            disallow: string[];
+            message?: string | undefined;
+        }[] | undefined;
+        security?: {
+            rules?: Record<string, string> | undefined;
+        } | undefined;
+    }>;
+    contributions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    version: string;
+    manifest: {
+        name: string;
+        version: string;
+        include: string[];
+        keywords: string[];
+        layers?: Record<string, string[]> | undefined;
+        description?: string | undefined;
+        minHarnessVersion?: string | undefined;
+        boundaries?: {
+            name: string;
+            layer: string;
+            direction: "input" | "output";
+            schema: string;
+        }[] | undefined;
+    };
+    constraints: {
+        architecture?: {
+            thresholds?: Record<string, unknown> | undefined;
+            modules?: Record<string, Record<string, unknown>> | undefined;
+        } | undefined;
+        layers?: {
+            name: string;
+            pattern: string;
+            allowedDependencies: string[];
+        }[] | undefined;
+        boundaries?: {
+            requireSchema?: string[] | undefined;
+        } | undefined;
+        forbiddenImports?: {
+            from: string;
+            disallow: string[];
+            message?: string | undefined;
+        }[] | undefined;
+        security?: {
+            rules?: Record<string, string> | undefined;
+        } | undefined;
+    };
+    description?: string | undefined;
+    minHarnessVersion?: string | undefined;
+    contributions?: Record<string, unknown> | undefined;
+}, {
+    name: string;
+    version: string;
+    manifest: {
+        name: string;
+        version: string;
+        include: string[];
+        layers?: Record<string, string[]> | undefined;
+        description?: string | undefined;
+        minHarnessVersion?: string | undefined;
+        keywords?: string[] | undefined;
+        boundaries?: {
+            name: string;
+            layer: string;
+            direction: "input" | "output";
+            schema: string;
+        }[] | undefined;
+    };
+    constraints: {
+        architecture?: {
+            thresholds?: Record<string, unknown> | undefined;
+            modules?: Record<string, Record<string, unknown>> | undefined;
+        } | undefined;
+        layers?: {
+            name: string;
+            pattern: string;
+            allowedDependencies: string[];
+        }[] | undefined;
+        boundaries?: {
+            requireSchema?: string[] | undefined;
+        } | undefined;
+        forbiddenImports?: {
+            from: string;
+            disallow: string[];
+            message?: string | undefined;
+        }[] | undefined;
+        security?: {
+            rules?: Record<string, string> | undefined;
+        } | undefined;
+    };
+    description?: string | undefined;
+    minHarnessVersion?: string | undefined;
+    contributions?: Record<string, unknown> | undefined;
+}>;
+declare const ContributionsSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+type Bundle = z.infer<typeof BundleSchema>;
+type BundleConstraints = z.infer<typeof BundleConstraintsSchema>;
+type Contributions = Record<string, unknown>;
+declare const LockfilePackageSchema: z.ZodObject<{
+    version: z.ZodString;
+    source: z.ZodString;
+    installedAt: z.ZodString;
+    contributions: z.ZodNullable<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    resolved: z.ZodOptional<z.ZodString>;
+    integrity: z.ZodOptional<z.ZodString>;
+    provenance: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    source: string;
+    version: string;
+    installedAt: string;
+    contributions?: Record<string, unknown> | null | undefined;
+    resolved?: string | undefined;
+    integrity?: string | undefined;
+    provenance?: string[] | undefined;
+}, {
+    source: string;
+    version: string;
+    installedAt: string;
+    contributions?: Record<string, unknown> | null | undefined;
+    resolved?: string | undefined;
+    integrity?: string | undefined;
+    provenance?: string[] | undefined;
+}>;
+declare const LockfileSchema: z.ZodEffects<z.ZodObject<{
+    version: z.ZodOptional<z.ZodLiteral<1>>;
+    lockfileVersion: z.ZodOptional<z.ZodLiteral<1>>;
+    packages: z.ZodRecord<z.ZodString, z.ZodObject<{
+        version: z.ZodString;
+        source: z.ZodString;
+        installedAt: z.ZodString;
+        contributions: z.ZodNullable<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+        resolved: z.ZodOptional<z.ZodString>;
+        integrity: z.ZodOptional<z.ZodString>;
+        provenance: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        source: string;
+        version: string;
+        installedAt: string;
+        contributions?: Record<string, unknown> | null | undefined;
+        resolved?: string | undefined;
+        integrity?: string | undefined;
+        provenance?: string[] | undefined;
+    }, {
+        source: string;
+        version: string;
+        installedAt: string;
+        contributions?: Record<string, unknown> | null | undefined;
+        resolved?: string | undefined;
+        integrity?: string | undefined;
+        provenance?: string[] | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    packages: Record<string, {
+        source: string;
+        version: string;
+        installedAt: string;
+        contributions?: Record<string, unknown> | null | undefined;
+        resolved?: string | undefined;
+        integrity?: string | undefined;
+        provenance?: string[] | undefined;
+    }>;
+    version?: 1 | undefined;
+    lockfileVersion?: 1 | undefined;
+}, {
+    packages: Record<string, {
+        source: string;
+        version: string;
+        installedAt: string;
+        contributions?: Record<string, unknown> | null | undefined;
+        resolved?: string | undefined;
+        integrity?: string | undefined;
+        provenance?: string[] | undefined;
+    }>;
+    version?: 1 | undefined;
+    lockfileVersion?: 1 | undefined;
+}>, {
+    packages: Record<string, {
+        source: string;
+        version: string;
+        installedAt: string;
+        contributions?: Record<string, unknown> | null | undefined;
+        resolved?: string | undefined;
+        integrity?: string | undefined;
+        provenance?: string[] | undefined;
+    }>;
+    version?: 1 | undefined;
+    lockfileVersion?: 1 | undefined;
+}, {
+    packages: Record<string, {
+        source: string;
+        version: string;
+        installedAt: string;
+        contributions?: Record<string, unknown> | null | undefined;
+        resolved?: string | undefined;
+        integrity?: string | undefined;
+        provenance?: string[] | undefined;
+    }>;
+    version?: 1 | undefined;
+    lockfileVersion?: 1 | undefined;
+}>;
+type Lockfile = z.infer<typeof LockfileSchema>;
+type LockfilePackage = z.infer<typeof LockfilePackageSchema>;
+declare const SharableLayerSchema: z.ZodUnknown;
+declare const SharableForbiddenImportSchema: z.ZodUnknown;
+declare const SharableBoundaryConfigSchema: z.ZodUnknown;
+declare const SharableSecurityRulesSchema: z.ZodUnknown;
+
+/**
+ * Utility to write a config object to disk as JSON or YAML.
+ * In this implementation, we'll keep it simple and just use JSON.stringify
+ * or a placeholder for YAML if needed.
+ */
+declare function writeConfig(filePath: string, content: unknown): Promise<Result<void, Error>>;
+
+/**
+ * Parse and validate a manifest from a pre-parsed object.
+ *
+ * YAML parsing is the caller's responsibility (stays in the CLI layer).
+ * This function validates the parsed structure against ManifestSchema.
+ *
+ * @param parsed - The result of YAML.parse() or JSON.parse()
+ * @returns Result<Manifest, string>
+ */
+declare function parseManifest(parsed: unknown): Result<Manifest, string>;
+
+/**
+ * Extract a constraints bundle from a harness config using the paths declared
+ * in the manifest's `include` array.
+ *
+ * Only paths that exist in the config are included in the bundle.
+ * Missing paths are silently omitted (not an error).
+ *
+ * Supported include paths:
+ *   "layers"             → config.layers
+ *   "forbiddenImports"   → config.forbiddenImports
+ *   "boundaries"         → config.boundaries
+ *   "architecture"       → config.architecture
+ *   "security.rules"     → config.security.rules
+ *
+ * @param manifest - Validated Manifest object
+ * @param config   - The project's harness config (Record<string, unknown>)
+ * @returns Result<Bundle, string>
+ */
+declare function extractBundle(manifest: Manifest, config: Record<string, unknown>): Result<Bundle, string>;
+
+interface ConflictReport {
+    section: string;
+    key: string;
+    localValue: unknown;
+    packageValue: unknown;
+    description: string;
+}
+interface MergeResult {
+    config: Record<string, unknown>;
+    contributions: Contributions;
+    conflicts: ConflictReport[];
+}
+declare function deepMergeConstraints(localConfig: Record<string, unknown>, bundleConstraints: BundleConstraints, _existingContributions?: Contributions): MergeResult;
+
+/**
+ * Read and validate a lockfile from disk.
+ *
+ * Returns null (not an error) if the file does not exist.
+ * Returns an error if the file exists but is invalid JSON or fails schema validation.
+ */
+declare function readLockfile(lockfilePath: string): Promise<Result<Lockfile | null, string>>;
+/**
+ * Write a lockfile to disk using atomic write.
+ */
+declare function writeLockfile(lockfilePath: string, lockfile: Lockfile): Promise<Result<void, Error>>;
+/**
+ * Add or replace a package entry in the lockfile (immutable).
+ *
+ * If the package already exists, its entry is replaced (upgrade semantics).
+ */
+declare function addProvenance(lockfile: Lockfile, packageName: string, entry: LockfilePackage): Lockfile;
+/**
+ * Remove a package entry from the lockfile (immutable).
+ *
+ * Returns the updated lockfile and the removed package's contributions
+ * (or null if the package was not found).
+ */
+declare function removeProvenance(lockfile: Lockfile, packageName: string): {
+    lockfile: Lockfile;
+    contributions: Contributions | null;
+};
+
+/**
+ * Remove contributions from a config object.
+ *
+ * Uses the contributions record (as stored in the lockfile) to identify
+ * exactly which rules/layers/thresholds to remove from each section.
+ *
+ * Returns a new config object; does not mutate the input.
+ */
+declare function removeContributions(config: Record<string, unknown>, contributions: Contributions): Record<string, unknown>;
+
 interface InternalSymbol {
     name: string;
     type: 'function' | 'class' | 'variable' | 'type';
@@ -1420,13 +2064,13 @@ declare const EntropyConfigSchema: z.ZodObject<{
             entryPoints?: string[] | undefined;
             includeTypes?: boolean | undefined;
             includeInternals?: boolean | undefined;
-            treatDynamicImportsAs?: "used" | "unknown" | undefined;
+            treatDynamicImportsAs?: "unknown" | "used" | undefined;
         }, {
             ignorePatterns?: string[] | undefined;
             entryPoints?: string[] | undefined;
             includeTypes?: boolean | undefined;
             includeInternals?: boolean | undefined;
-            treatDynamicImportsAs?: "used" | "unknown" | undefined;
+            treatDynamicImportsAs?: "unknown" | "used" | undefined;
         }>]>>;
         patterns: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodObject<{
             patterns: z.ZodArray<z.ZodObject<{
@@ -1692,7 +2336,7 @@ declare const EntropyConfigSchema: z.ZodObject<{
             entryPoints?: string[] | undefined;
             includeTypes?: boolean | undefined;
             includeInternals?: boolean | undefined;
-            treatDynamicImportsAs?: "used" | "unknown" | undefined;
+            treatDynamicImportsAs?: "unknown" | "used" | undefined;
         } | undefined;
         patterns?: boolean | {
             patterns: {
@@ -1748,7 +2392,7 @@ declare const EntropyConfigSchema: z.ZodObject<{
             entryPoints?: string[] | undefined;
             includeTypes?: boolean | undefined;
             includeInternals?: boolean | undefined;
-            treatDynamicImportsAs?: "used" | "unknown" | undefined;
+            treatDynamicImportsAs?: "unknown" | "used" | undefined;
         } | undefined;
         patterns?: boolean | {
             patterns: {
@@ -1810,7 +2454,7 @@ declare const EntropyConfigSchema: z.ZodObject<{
             entryPoints?: string[] | undefined;
             includeTypes?: boolean | undefined;
             includeInternals?: boolean | undefined;
-            treatDynamicImportsAs?: "used" | "unknown" | undefined;
+            treatDynamicImportsAs?: "unknown" | "used" | undefined;
         } | undefined;
         patterns?: boolean | {
             patterns: {
@@ -1855,9 +2499,9 @@ declare const EntropyConfigSchema: z.ZodObject<{
         } | undefined;
     };
     parser?: any;
+    include?: string[] | undefined;
     docPaths?: string[] | undefined;
     entryPoints?: string[] | undefined;
-    include?: string[] | undefined;
     exclude?: string[] | undefined;
 }, {
     rootDir: string;
@@ -1874,7 +2518,7 @@ declare const EntropyConfigSchema: z.ZodObject<{
             entryPoints?: string[] | undefined;
             includeTypes?: boolean | undefined;
             includeInternals?: boolean | undefined;
-            treatDynamicImportsAs?: "used" | "unknown" | undefined;
+            treatDynamicImportsAs?: "unknown" | "used" | undefined;
         } | undefined;
         patterns?: boolean | {
             patterns: {
@@ -1919,9 +2563,9 @@ declare const EntropyConfigSchema: z.ZodObject<{
         } | undefined;
     };
     parser?: any;
+    include?: string[] | undefined;
     docPaths?: string[] | undefined;
     entryPoints?: string[] | undefined;
-    include?: string[] | undefined;
     exclude?: string[] | undefined;
 }>;
 /**
@@ -2141,7 +2785,7 @@ interface ForbiddenPattern {
     fileGlob?: string;
 }
 type AgentType = 'architecture-enforcer' | 'documentation-maintainer' | 'test-reviewer' | 'entropy-cleaner' | 'custom';
-interface AgentConfig {
+interface FeedbackAgentConfig {
     type: AgentType;
     customType?: string;
     context: ReviewContext;
@@ -2158,7 +2802,7 @@ interface AgentProcess {
     id: string;
     status: 'pending' | 'running' | 'completed' | 'failed' | 'timeout';
     startedAt: string;
-    config: AgentConfig;
+    config: FeedbackAgentConfig;
 }
 interface PeerReview {
     agentId: string;
@@ -2289,7 +2933,7 @@ interface TelemetryAdapter {
 interface AgentExecutor {
     readonly name: string;
     health(): Promise<Result<ExecutorHealth, FeedbackError>>;
-    spawn(config: AgentConfig): Promise<Result<AgentProcess, FeedbackError>>;
+    spawn(config: FeedbackAgentConfig): 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>>;
@@ -2388,7 +3032,7 @@ declare class NoOpExecutor implements AgentExecutor {
     readonly name = "noop";
     private processes;
     health(): Promise<Result<ExecutorHealth, FeedbackError>>;
-    spawn(config: AgentConfig): Promise<Result<AgentProcess, FeedbackError>>;
+    spawn(config: FeedbackAgentConfig): 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>>;
@@ -2444,6 +3088,171 @@ declare class NoOpSink implements ActionSink {
     write(): Promise<Result<void, FeedbackError>>;
 }
 
+declare class CircularDepsCollector implements Collector {
+    readonly category: "circular-deps";
+    getRules(_config: ArchConfig, _rootDir: string): ConstraintRule[];
+    collect(_config: ArchConfig, rootDir: string): Promise<MetricResult[]>;
+}
+
+declare class LayerViolationCollector implements Collector {
+    readonly category: "layer-violations";
+    getRules(_config: ArchConfig, _rootDir: string): ConstraintRule[];
+    collect(_config: ArchConfig, rootDir: string): Promise<MetricResult[]>;
+}
+
+declare class ComplexityCollector implements Collector {
+    readonly category: "complexity";
+    getRules(_config: ArchConfig, _rootDir: string): ConstraintRule[];
+    collect(_config: ArchConfig, rootDir: string): Promise<MetricResult[]>;
+}
+
+declare class CouplingCollector implements Collector {
+    readonly category: "coupling";
+    getRules(_config: ArchConfig, _rootDir: string): ConstraintRule[];
+    collect(_config: ArchConfig, rootDir: string): Promise<MetricResult[]>;
+}
+
+declare class ForbiddenImportCollector implements Collector {
+    readonly category: "forbidden-imports";
+    getRules(_config: ArchConfig, _rootDir: string): ConstraintRule[];
+    collect(_config: ArchConfig, rootDir: string): Promise<MetricResult[]>;
+}
+
+declare class ModuleSizeCollector implements Collector {
+    readonly category: "module-size";
+    getRules(config: ArchConfig, _rootDir: string): ConstraintRule[];
+    collect(config: ArchConfig, rootDir: string): Promise<MetricResult[]>;
+}
+
+declare class DepDepthCollector implements Collector {
+    readonly category: "dependency-depth";
+    getRules(config: ArchConfig, _rootDir: string): ConstraintRule[];
+    collect(config: ArchConfig, rootDir: string): Promise<MetricResult[]>;
+}
+
+/**
+ * Produce a stable violation ID.
+ * Formula: sha256(relativePath + ':' + category + ':' + normalizedDetail)
+ * Line numbers are excluded to keep IDs stable across unrelated edits.
+ */
+declare function violationId(relativePath: string, category: string, normalizedDetail: string): string;
+/**
+ * Produce a stable constraint rule ID.
+ * Formula: sha256(category + ':' + scope + ':' + description)
+ */
+declare function constraintRuleId(category: string, scope: string, description: string): string;
+
+declare const defaultCollectors: Collector[];
+/**
+ * Run all collectors in parallel and return a flat array of MetricResults.
+ */
+declare function runAll(config: ArchConfig, rootDir: string, collectors?: Collector[]): Promise<MetricResult[]>;
+
+/**
+ * Minimal graph store interface for constraint node operations.
+ * Matches the subset of GraphStore used by this module.
+ */
+interface ConstraintNodeStore {
+    findNodes(query: {
+        type: string;
+    }): Array<{
+        id: string;
+        [key: string]: unknown;
+    }>;
+    upsertNode(node: Record<string, unknown>): void;
+    removeNode(id: string): void;
+}
+/**
+ * Synchronize constraint rules with graph nodes.
+ *
+ * - Upserts each rule as a `constraint` node (sets `createdAt` on first insert)
+ * - Matches violations to rules and updates `lastViolatedAt`
+ * - Prunes constraint nodes not present in the current rules set (orphan cleanup)
+ */
+declare function syncConstraintNodes(store: ConstraintNodeStore, rules: ConstraintRule[], violations: MetricResult[]): void;
+
+interface StaleConstraint {
+    id: string;
+    category: ArchMetricCategory;
+    description: string;
+    scope: string;
+    lastViolatedAt: string | null;
+    daysSinceLastViolation: number;
+}
+interface DetectStaleResult {
+    staleConstraints: StaleConstraint[];
+    totalConstraints: number;
+    windowDays: number;
+}
+/**
+ * Detect constraint rules that haven't been violated within the given window.
+ *
+ * A constraint is considered stale if its comparison timestamp
+ * (lastViolatedAt ?? createdAt) is older than `now - windowDays`.
+ */
+declare function detectStaleConstraints(store: ConstraintNodeStore, windowDays?: number, category?: ArchMetricCategory): DetectStaleResult;
+
+/**
+ * Manages architecture baselines stored on disk.
+ *
+ * Baselines are stored at `.harness/arch/baselines.json` relative to the project root.
+ * Each category maps to an aggregate value and an allowlist of known violation IDs.
+ */
+declare class ArchBaselineManager {
+    private readonly baselinesPath;
+    constructor(projectRoot: string, baselinePath?: string);
+    /**
+     * Snapshot the current metric results into an ArchBaseline.
+     * Aggregates multiple MetricResults for the same category by summing values
+     * and concatenating violation IDs.
+     */
+    capture(results: MetricResult[], commitHash: string): ArchBaseline;
+    /**
+     * Load the baselines file from disk.
+     * Returns null if the file does not exist, contains invalid JSON,
+     * or fails ArchBaselineSchema validation.
+     */
+    load(): ArchBaseline | null;
+    /**
+     * Save an ArchBaseline to disk.
+     * Creates parent directories if they do not exist.
+     * Uses atomic write (write to temp file, then rename) to prevent corruption.
+     */
+    save(baseline: ArchBaseline): void;
+}
+
+/**
+ * Diff current metric results against a stored baseline.
+ *
+ * Pure function implementing the ratchet logic:
+ * - New violations (in current but not baseline) cause failure
+ * - Aggregate value exceeding baseline causes failure (regression)
+ * - Pre-existing violations (in both) are allowed
+ * - Resolved violations (in baseline but not current) are celebrated
+ *
+ * Categories present in current but absent from the baseline are treated
+ * as having an empty baseline (value: 0, no known violations), so any
+ * violations in those categories are considered new.
+ */
+declare function diff(current: MetricResult[], baseline: ArchBaseline): ArchDiffResult;
+
+/**
+ * Resolve effective thresholds for a given scope.
+ *
+ * When scope is 'project' or has no matching module entry, returns
+ * project-wide thresholds. Otherwise, merges project thresholds
+ * with module-level overrides (module wins per-category).
+ *
+ * For object-valued thresholds (e.g. coupling: { maxFanIn, maxFanOut }),
+ * performs a shallow merge at the category level:
+ *   project { maxFanIn: 10, maxFanOut: 8 } + module { maxFanOut: 5 }
+ *   => { maxFanIn: 10, maxFanOut: 5 }
+ *
+ * When either side is a scalar, the module value replaces the project
+ * value entirely (no merge across scalar/object boundaries).
+ */
+declare function resolveThresholds(scope: string, config: ArchConfig): ThresholdConfig;
+
 declare const FailureEntrySchema: z.ZodObject<{
     date: z.ZodString;
     skill: z.ZodString;
@@ -2451,13 +3260,13 @@ declare const FailureEntrySchema: z.ZodObject<{
     description: z.ZodString;
 }, "strip", z.ZodTypeAny, {
     type: string;
-    date: string;
     description: string;
+    date: string;
     skill: string;
 }, {
     type: string;
-    date: string;
     description: string;
+    date: string;
     skill: string;
 }>;
 type FailureEntry = z.infer<typeof FailureEntrySchema>;
@@ -2609,12 +3418,12 @@ declare const HarnessStateSchema: z.ZodObject<{
         status: z.ZodEnum<["open", "resolved"]>;
     }, "strip", z.ZodTypeAny, {
         id: string;
-        status: "open" | "resolved";
         description: string;
+        status: "resolved" | "open";
     }, {
         id: string;
-        status: "open" | "resolved";
         description: string;
+        status: "resolved" | "open";
     }>, "many">>;
     progress: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodEnum<["pending", "in_progress", "complete"]>>>;
     lastSession: z.ZodOptional<z.ZodObject<{
@@ -2641,8 +3450,8 @@ declare const HarnessStateSchema: z.ZodObject<{
     }[];
     blockers: {
         id: string;
-        status: "open" | "resolved";
         description: string;
+        status: "resolved" | "open";
     }[];
     schemaVersion: 1;
     position: {
@@ -2665,8 +3474,8 @@ declare const HarnessStateSchema: z.ZodObject<{
     }[] | undefined;
     blockers?: {
         id: string;
-        status: "open" | "resolved";
         description: string;
+        status: "resolved" | "open";
     }[] | undefined;
     position?: {
         task?: string | undefined;
@@ -2915,10 +3724,10 @@ declare const SecurityConfigSchema: z.ZodObject<{
         } | undefined;
     }>>;
 }, "strip", z.ZodTypeAny, {
+    rules: Record<string, "error" | "warning" | "info" | "off">;
     enabled: boolean;
     strict: boolean;
     exclude: string[];
-    rules: Record<string, "error" | "warning" | "info" | "off">;
     external?: {
         semgrep?: {
             enabled: boolean | "auto";
@@ -2929,10 +3738,10 @@ declare const SecurityConfigSchema: z.ZodObject<{
         } | undefined;
     } | undefined;
 }, {
+    rules?: Record<string, "error" | "warning" | "info" | "off"> | undefined;
     enabled?: boolean | undefined;
     strict?: boolean | undefined;
     exclude?: string[] | undefined;
-    rules?: Record<string, "error" | "warning" | "info" | "off"> | undefined;
     external?: {
         semgrep?: {
             enabled?: boolean | "auto" | undefined;
@@ -3880,6 +4689,52 @@ type Confirmation = z.infer<typeof ConfirmationSchema>;
 type Transition = z.infer<typeof TransitionSchema>;
 type EmitInteractionInput = z.infer<typeof EmitInteractionInputSchema>;
 
+interface Content {
+    codeTranslation: string;
+}
+interface BlueprintModule {
+    id: string;
+    title: string;
+    description: string;
+    files: string[];
+    content?: Content;
+}
+interface Hotspot {
+    file: string;
+    function: string;
+    score: number;
+}
+interface ModuleDependency {
+    from: string;
+    to: string;
+}
+interface BlueprintData {
+    projectName: string;
+    generatedAt: string;
+    modules: BlueprintModule[];
+    hotspots: Hotspot[];
+    dependencies: ModuleDependency[];
+}
+interface BlueprintOptions {
+    outputDir: string;
+    projectName?: string;
+}
+
+declare class ProjectScanner {
+    private rootDir;
+    constructor(rootDir: string);
+    scan(): Promise<BlueprintData>;
+}
+
+declare class BlueprintGenerator {
+    private contentPipeline;
+    generate(data: BlueprintData, options: BlueprintOptions): Promise<void>;
+}
+
+declare class ContentPipeline {
+    generateModuleContent(module: BlueprintModule): Promise<Content>;
+}
+
 interface UpdateCheckState {
     lastCheckTime: number;
     latestVersion: string | null;
@@ -3920,15 +4775,22 @@ declare function getUpdateNotification(currentVersion: string): string | null;
 /**
  * @harness-engineering/core
  *
- * Core library for Harness Engineering toolkit
+ * Core library for Harness Engineering toolkit.
+ * This library provides the fundamental building blocks for codebase analysis,
+ * validation, entropy management, and agent-driven workflows.
+ */
+/**
+ * Re-export all fundamental types from the types package.
  */
 
 /**
+ * The current version of the Harness Engineering core library.
+ *
  * @deprecated Read the CLI version from `@harness-engineering/cli/package.json`
  * instead. This hardcoded constant drifts from the actual CLI version on each
  * release. Kept only as a fallback for consumers that cannot resolve the CLI
  * package at runtime.
  */
-declare const VERSION = "1.8.2";
+declare const VERSION = "0.11.0";
 
-export { AGENT_DESCRIPTORS, ARCHITECTURE_DESCRIPTOR, 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 AgentReviewResult, type AgentType, type AgentsMapConfig, BUG_DETECTION_DESCRIPTOR, type BaseError, type Baseline, BaselineManager, type BaselinesFile, type BenchmarkResult, type BenchmarkRunOptions, BenchmarkRunner, type BoundaryDefinition, type BoundaryValidation, type BoundaryValidator, type BoundaryViolation, type BrokenLink, COMPLIANCE_DESCRIPTOR, type ChangeType, type ChangedFile, ChecklistBuilder, type CircularDependency, type CircularDepsResult, type CleanupFinding, type CodeBlock, type CodeChanges, type CodePattern, type CodeReference, type CodebaseSnapshot, type CommentedCodeBlock, type CommitFormat, type CommitHistoryEntry, type CommitValidation, type ComplexityConfig, type ComplexityReport, type ComplexityThresholds, type ComplexityViolation, type ConfigError, type ConfigPattern, type Confirmation, ConfirmationSchema, ConsoleSink, type ConstraintError, type ContextBundle, type ContextError, type ContextFile, type ContextFilterResult, type ContextScopeOptions, type Convention, type CouplingConfig, type CouplingReport, type CouplingThresholds, type CouplingViolation, type CoverageOptions, type CoverageReport, type CriticalPathEntry, CriticalPathResolver, type CriticalPathSet, type CustomRule, type CustomRuleResult, DEFAULT_PROVIDER_TIERS, DEFAULT_SECURITY_CONFIG, DEFAULT_STATE, DEFAULT_STREAM_INDEX, type DeadCodeConfig, type DeadCodeReport, type DeadExport, type DeadFile, type DeadInternal, type DeduplicateFindingsOptions, type DependencyEdge, type DependencyGraph, type DependencyValidation, type DependencyViolation, type DiffInfo, type DocumentationDrift, type DocumentationFile, type DocumentationGap, type DriftConfig, type DriftReport, type EligibilityResult, type EmitInteractionInput, EmitInteractionInputSchema, EntropyAnalyzer, type EntropyConfig, EntropyConfigSchema, type EntropyError, type EntropyReport, ExclusionSet, type ExecutorHealth, type Export, type ExportMap, type FailureEntry, FailureEntrySchema, type FanOutOptions, type FeedbackConfig, type FeedbackError$1 as FeedbackError, type FileCategory, FileSink, type FindingSeverity, type Fix, type FixConfig, type FixResult, type FixType, type ForbiddenImportViolation, type ForbiddenPattern, type GateConfig, GateConfigSchema, type GateResult, GateResultSchema, type GenerationSection, type GitHubInlineComment, type GraphAdapter, type GraphComplexityData, type GraphCouplingData, type GraphCoverageData, type GraphCriticalPathData, type GraphDependencyData, type GraphHarnessCheckData, type GraphImpactData, type Handoff, HandoffSchema, type HarnessState, HarnessStateSchema, type HealthCheckResult, type HotspotContext, type Import, type InlineReference, type IntegrityReport, type InteractionType, InteractionTypeSchema, type InternalSymbol, type JSDocComment, type LanguageParser, type Layer, type LayerConfig, type LogEntry, type LogFilter, type MechanicalCheckOptions, type MechanicalCheckResult, type MechanicalCheckStatus, type MechanicalFinding, type Metric, type ModelProvider, type ModelTier, type ModelTierConfig, NoOpExecutor, NoOpSink, NoOpTelemetryAdapter, type OrphanedDep, type ParseError, type PatternConfig, PatternConfigSchema, type PatternMatch, type PatternReport, type PatternViolation, type PeerReview, type PeerReviewOptions, type PipelineContext, type PipelineFlags, type PipelineOptions, type PipelineResult, type PrMetadata, type PriorReview, type ProviderDefaults, type Question, QuestionSchema, REQUIRED_SECTIONS, type ReachabilityNode, RegressionDetector, type RegressionReport, type RegressionResult, type ReviewAgentDescriptor, type ReviewAssessment, type ReviewChecklist, type ReviewComment, type ReviewContext, type ReviewDomain, type ReviewFinding, type ReviewItem, type ReviewOutputOptions, type ReviewPipelineResult, type ReviewStrength, type RuleOverride, RuleRegistry, type RunCIChecksInput, type RunPipelineOptions, SECURITY_DESCRIPTOR, type SafetyLevel, type ScanResult, type SecurityCategory, type SecurityConfidence, type SecurityConfig, SecurityConfigSchema, type SecurityFinding, type SecurityRule, SecurityScanner, type SecuritySeverity, type SelfReviewConfig, type SizeBudgetConfig, type SizeBudgetReport, type SizeBudgetViolation, type SkillExecutor, type SourceFile, type Span, type SpanEvent, type StepExecutor, type StreamIndex, StreamIndexSchema, type StreamInfo, StreamInfoSchema, type StructureValidation, type Suggestion, type SuggestionReport, type SyncChange, type SyncOptions, type TelemetryAdapter, type TelemetryHealth, type TimeRange, type TokenBudget, type TokenBudgetOverrides, type Trace, type Transition, TransitionSchema, type TurnExecutor, TypeScriptParser, type UnusedImport, type UpdateCheckState, VERSION, type ValidateFindingsOptions, type ValidationError, type WorkflowPhase, analyzeDiff, appendFailure, appendLearning, applyFixes, applyHotspotDowngrade, archiveFailures, archiveStream, buildDependencyGraph, buildExclusionSet, buildSnapshot, checkDocCoverage, checkEligibility, classifyFinding, configureFeedback, contextBudget, contextFilter, createBoundaryValidator, createCommentedCodeFixes, createError, createFixes, createForbiddenImportFixes, createOrphanedDepFixes, createParseError, createSelfReview, createStream, cryptoRules, deduplicateCleanupFindings, deduplicateFindings, defineLayer, deserializationRules, detectChangeType, detectCircularDeps, detectCircularDepsInFiles, detectComplexityViolations, detectCouplingViolations, detectDeadCode, detectDocDrift, detectPatternViolations, detectSizeBudgetViolations, detectStack, determineAssessment, executeWorkflow, expressRules, extractMarkdownLinks, extractSections, fanOutReview, formatFindingBlock, formatGitHubComment, formatGitHubSummary, formatTerminalOutput, generateAgentsMap, generateSuggestions, getActionEmitter, getExitCode, getFeedbackConfig, getPhaseCategories, getStreamForBranch, getUpdateNotification, goRules, injectionRules, isSmallSuggestion, isUpdateCheckEnabled, listStreams, loadFailures, loadHandoff, loadRelevantLearnings, loadState, loadStreamIndex, logAgentAction, migrateToStreams, networkRules, nodeRules, parseDiff, parseRoadmap, parseSecurityConfig, parseSize, pathTraversalRules, previewFix, reactRules, readCheckState, requestMultiplePeerReviews, requestPeerReview, resetFeedbackConfig, resolveFileToLayer, resolveModelTier, resolveRuleSeverity, resolveStreamPath, runArchitectureAgent, runBugDetectionAgent, runCIChecks, runComplianceAgent, runMechanicalChecks, runMechanicalGate, runMultiTurnPipeline, runPipeline, runReviewPipeline, runSecurityAgent, saveHandoff, saveState, saveStreamIndex, scopeContext, secretRules, serializeRoadmap, setActiveStream, shouldRunCheck, spawnBackgroundCheck, syncRoadmap, touchStream, trackAction, validateAgentsMap, validateBoundaries, validateCommitMessage, validateConfig, validateDependencies, validateFileStructure, validateFindings, validateKnowledgeMap, validatePatternConfig, xssRules };
+export { AGENT_DESCRIPTORS, ARCHITECTURE_DESCRIPTOR, type AST, type ActionContext, type ActionEvent, type ActionEventHandler, type ActionEventType, type ActionResult, type ActionSink, type ActionTracker, type ActionType, type AgentAction, AgentActionEmitter, type AgentExecutor, type AgentMapLink, type AgentMapSection, type AgentMapValidation, type AgentProcess, type AgentReviewResult, type AgentType, type AgentsMapConfig, ArchBaseline, ArchBaselineManager, ArchConfig, ArchDiffResult, ArchMetricCategory, BUG_DETECTION_DESCRIPTOR, type BaseError, type Baseline, BaselineManager, type BaselinesFile, type BenchmarkResult, type BenchmarkRunOptions, BenchmarkRunner, type BlueprintData, BlueprintGenerator, type BlueprintModule, type BlueprintOptions, type BoundaryDefinition, type BoundaryValidation, type BoundaryValidator, type BoundaryViolation, type BrokenLink, type Bundle, type BundleConstraints, BundleConstraintsSchema, BundleSchema, COMPLIANCE_DESCRIPTOR, type ChangeType, type ChangedFile, ChecklistBuilder, type CircularDependency, CircularDepsCollector, type CircularDepsResult, type CleanupFinding, type CodeBlock, type CodeChanges, type CodePattern, type CodeReference, type CodebaseSnapshot, Collector, type CommentedCodeBlock, type CommitFormat, type CommitHistoryEntry, type CommitValidation, ComplexityCollector, type ComplexityConfig, type ComplexityReport, type ComplexityThresholds, type ComplexityViolation, type ConfigError, type ConfigPattern, type Confirmation, ConfirmationSchema, type ConflictReport, ConsoleSink, type ConstraintError, type ConstraintNodeStore, ConstraintRule, type Content, ContentPipeline, type ContextBundle, type ContextError, type ContextFile, type ContextFilterResult, type ContextScopeOptions, type Contributions, ContributionsSchema, type Convention, CouplingCollector, type CouplingConfig, type CouplingReport, type CouplingThresholds, type CouplingViolation, type CoverageOptions, type CoverageReport, type CriticalPathEntry, CriticalPathResolver, type CriticalPathSet, type CustomRule, type CustomRuleResult, DEFAULT_PROVIDER_TIERS, DEFAULT_SECURITY_CONFIG, DEFAULT_STATE, DEFAULT_STREAM_INDEX, type DeadCodeConfig, type DeadCodeReport, type DeadExport, type DeadFile, type DeadInternal, type DeduplicateFindingsOptions, DepDepthCollector, type DependencyEdge, type DependencyGraph, type DependencyValidation, type DependencyViolation, type DetectStaleResult, type DiffInfo, type DocumentationDrift, type DocumentationFile, type DocumentationGap, type DriftConfig, type DriftReport, type EligibilityResult, type EmitInteractionInput, EmitInteractionInputSchema, EntropyAnalyzer, type EntropyConfig, EntropyConfigSchema, type EntropyError, type EntropyReport, ExclusionSet, type ExecutorHealth, type Export, type ExportMap, type FailureEntry, FailureEntrySchema, type FanOutOptions, type FeedbackAgentConfig, type FeedbackConfig, type FeedbackError$1 as FeedbackError, type FileCategory, FileSink, type FindingSeverity, type Fix, type FixConfig, type FixResult, type FixType, ForbiddenImportCollector, type ForbiddenImportViolation, type ForbiddenPattern, type GateConfig, GateConfigSchema, type GateResult, GateResultSchema, type GenerationSection, type GitHubInlineComment, type GraphAdapter, type GraphComplexityData, type GraphCouplingData, type GraphCoverageData, type GraphCriticalPathData, type GraphDependencyData, type GraphHarnessCheckData, type GraphImpactData, type Handoff, HandoffSchema, type HarnessState, HarnessStateSchema, type HealthCheckResult, type Hotspot, type HotspotContext, type Import, type InlineReference, type IntegrityReport, type InteractionType, InteractionTypeSchema, type InternalSymbol, type JSDocComment, type LanguageParser, type Layer, type LayerConfig, LayerViolationCollector, type Lockfile, type LockfilePackage, LockfilePackageSchema, LockfileSchema, type LogEntry, type LogFilter, type Manifest, ManifestSchema, type MechanicalCheckOptions, type MechanicalCheckResult, type MechanicalCheckStatus, type MechanicalFinding, type MergeResult, type Metric, MetricResult, type ModelProvider, type ModelTier, type ModelTierConfig, type ModuleDependency, ModuleSizeCollector, NoOpExecutor, NoOpSink, NoOpTelemetryAdapter, type OrphanedDep, type ParseError, type PatternConfig, PatternConfigSchema, type PatternMatch, type PatternReport, type PatternViolation, type PeerReview, type PeerReviewOptions, type PipelineContext, type PipelineFlags, type PipelineOptions, type PipelineResult, type PrMetadata, type PriorReview, ProjectScanner, type ProviderDefaults, type Question, QuestionSchema, REQUIRED_SECTIONS, type ReachabilityNode, RegressionDetector, type RegressionReport, type RegressionResult, type ReviewAgentDescriptor, type ReviewAssessment, type ReviewChecklist, type ReviewComment, type ReviewContext, type ReviewDomain, type ReviewFinding, type ReviewItem, type ReviewOutputOptions, type ReviewPipelineResult, type ReviewStrength, type RuleOverride, RuleRegistry, type RunCIChecksInput, type RunPipelineOptions, SECURITY_DESCRIPTOR, type SafetyLevel, type ScanResult, type SecurityCategory, type SecurityConfidence, type SecurityConfig, SecurityConfigSchema, type SecurityFinding, type SecurityRule, SecurityScanner, type SecuritySeverity, type SelfReviewConfig, SharableBoundaryConfigSchema, SharableForbiddenImportSchema, SharableLayerSchema, SharableSecurityRulesSchema, type SizeBudgetConfig, type SizeBudgetReport, type SizeBudgetViolation, type SkillExecutor, type SourceFile, type Span, type SpanEvent, type StaleConstraint, type StepExecutor, type StreamIndex, StreamIndexSchema, type StreamInfo, StreamInfoSchema, type StructureValidation, type Suggestion, type SuggestionReport, type SyncChange, type SyncOptions, type TelemetryAdapter, type TelemetryHealth, ThresholdConfig, type TimeRange, type TokenBudget, type TokenBudgetOverrides, type Trace, type Transition, TransitionSchema, type TurnExecutor, TypeScriptParser, type UnusedImport, type UpdateCheckState, VERSION, type ValidateFindingsOptions, type ValidationError, type WorkflowPhase, addProvenance, analyzeDiff, appendFailure, appendLearning, applyFixes, applyHotspotDowngrade, archiveFailures, archiveStream, buildDependencyGraph, buildExclusionSet, buildSnapshot, checkDocCoverage, checkEligibility, classifyFinding, configureFeedback, constraintRuleId, contextBudget, contextFilter, createBoundaryValidator, createCommentedCodeFixes, createError, createFixes, createForbiddenImportFixes, createOrphanedDepFixes, createParseError, createSelfReview, createStream, cryptoRules, deduplicateCleanupFindings, deduplicateFindings, deepMergeConstraints, defaultCollectors, defineLayer, deserializationRules, detectChangeType, detectCircularDeps, detectCircularDepsInFiles, detectComplexityViolations, detectCouplingViolations, detectDeadCode, detectDocDrift, detectPatternViolations, detectSizeBudgetViolations, detectStack, detectStaleConstraints, determineAssessment, diff, executeWorkflow, expressRules, extractBundle, extractMarkdownLinks, extractSections, fanOutReview, formatFindingBlock, formatGitHubComment, formatGitHubSummary, formatTerminalOutput, generateAgentsMap, generateSuggestions, getActionEmitter, getExitCode, getFeedbackConfig, getPhaseCategories, getStreamForBranch, getUpdateNotification, goRules, injectionRules, isSmallSuggestion, isUpdateCheckEnabled, listStreams, loadFailures, loadHandoff, loadRelevantLearnings, loadState, loadStreamIndex, logAgentAction, migrateToStreams, networkRules, nodeRules, parseDiff, parseManifest, parseRoadmap, parseSecurityConfig, parseSize, pathTraversalRules, previewFix, reactRules, readCheckState, readLockfile, removeContributions, removeProvenance, requestMultiplePeerReviews, requestPeerReview, resetFeedbackConfig, resolveFileToLayer, resolveModelTier, resolveRuleSeverity, resolveStreamPath, resolveThresholds, runAll, runArchitectureAgent, runBugDetectionAgent, runCIChecks, runComplianceAgent, runMechanicalChecks, runMechanicalGate, runMultiTurnPipeline, runPipeline, runReviewPipeline, runSecurityAgent, saveHandoff, saveState, saveStreamIndex, scopeContext, secretRules, serializeRoadmap, setActiveStream, shouldRunCheck, spawnBackgroundCheck, syncConstraintNodes, syncRoadmap, touchStream, trackAction, validateAgentsMap, validateBoundaries, validateCommitMessage, validateConfig, validateDependencies, validateFileStructure, validateFindings, validateKnowledgeMap, validatePatternConfig, violationId, writeConfig, writeLockfile, xssRules };