131 changed files with 943 additions and 5930 deletions
--- a/docs/CONFIG_SPLIT_APPLICATION_NEW.md
+++ b/docs/CONFIG_SPLIT_APPLICATION_NEW.md
@ -1,31 +0,0 @@
-# Config split: moved new-runtime properties to application-new.yml
-
-This patch keeps shared and legacy defaults in `application.yml` and moves new-runtime properties into `application-new.yml`.
-
-Activate the new runtime with:
-
-```
--spring.profiles.active=new
-```
-
-`application-new.yml` also sets:
-
-```yaml
-dip.runtime.mode: NEW
-```
-
-So profile selection and runtime mode stay aligned.
-
-Moved blocks:
- `dip.embedding.*`
- `ted.search.*` (new generic search tuning, now under `dip.search.*`)
- `ted.projection.*`
- `ted.generic-ingestion.*`
- new/transitional `ted.vectorization.*` keys:
-  - `generic-pipeline-enabled`
-  - `dual-write-legacy-ted-vectors`
-  - `generic-scheduler-period-ms`
-  - `primary-representation-builder-key`
-  - `embedding-provider`
-
-Shared / legacy defaults remain in `application.yml`.
--- a/docs/architecture/EMBEDDING_POLICY_PATCH_K1.md
+++ b/docs/architecture/EMBEDDING_POLICY_PATCH_K1.md
@ -1,30 +0,0 @@
-# Embedding policy Patch K1
-
-Patch K1 introduces the configuration and resolver layer for policy-based document embedding selection.
-
-## Added
- `EmbeddingPolicy`
- `EmbeddingProfile`
- `EmbeddingPolicyCondition`
- `EmbeddingPolicyUse`
- `EmbeddingPolicyRule`
- `EmbeddingPolicyProperties`
- `EmbeddingProfileProperties`
- `EmbeddingPolicyResolver`
- `DefaultEmbeddingPolicyResolver`
- `EmbeddingProfileResolver`
- `DefaultEmbeddingProfileResolver`
-
-## Example config
-See `application-new-example-embedding-policy.yml`.
-
-## What K1 does not change
- no runtime import/orchestrator wiring yet
- no `SourceDescriptor` schema change yet
- no job persistence/audit changes yet
-
-## Intended follow-up
-K2 should wire:
- `GenericDocumentImportService`
- `RepresentationEmbeddingOrchestrator`
-to use the resolved policy and profile.
--- a/docs/architecture/EMBEDDING_POLICY_PATCH_K2.md
+++ b/docs/architecture/EMBEDDING_POLICY_PATCH_K2.md
@ -1,26 +0,0 @@
-# Embedding policy Patch K2
-
-Patch K2 wires the policy/profile layer into the actual NEW import runtime.
-
-## What it changes
- `GenericDocumentImportService`
-  - resolves `EmbeddingPolicy` per imported document
-  - resolves `EmbeddingProfile`
-  - ensures the selected embedding model is registered
-  - queues embeddings only for representation drafts allowed by the resolved profile
- `RepresentationEmbeddingOrchestrator`
-  - adds a convenience overload for `(documentId, modelKey, profile)`
- `EmbeddingJobService`
-  - adds a profile-aware enqueue overload
- `DefaultEmbeddingSelectionPolicy`
-  - adds profile-aware representation filtering
- `DefaultEmbeddingPolicyResolver`
-  - corrected for the current `SourceDescriptor.attributes()` shape
-
-## Runtime flow after K2
-document imported
-> representations built
-> policy resolved
-> profile resolved
-> model ensured
-> matching representations queued for embedding
--- a/docs/architecture/RUNTIME_SPLIT_PATCH_B.md
+++ b/docs/architecture/RUNTIME_SPLIT_PATCH_B.md
@ -1,59 +0,0 @@
-# Runtime split Patch B
-
-Patch B builds on Patch A and makes the NEW runtime actually process embedding jobs.
-
-## What changes
-
-### 1. New embedding job scheduler
-Adds:
-
- `EmbeddingJobScheduler`
- `EmbeddingJobSchedulingConfiguration`
-
-Behavior:
- enabled only in `NEW` runtime mode
- active only when `dip.embedding.jobs.enabled=true`
- periodically calls:
-  - `RepresentationEmbeddingOrchestrator.processNextReadyBatch()`
-
-### 2. Generic import hands off to the new embedding job path
-`GenericDocumentImportService` is updated so that in `NEW` mode it:
-
- resolves `dip.embedding.default-document-model`
- ensures the model is registered in `DOC.doc_embedding_model`
- creates embedding jobs through:
-  - `RepresentationEmbeddingOrchestrator.enqueueRepresentation(...)`
-
-It no longer creates legacy-style pending embeddings as the primary handoff for the NEW runtime path.
-
-## Notes
-
- This patch assumes Patch A has already introduced:
-  - `RuntimeMode`
-  - `RuntimeModeProperties`
-  - `@ConditionalOnRuntimeMode`
- This patch does not yet remove the legacy vectorization runtime.
-  That remains the job of subsequent cutover steps.
-
-## Expected runtime behavior in NEW mode
-
- `GenericDocumentImportService` persists new generic representations
- selected representations are queued into `DOC.doc_embedding_job`
- scheduler processes pending jobs
- vectors are persisted through the new embedding subsystem
-
-## New config
-
-Example:
-
-```yaml
-dip:
-  runtime:
-    mode: NEW
-
-  embedding:
-    enabled: true
-    jobs:
-      enabled: true
-      scheduler-delay-ms: 5000
-```
--- a/docs/architecture/RUNTIME_SPLIT_PATCH_C.md
+++ b/docs/architecture/RUNTIME_SPLIT_PATCH_C.md
@ -1,36 +0,0 @@
-# Runtime split Patch C
-
-Patch C moves the **new generic search runtime** off `TedProcessorProperties.search`
-and into a dedicated `dip.search.*` config tree.
-
-## New config class
- `at.procon.dip.search.config.DipSearchProperties`
-
-## New config root
-```yaml
-dip:
-  search:
-    ...
-```
-
-## Classes moved off `TedProcessorProperties`
- `PostgresFullTextSearchEngine`
- `PostgresTrigramSearchEngine`
- `PgVectorSemanticSearchEngine`
- `DefaultSearchOrchestrator`
- `DefaultSearchResultFusionService`
- `SearchLexicalIndexStartupRunner`
- `ChunkedLongTextRepresentationBuilder`
-
-## What this patch intentionally does not do
- it does not yet remove `TedProcessorProperties` from all NEW-mode classes
- it does not yet move `generic-ingestion` config off `ted.*`
- it does not yet finish the legacy/new config split for import/mail/TED package processing
-
-Those should be handled in the next config-splitting patch.
-
-## Practical result
-After this patch, **new search/semantic/chunking tuning** should be configured only via:
- `dip.search.*`
-
-while `ted.search.*` remains legacy-oriented.
--- a/docs/architecture/RUNTIME_SPLIT_PATCH_D.md
+++ b/docs/architecture/RUNTIME_SPLIT_PATCH_D.md
@ -1,40 +0,0 @@
-# Runtime Split Patch D
-
-This patch completes the next configuration split step for the NEW runtime.
-
-## New property classes
-
- `at.procon.dip.ingestion.config.DipIngestionProperties`
-  - prefix: `dip.ingestion`
- `at.procon.dip.domain.ted.config.TedProjectionProperties`
-  - prefix: `dip.ted.projection`
-
-## Classes moved off `TedProcessorProperties`
-
-### NEW-mode ingestion
- `GenericDocumentImportService`
- `GenericFileSystemIngestionRoute`
- `GenericDocumentImportController`
- `MailDocumentIngestionAdapter`
- `TedPackageDocumentIngestionAdapter`
- `TedPackageChildImportProcessor`
-
-### NEW-mode projection
- `TedNoticeProjectionService`
- `TedProjectionStartupRunner`
-
-## Additional cleanup in `GenericDocumentImportService`
-
-It now resolves the default document embedding model through the new embedding subsystem:
-
- `EmbeddingProperties`
- `EmbeddingModelRegistry`
- `EmbeddingModelCatalogService`
-
-and no longer reads vectorization model/provider/dimensions from `TedProcessorProperties`.
-
-## What still remains for later split steps
-
- legacy routes/services still using `TedProcessorProperties`
- legacy/new runtime bean gating for all remaining shared classes
- moving old TED-only config fully under `legacy.ted.*`
--- a/docs/architecture/RUNTIME_SPLIT_PATCH_E.md
+++ b/docs/architecture/RUNTIME_SPLIT_PATCH_E.md
@ -1,26 +0,0 @@
-# Runtime split Patch E
-
-This patch continues the runtime/config split by targeting the remaining NEW-mode classes
-that still injected `TedProcessorProperties`.
-
-## New config classes
- `DipIngestionProperties` (`dip.ingestion.*`)
- `TedProjectionProperties` (`dip.ted.projection.*`)
-
-## NEW-mode classes moved off `TedProcessorProperties`
- `GenericDocumentImportService`
- `GenericFileSystemIngestionRoute`
- `GenericDocumentImportController`
- `MailDocumentIngestionAdapter`
- `TedPackageDocumentIngestionAdapter`
- `TedPackageChildImportProcessor`
- `TedNoticeProjectionService`
- `TedProjectionStartupRunner`
-
-## Additional behavior change
-`GenericDocumentImportService` now hands embedding work off to the new embedding subsystem by:
- resolving the default document model from `EmbeddingModelRegistry`
- ensuring the model is registered via `EmbeddingModelCatalogService`
- enqueueing jobs through `RepresentationEmbeddingOrchestrator`
-
-This removes the new import path's runtime dependence on legacy `TedProcessorProperties.vectorization`.
--- a/docs/architecture/RUNTIME_SPLIT_PATCH_F.md
+++ b/docs/architecture/RUNTIME_SPLIT_PATCH_F.md
@ -1,39 +0,0 @@
-# Runtime split Patch F
-
-This patch finishes the first major bean-gating pass for the **legacy runtime**.
-
-## What it does
-Marks the remaining old runtime classes as:
-
- `@ConditionalOnRuntimeMode(RuntimeMode.LEGACY)`
-
-### Legacy routes / runtime
- `MailRoute`
- `SolutionBriefRoute`
- `TedDocumentRoute`
- `TedPackageDownloadCamelRoute`
- `TedPackageDownloadRoute`
- `VectorizationRoute`
-
-### Legacy config/runtime infrastructure
- `AsyncConfig`
- `TedProcessorProperties`
-
-### Legacy controller / listeners / services
- `AdminController`
- `VectorizationEventListener`
- `AttachmentProcessingService`
- `BatchDocumentProcessingService`
- `DocumentProcessingService`
- `SearchService`
- `SimilaritySearchService`
- `TedPackageDownloadService`
- `TedPhase2GenericDocumentService`
- `VectorizationProcessorService`
- `VectorizationService`
- `VectorizationStartupRunner`
-
-## Added profile file
- `application-legacy.yml`
-
-This patch is intended to apply **after Patch A–E**. It does not yet remove the old `ted.*` property tree; it makes the old bean graph activate only in `LEGACY` mode.
--- a/docs/architecture/RUNTIME_SPLIT_PATCH_G.md
+++ b/docs/architecture/RUNTIME_SPLIT_PATCH_G.md
@ -1,24 +0,0 @@
-# Runtime split Patch G
-
-Patch G moves the remaining NEW-mode search/chunking classes off `TedProcessorProperties.search`
-and onto `DipSearchProperties` (`dip.search.*`).
-
-## New config class
- `at.procon.dip.search.config.DipSearchProperties`
-
-## Classes switched to `DipSearchProperties`
- `PostgresFullTextSearchEngine`
- `PostgresTrigramSearchEngine`
- `PgVectorSemanticSearchEngine`
- `DefaultSearchResultFusionService`
- `DefaultSearchOrchestrator`
- `SearchLexicalIndexStartupRunner`
- `ChunkedLongTextRepresentationBuilder`
-
-## Additional cleanup
-These classes are also marked `NEW`-only in this patch.
-
-## Effect
-After Patch G, the generic NEW-mode search/chunking path no longer depends on
-`TedProcessorProperties.search`. That leaves `TedProcessorProperties` much closer to
-legacy-only ownership.
--- a/docs/architecture/RUNTIME_SPLIT_PATCH_H.md
+++ b/docs/architecture/RUNTIME_SPLIT_PATCH_H.md
@ -1,17 +0,0 @@
-# Runtime split Patch H
-
-Patch H is a final cleanup / verification step after the previous split patches.
-
-## What it does
- makes `TedProcessorProperties` explicitly `LEGACY`-only
- removes the stale `TedProcessorProperties` import/comment from `DocumentIntelligencePlatformApplication`
- adds a regression test that fails if NEW runtime classes reintroduce a dependency on `TedProcessorProperties`
- adds a simple `application-legacy.yml` profile file
-
-## Why this matters
-After the NEW search/ingestion/projection classes are moved to:
- `DipSearchProperties`
- `DipIngestionProperties`
- `TedProjectionProperties`
-
-`TedProcessorProperties` should be owned strictly by the legacy runtime graph.
--- a/docs/architecture/RUNTIME_SPLIT_PATCH_I.md
+++ b/docs/architecture/RUNTIME_SPLIT_PATCH_I.md
@ -1,21 +0,0 @@
-# Runtime split Patch I
-
-Patch I extracts the remaining legacy vectorization cluster off `TedProcessorProperties`
-and onto a dedicated legacy-only config class.
-
-## New config class
- `at.procon.ted.config.LegacyVectorizationProperties`
-  - prefix: `legacy.ted.vectorization.*`
-
-## Classes switched off `TedProcessorProperties`
- `GenericVectorizationRoute`
- `DocumentEmbeddingProcessingService`
- `ConfiguredEmbeddingModelStartupRunner`
- `GenericVectorizationStartupRunner`
-
-## Additional cleanup
-These classes are also marked `LEGACY`-only via `@ConditionalOnRuntimeMode(RuntimeMode.LEGACY)`.
-
-## Effect
-The `at.procon.dip.vectorization.*` package now clearly belongs to the old runtime graph and no longer pulls
-its settings from the shared monolithic `TedProcessorProperties`.
--- a/docs/architecture/RUNTIME_SPLIT_PATCH_J.md
+++ b/docs/architecture/RUNTIME_SPLIT_PATCH_J.md
@ -1,45 +0,0 @@
-# Runtime split Patch J
-
-Patch J is a broader cleanup patch for the **actual current codebase**.
-
-It adds the missing runtime/config split scaffolding and rewires the remaining NEW-mode classes
-that still injected `TedProcessorProperties`.
-
-## Added
- `dip.runtime` infrastructure
-  - `RuntimeMode`
-  - `RuntimeModeProperties`
-  - `@ConditionalOnRuntimeMode`
-  - `RuntimeModeCondition`
- `DipSearchProperties`
- `DipIngestionProperties`
- `TedProjectionProperties`
-
-## Rewired off `TedProcessorProperties`
-### NEW search/chunking
- `PostgresFullTextSearchEngine`
- `PostgresTrigramSearchEngine`
- `PgVectorSemanticSearchEngine`
- `DefaultSearchOrchestrator`
- `SearchLexicalIndexStartupRunner`
- `DefaultSearchResultFusionService`
- `ChunkedLongTextRepresentationBuilder`
-
-### NEW ingestion/projection
- `GenericDocumentImportService`
- `GenericFileSystemIngestionRoute`
- `GenericDocumentImportController`
- `MailDocumentIngestionAdapter`
- `TedPackageDocumentIngestionAdapter`
- `TedPackageChildImportProcessor`
- `TedNoticeProjectionService`
- `TedProjectionStartupRunner`
-
-## Additional behavior
- `GenericDocumentImportService` now hands embedding work off to the new embedding subsystem
-  via `RepresentationEmbeddingOrchestrator` and resolves the default model through
-  `EmbeddingModelRegistry` / `EmbeddingModelCatalogService`.
-
-## Notes
-This patch intentionally targets the real current leftovers visible in the actual codebase.
-It assumes the new embedding subsystem already exists.
--- a/docs/architecture/TED_PACKAGE_NEW_IMPORT.md
+++ b/docs/architecture/TED_PACKAGE_NEW_IMPORT.md
@ -1,20 +0,0 @@
-# NEW TED package import route
-
-This patch adds a NEW-runtime TED package download path that:
-
- reuses the proven package sequencing rules
- stores package tracking in `TedDailyPackage`
- downloads the package tar.gz
- ingests it only through `DocumentIngestionGateway`
- never calls the legacy XML batch processing / vectorization flow
-
-## Added classes
-
- `TedPackageSequenceService`
- `DefaultTedPackageSequenceService`
- `TedPackageDownloadNewProperties`
- `TedPackageDownloadNewRoute`
-
-## Config
-
-Use the `dip.ingestion.ted-download.*` block in `application-new.yml`.
--- a/docs/embedding/VECTOR_SYNC_HTTP_PROVIDER.md
+++ b/docs/embedding/VECTOR_SYNC_HTTP_PROVIDER.md
@ -1,67 +0,0 @@
-# Vector-sync HTTP embedding provider
-
-This provider supports two endpoints:
-
- `POST {baseUrl}/vector-sync` for single-text requests
- `POST {baseUrl}/vectorize-batch` for batch document requests
-
-## Single request
-
-Request body:
-```json
-{
-  "model": "intfloat/multilingual-e5-large",
-  "text": "This is a sample text to vectorize"
-}
-```
-
-## Batch request
-
-Request body:
-```json
-{
-  "model": "intfloat/multilingual-e5-large",
-  "truncate_text": false,
-  "truncate_length": 512,
-  "chunk_size": 20,
-  "items": [
-    {
-      "id": "2f48fd5c-9d39-4d80-9225-ea0c59c77c9a",
-      "text": "This is a sample text to vectorize"
-    }
-  ]
-}
-```
-
-## Provider configuration
-
-```yaml
-batch-request:
-  truncate-text: false
-  truncate-length: 512
-  chunk-size: 20
-```
-
-These values are used for `/vectorize-batch` calls and can also be overridden per request via `EmbeddingRequest.providerOptions()`.
-
-## Orchestrator batch processing
-
-To let `RepresentationEmbeddingOrchestrator` send multiple representations in one provider call, enable batch processing for jobs and for the model:
-
-```yaml
-dip:
-  embedding:
-    jobs:
-      enabled: true
-      process-in-batches: true
-      execution-batch-size: 20
-
-    models:
-      e5-default:
-        supports-batch: true
-```
-
-Notes:
- jobs are grouped by `modelKey`
- non-batch-capable models still fall back to single-item execution
- `execution-batch-size` controls how many texts are sent in one `/vectorize-batch` request
--- a/src/main/java/at/procon/dip/DocumentIntelligencePlatformApplication.java
+++ b/src/main/java/at/procon/dip/DocumentIntelligencePlatformApplication.java
@ -1,5 +1,6 @@
 package at.procon.dip;

+import at.procon.ted.config.TedProcessorProperties;
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
 import org.springframework.boot.context.properties.EnableConfigurationProperties;
@ -16,8 +17,9 @@ import org.springframework.scheduling.annotation.EnableAsync;
 */
@SpringBootApplication(scanBasePackages = {"at.procon.dip", "at.procon.ted"})
@EnableAsync
-@EntityScan(basePackages = {"at.procon.ted.model.entity", "at.procon.dip.domain.document.entity", "at.procon.dip.domain.tenant.entity", "at.procon.dip.domain.ted.entity", "at.procon.dip.embedding.job.entity", "at.procon.dip.migration.audit.entity"})
-@EnableJpaRepositories(basePackages = {"at.procon.ted.repository", "at.procon.dip.domain.document.repository", "at.procon.dip.domain.tenant.repository", "at.procon.dip.domain.ted.repository", "at.procon.dip.embedding.job.repository", "at.procon.dip.migration.audit.repository"})
+//@EnableConfigurationProperties(TedProcessorProperties.class)
+@EntityScan(basePackages = {"at.procon.ted.model.entity", "at.procon.dip.domain.document.entity", "at.procon.dip.domain.tenant.entity", "at.procon.dip.domain.ted.entity", "at.procon.dip.embedding.job.entity"})
+@EnableJpaRepositories(basePackages = {"at.procon.ted.repository", "at.procon.dip.domain.document.repository", "at.procon.dip.domain.tenant.repository", "at.procon.dip.domain.ted.repository", "at.procon.dip.embedding.job.repository"})
 public class DocumentIntelligencePlatformApplication {

    public static void main(String[] args) {
--- a/src/main/java/at/procon/dip/domain/document/RepresentationType.java
+++ b/src/main/java/at/procon/dip/domain/document/RepresentationType.java
@ -9,6 +9,5 @@ public enum RepresentationType {
    SUMMARY,
    TITLE_ABSTRACT,
    CHUNK,
-    METADATA_ENRICHED,
-    ATTACHMENT_ROLLUP
+    METADATA_ENRICHED
 }
--- a/src/main/java/at/procon/dip/domain/document/repository/DocumentEmbeddingRepository.java
+++ b/src/main/java/at/procon/dip/domain/document/repository/DocumentEmbeddingRepository.java
@ -38,7 +38,7 @@ public interface DocumentEmbeddingRepository extends JpaRepository<DocumentEmbed
            "error_message = NULL, token_count = :tokenCount, embedding_dimensions = :dimensions WHERE id = :id",
            nativeQuery = true)
    int updateEmbeddingVector(@Param("id") UUID id,
-                              @Param("vectorData") float[] vectorData,
+                              @Param("vectorData") String vectorData,
                              @Param("tokenCount") Integer tokenCount,
                              @Param("dimensions") Integer dimensions);

--- a/src/main/java/at/procon/dip/domain/ted/config/TedProjectionProperties.java
+++ b/src/main/java/at/procon/dip/domain/ted/config/TedProjectionProperties.java
@ -1,16 +0,0 @@
-package at.procon.dip.domain.ted.config;
-
-import jakarta.validation.constraints.Positive;
-import lombok.Data;
-import org.springframework.boot.context.properties.ConfigurationProperties;
-import org.springframework.context.annotation.Configuration;
-
-@Configuration
-@ConfigurationProperties(prefix = "dip.ted.projection")
-@Data
-public class TedProjectionProperties {
-    private boolean enabled = true;
-    private boolean startupBackfillEnabled = false;
-    @Positive
-    private int startupBackfillLimit = 250;
-}
--- a/src/main/java/at/procon/dip/domain/ted/entity/TedNoticeOrganization.java
+++ b/src/main/java/at/procon/dip/domain/ted/entity/TedNoticeOrganization.java
@ -55,10 +55,10 @@ public class TedNoticeOrganization {
    @Column(name = "company_id", length = 1000)
    private String companyId;

-    @Column(name = "country_code", columnDefinition = "TEXT")
+    @Column(name = "country_code", length = 10)
    private String countryCode;

-    @Column(name = "city", columnDefinition = "TEXT")
+    @Column(name = "city", length = 255)
    private String city;

    @Column(name = "postal_code", length = 255)
--- a/src/main/java/at/procon/dip/domain/ted/entity/TedNoticeProjection.java
+++ b/src/main/java/at/procon/dip/domain/ted/entity/TedNoticeProjection.java
@ -108,7 +108,7 @@ public class TedNoticeProjection {
    @Column(name = "buyer_country_code", length = 10)
    private String buyerCountryCode;

-    @Column(name = "buyer_city", columnDefinition = "TEXT")
+    @Column(name = "buyer_city", length = 255)
    private String buyerCity;

    @Column(name = "buyer_postal_code", length = 100)
@ -129,7 +129,7 @@ public class TedNoticeProjection {
    @Column(name = "project_description", columnDefinition = "TEXT")
    private String projectDescription;

-    @Column(name = "internal_reference", columnDefinition = "TEXT")
+    @Column(name = "internal_reference", length = 500)
    private String internalReference;

    @Enumerated(EnumType.STRING)
--- a/src/main/java/at/procon/dip/domain/ted/service/DefaultTedPackageSequenceService.java
+++ b/src/main/java/at/procon/dip/domain/ted/service/DefaultTedPackageSequenceService.java
@ -1,189 +0,0 @@
-package at.procon.dip.domain.ted.service;
-
-import at.procon.dip.runtime.condition.ConditionalOnRuntimeMode;
-import at.procon.dip.runtime.config.RuntimeMode;
-import at.procon.dip.ingestion.config.TedPackageDownloadProperties;
-import at.procon.ted.model.entity.TedDailyPackage;
-import at.procon.ted.repository.TedDailyPackageRepository;
-import java.time.Duration;
-import java.time.LocalDate;
-import java.time.OffsetDateTime;
-import java.time.Year;
-import java.time.ZoneOffset;
-import java.util.Optional;
-import lombok.RequiredArgsConstructor;
-import lombok.extern.slf4j.Slf4j;
-import org.springframework.stereotype.Service;
-
-/**
- * NEW-runtime implementation of TED package sequencing.
- * <p>
- * This reuses the same decision rules as the legacy TED package downloader:
- * <ul>
- *   <li>current year forward crawling first</li>
- *   <li>gap filling by walking backward to package 1</li>
- *   <li>NOT_FOUND retry handling with current-year indefinite retry support</li>
- *   <li>previous-year grace period before a tail NOT_FOUND becomes final</li>
- * </ul>
- */
-@Service
-@ConditionalOnRuntimeMode(RuntimeMode.NEW)
-@RequiredArgsConstructor
-@Slf4j
-public class DefaultTedPackageSequenceService implements TedPackageSequenceService {
-
-    private final TedPackageDownloadProperties properties;
-    private final TedDailyPackageRepository packageRepository;
-
-    @Override
-    public PackageInfo getNextPackageToDownload() {
-        int currentYear = Year.now().getValue();
-
-        log.debug("Determining next TED package to download for NEW runtime (current year: {})", currentYear);
-
-        // 1) Current year forward crawling first (newest data first)
-        PackageInfo nextInCurrentYear = getNextForwardPackage(currentYear);
-        if (nextInCurrentYear != null) {
-            log.info("Next TED package: {} (current year {} forward)", nextInCurrentYear.identifier(), currentYear);
-            return nextInCurrentYear;
-        }
-
-        // 2) Walk all years backward and fill gaps / continue unfinished years
-        for (int year = currentYear; year >= properties.getStartYear(); year--) {
-            PackageInfo gapFiller = getGapFillerPackage(year);
-            if (gapFiller != null) {
-                log.info("Next TED package: {} (filling gap in year {})", gapFiller.identifier(), year);
-                return gapFiller;
-            }
-
-            if (!isYearComplete(year)) {
-                PackageInfo forwardPackage = getNextForwardPackage(year);
-                if (forwardPackage != null) {
-                    log.info("Next TED package: {} (continuing year {})", forwardPackage.identifier(), year);
-                    return forwardPackage;
-                }
-            } else {
-                log.debug("TED package year {} is complete", year);
-            }
-        }
-
-        // 3) Open a new older year if possible
-        int oldestYear = getOldestYearWithData();
-        if (oldestYear > properties.getStartYear()) {
-            int previousYear = oldestYear - 1;
-            if (previousYear >= properties.getStartYear()) {
-                PackageInfo first = new PackageInfo(previousYear, 1);
-                log.info("Next TED package: {} (opening year {})", first.identifier(), previousYear);
-                return first;
-            }
-        }
-
-        log.info("All TED package years from {} to {} appear complete - nothing to download",
-                properties.getStartYear(), currentYear);
-        return null;
-    }
-
-    private PackageInfo getNextForwardPackage(int year) {
-        Optional<TedDailyPackage> latest = packageRepository.findLatestByYear(year);
-
-        if (latest.isEmpty()) {
-            return new PackageInfo(year, 1);
-        }
-
-        TedDailyPackage latestPackage = latest.get();
-
-        if (latestPackage.getDownloadStatus() == TedDailyPackage.DownloadStatus.NOT_FOUND) {
-            if (shouldRetryNotFoundPackage(latestPackage)) {
-                return new PackageInfo(year, latestPackage.getSerialNumber());
-            }
-
-            if (isNotFoundRetryableForYear(latestPackage)) {
-                log.debug("Year {} still inside NOT_FOUND retry window for package {} until {}",
-                        year, latestPackage.getPackageIdentifier(), calculateNextRetryAt(latestPackage));
-                return null;
-            }
-
-            log.debug("Year {} finalized after grace period at tail package {}", year, latestPackage.getPackageIdentifier());
-            return null;
-        }
-
-        return new PackageInfo(year, latestPackage.getSerialNumber() + 1);
-    }
-
-    private PackageInfo getGapFillerPackage(int year) {
-        Optional<TedDailyPackage> first = packageRepository.findFirstByYear(year);
-
-        if (first.isEmpty()) {
-            return null;
-        }
-
-        int minSerial = first.get().getSerialNumber();
-        if (minSerial <= 1) {
-            return null;
-        }
-
-        return new PackageInfo(year, minSerial - 1);
-    }
-
-    private boolean isYearComplete(int year) {
-        Optional<TedDailyPackage> first = packageRepository.findFirstByYear(year);
-        Optional<TedDailyPackage> latest = packageRepository.findLatestByYear(year);
-
-        if (first.isEmpty() || latest.isEmpty()) {
-            return false;
-        }
-
-        if (first.get().getSerialNumber() != 1) {
-            return false;
-        }
-
-        TedDailyPackage latestPackage = latest.get();
-        return latestPackage.getDownloadStatus() == TedDailyPackage.DownloadStatus.NOT_FOUND
-                && !isNotFoundRetryableForYear(latestPackage);
-    }
-
-    private boolean shouldRetryNotFoundPackage(TedDailyPackage pkg) {
-        if (!isNotFoundRetryableForYear(pkg)) {
-            return false;
-        }
-
-        OffsetDateTime nextRetryAt = calculateNextRetryAt(pkg);
-        return !nextRetryAt.isAfter(OffsetDateTime.now());
-    }
-
-    private boolean isNotFoundRetryableForYear(TedDailyPackage pkg) {
-        int currentYear = Year.now().getValue();
-        int packageYear = pkg.getYear() != null ? pkg.getYear() : currentYear;
-
-        if (packageYear >= currentYear) {
-            return properties.isRetryCurrentYearNotFoundIndefinitely();
-        }
-
-        return OffsetDateTime.now().isBefore(getYearRetryGraceDeadline(packageYear));
-    }
-
-    private OffsetDateTime calculateNextRetryAt(TedDailyPackage pkg) {
-        OffsetDateTime lastAttemptAt = pkg.getUpdatedAt() != null
-                ? pkg.getUpdatedAt()
-                : (pkg.getCreatedAt() != null ? pkg.getCreatedAt() : OffsetDateTime.now());
-
-        return lastAttemptAt.plus(Duration.ofMillis(properties.getNotFoundRetryInterval()));
-    }
-
-    private OffsetDateTime getYearRetryGraceDeadline(int year) {
-        return LocalDate.of(year + 1, 1, 1)
-                .atStartOfDay()
-                .atOffset(ZoneOffset.UTC)
-                .plusDays(properties.getPreviousYearGracePeriodDays());
-    }
-
-    private int getOldestYearWithData() {
-        int currentYear = Year.now().getValue();
-        for (int year = properties.getStartYear(); year <= currentYear; year++) {
-            if (packageRepository.findLatestByYear(year).isPresent()) {
-                return year;
-            }
-        }
-        return currentYear;
-    }
-}
--- a/src/main/java/at/procon/dip/domain/ted/service/TedNoticeProjectionService.java
+++ b/src/main/java/at/procon/dip/domain/ted/service/TedNoticeProjectionService.java
@ -8,9 +8,7 @@ import at.procon.dip.domain.ted.entity.TedNoticeProjection;
 import at.procon.dip.domain.ted.repository.TedNoticeLotRepository;
 import at.procon.dip.domain.ted.repository.TedNoticeOrganizationRepository;
 import at.procon.dip.domain.ted.repository.TedNoticeProjectionRepository;
-import at.procon.dip.domain.ted.config.TedProjectionProperties;
-import at.procon.dip.runtime.condition.ConditionalOnRuntimeMode;
-import at.procon.dip.runtime.config.RuntimeMode;
+import at.procon.ted.config.TedProcessorProperties;
 import at.procon.ted.model.entity.Organization;
 import at.procon.ted.model.entity.ProcurementDocument;
 import at.procon.ted.model.entity.ProcurementLot;
@ -26,12 +24,11 @@ import org.springframework.transaction.annotation.Transactional;
 * Phase 3 service that materializes TED-specific structured projections on top of the generic DOC document root.
 */
@Service
-@ConditionalOnRuntimeMode(RuntimeMode.NEW)
@RequiredArgsConstructor
@Slf4j
 public class TedNoticeProjectionService {

-    private final TedProjectionProperties properties;
+    private final TedProcessorProperties properties;
    private final TedGenericDocumentRootService tedGenericDocumentRootService;
    private final DocumentRepository documentRepository;
    private final TedNoticeProjectionRepository projectionRepository;
@ -40,7 +37,7 @@ public class TedNoticeProjectionService {

    @Transactional
    public UUID registerOrRefreshProjection(ProcurementDocument legacyDocument) {
-        if (!properties.isEnabled()) {
+        if (!properties.getProjection().isEnabled()) {
            return null;
        }

@ -50,7 +47,7 @@ public class TedNoticeProjectionService {

    @Transactional
    public UUID registerOrRefreshProjection(ProcurementDocument legacyDocument, UUID genericDocumentId) {
-        if (!properties.isEnabled()) {
+        if (!properties.getProjection().isEnabled()) {
            return null;
        }

--- a/src/main/java/at/procon/dip/domain/ted/service/TedPackageSequenceService.java
+++ b/src/main/java/at/procon/dip/domain/ted/service/TedPackageSequenceService.java
@ -1,25 +0,0 @@
-package at.procon.dip.domain.ted.service;
-
-/**
- * Shared package sequencing contract used to determine the next TED daily package to download.
- * <p>
- * This service encapsulates the proven sequencing rules from the legacy download implementation
- * so they can also be used by the NEW runtime without depending on the old route/service graph.
- */
-public interface TedPackageSequenceService {
-
-    /**
-     * Returns the next package to download according to the current sequencing strategy,
-     * or {@code null} if nothing should be downloaded right now.
-     */
-    PackageInfo getNextPackageToDownload();
-
-    /**
-     * Simple year/serial pair with TED package identifier helper.
-     */
-    record PackageInfo(int year, int serialNumber) {
-        public String identifier() {
-            return "%04d%05d".formatted(year, serialNumber);
-        }
-    }
-}
--- a/src/main/java/at/procon/dip/domain/ted/startup/TedProjectionStartupRunner.java
+++ b/src/main/java/at/procon/dip/domain/ted/startup/TedProjectionStartupRunner.java
@ -2,9 +2,7 @@ package at.procon.dip.domain.ted.startup;

 import at.procon.dip.domain.ted.repository.TedNoticeProjectionRepository;
 import at.procon.dip.domain.ted.service.TedNoticeProjectionService;
-import at.procon.dip.domain.ted.config.TedProjectionProperties;
-import at.procon.dip.runtime.condition.ConditionalOnRuntimeMode;
-import at.procon.dip.runtime.config.RuntimeMode;
+import at.procon.ted.config.TedProcessorProperties;
 import at.procon.ted.repository.ProcurementDocumentRepository;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
@ -18,23 +16,22 @@ import org.springframework.stereotype.Component;
 * Optional startup backfill for Phase 3 TED projections.
 */
@Component
-@ConditionalOnRuntimeMode(RuntimeMode.NEW)
@RequiredArgsConstructor
@Slf4j
 public class TedProjectionStartupRunner implements ApplicationRunner {

-    private final TedProjectionProperties properties;
+    private final TedProcessorProperties properties;
    private final ProcurementDocumentRepository procurementDocumentRepository;
    private final TedNoticeProjectionRepository projectionRepository;
    private final TedNoticeProjectionService projectionService;

    @Override
    public void run(ApplicationArguments args) {
-        if (!properties.isEnabled() || !properties.isStartupBackfillEnabled()) {
+        if (!properties.getProjection().isEnabled() || !properties.getProjection().isStartupBackfillEnabled()) {
            return;
        }

-        int limit = properties.getStartupBackfillLimit();
+        int limit = properties.getProjection().getStartupBackfillLimit();
        log.info("Phase 3 startup backfill enabled - ensuring TED projections for up to {} documents", limit);

        var page = procurementDocumentRepository.findAll(
--- a/src/main/java/at/procon/dip/embedding/config/EmbeddingJobSchedulingConfiguration.java
+++ b/src/main/java/at/procon/dip/embedding/config/EmbeddingJobSchedulingConfiguration.java
@ -1,12 +0,0 @@
-package at.procon.dip.embedding.config;
-
-import at.procon.dip.runtime.condition.ConditionalOnRuntimeMode;
-import at.procon.dip.runtime.config.RuntimeMode;
-import org.springframework.context.annotation.Configuration;
-import org.springframework.scheduling.annotation.EnableScheduling;
-
-@Configuration
-@EnableScheduling
-@ConditionalOnRuntimeMode(RuntimeMode.NEW)
-public class EmbeddingJobSchedulingConfiguration {
-}
--- a/src/main/java/at/procon/dip/embedding/config/EmbeddingPolicyCondition.java
+++ b/src/main/java/at/procon/dip/embedding/config/EmbeddingPolicyCondition.java
@ -1,14 +0,0 @@
-package at.procon.dip.embedding.config;
-
-import lombok.Data;
-
-@Data
-public class EmbeddingPolicyCondition {
-    private String documentType;
-    private String documentFamily;
-    private String sourceType;
-    private String mimeType;
-    private String language;
-    private String ownerTenantKey;
-    private String embeddingPolicyHint;
-}
--- a/src/main/java/at/procon/dip/embedding/config/EmbeddingPolicyProperties.java
+++ b/src/main/java/at/procon/dip/embedding/config/EmbeddingPolicyProperties.java
@ -1,16 +0,0 @@
-package at.procon.dip.embedding.config;
-
-import java.util.ArrayList;
-import java.util.List;
-import lombok.Data;
-import org.springframework.boot.context.properties.ConfigurationProperties;
-import org.springframework.context.annotation.Configuration;
-
-@Configuration
-@ConfigurationProperties(prefix = "dip.embedding.policies")
-@Data
-public class EmbeddingPolicyProperties {
-
-    private EmbeddingPolicyUse defaultPolicy = new EmbeddingPolicyUse();
-    private List<EmbeddingPolicyRule> rules = new ArrayList<>();
-}
--- a/src/main/java/at/procon/dip/embedding/config/EmbeddingPolicyRule.java
+++ b/src/main/java/at/procon/dip/embedding/config/EmbeddingPolicyRule.java
@ -1,10 +0,0 @@
-package at.procon.dip.embedding.config;
-
-import lombok.Data;
-
-@Data
-public class EmbeddingPolicyRule {
-    private String name;
-    private EmbeddingPolicyCondition when = new EmbeddingPolicyCondition();
-    private EmbeddingPolicyUse use = new EmbeddingPolicyUse();
-}
--- a/src/main/java/at/procon/dip/embedding/config/EmbeddingPolicyUse.java
+++ b/src/main/java/at/procon/dip/embedding/config/EmbeddingPolicyUse.java
@ -1,12 +0,0 @@
-package at.procon.dip.embedding.config;
-
-import lombok.Data;
-
-@Data
-public class EmbeddingPolicyUse {
-    private String policyKey;
-    private String modelKey;
-    private String queryModelKey;
-    private String profileKey;
-    private boolean enabled = true;
-}
--- a/src/main/java/at/procon/dip/embedding/config/EmbeddingProfileProperties.java
+++ b/src/main/java/at/procon/dip/embedding/config/EmbeddingProfileProperties.java
@ -1,23 +0,0 @@
-package at.procon.dip.embedding.config;
-
-import at.procon.dip.domain.document.RepresentationType;
-import java.util.ArrayList;
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Map;
-import lombok.Data;
-import org.springframework.boot.context.properties.ConfigurationProperties;
-import org.springframework.context.annotation.Configuration;
-
-@Configuration
-@ConfigurationProperties(prefix = "dip.embedding.profiles")
-@Data
-public class EmbeddingProfileProperties {
-
-    private Map<String, ProfileDefinition> definitions = new LinkedHashMap<>();
-
-    @Data
-    public static class ProfileDefinition {
-        private List<RepresentationType> embedRepresentationTypes = new ArrayList<>();
-    }
-}
--- a/src/main/java/at/procon/dip/embedding/config/EmbeddingProperties.java
+++ b/src/main/java/at/procon/dip/embedding/config/EmbeddingProperties.java
@ -30,14 +30,6 @@ public class EmbeddingProperties {
        private Duration readTimeout = Duration.ofSeconds(60);
        private Map<String, String> headers = new LinkedHashMap<>();
        private Integer dimensions;
-        private BatchRequestProperties batchRequest = new BatchRequestProperties();
-    }
-
-    @Data
-    public static class BatchRequestProperties {
-        private boolean truncateText = false;
-        private int truncateLength = 512;
-        private int chunkSize = 20;
    }

    @Data
@ -67,11 +59,8 @@ public class EmbeddingProperties {
    public static class JobsProperties {
        private boolean enabled = false;
        private int batchSize = 16;
-        private boolean processInBatches = false;
-        private int executionBatchSize = 8;
        private int maxRetries = 5;
        private Duration initialRetryDelay = Duration.ofSeconds(30);
        private Duration maxRetryDelay = Duration.ofHours(6);
-        private long schedulerDelayMs = 5000;
    }
 }
--- a/src/main/java/at/procon/dip/embedding/job/EmbeddingJobScheduler.java
+++ b/src/main/java/at/procon/dip/embedding/job/EmbeddingJobScheduler.java
@ -1,32 +0,0 @@
-package at.procon.dip.embedding.job;
-
-import at.procon.dip.embedding.service.RepresentationEmbeddingOrchestrator;
-import at.procon.dip.runtime.condition.ConditionalOnRuntimeMode;
-import at.procon.dip.runtime.config.RuntimeMode;
-import lombok.RequiredArgsConstructor;
-import lombok.extern.slf4j.Slf4j;
-import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
-import org.springframework.scheduling.annotation.Scheduled;
-import org.springframework.stereotype.Component;
-
-@Component
-@RequiredArgsConstructor
-@Slf4j
-@ConditionalOnRuntimeMode(RuntimeMode.NEW)
-@ConditionalOnProperty(prefix = "dip.embedding.jobs", name = "enabled", havingValue = "true")
-public class EmbeddingJobScheduler {
-
-    private final RepresentationEmbeddingOrchestrator orchestrator;
-
-    @Scheduled(fixedDelayString = "${dip.embedding.jobs.scheduler-delay-ms:5000}")
-    public void processNextBatch() {
-        try {
-            int processed = orchestrator.processNextReadyBatch();
-            if (processed > 0) {
-                log.debug("NEW runtime embedding job scheduler processed {} job(s)", processed);
-            }
-        } catch (Exception ex) {
-            log.warn("NEW runtime embedding job scheduler failed: {}", ex.getMessage(), ex);
-        }
-    }
-}
--- a/src/main/java/at/procon/dip/embedding/job/service/EmbeddingJobService.java
+++ b/src/main/java/at/procon/dip/embedding/job/service/EmbeddingJobService.java
@ -1,14 +1,13 @@
 package at.procon.dip.embedding.job.service;

-import at.procon.dip.domain.document.entity.DocumentTextRepresentation;
 import at.procon.dip.embedding.config.EmbeddingProperties;
 import at.procon.dip.embedding.job.entity.EmbeddingJob;
 import at.procon.dip.embedding.job.repository.EmbeddingJobRepository;
 import at.procon.dip.embedding.model.EmbeddingJobStatus;
 import at.procon.dip.embedding.model.EmbeddingJobType;
-import at.procon.dip.embedding.policy.EmbeddingProfile;
 import at.procon.dip.embedding.policy.EmbeddingSelectionPolicy;
 import at.procon.dip.embedding.registry.EmbeddingModelRegistry;
+import at.procon.dip.domain.document.entity.DocumentTextRepresentation;
 import java.time.Duration;
 import java.time.OffsetDateTime;
 import java.util.List;
@ -47,14 +46,6 @@ public class EmbeddingJobService {
                .toList();
    }

-    public List<EmbeddingJob> enqueueForDocument(UUID documentId, String modelKey, EmbeddingProfile profile) {
-        var model = modelRegistry.getRequired(modelKey);
-        List<DocumentTextRepresentation> selected = selectionPolicy.selectRepresentations(documentId, model, profile);
-        return selected.stream()
-                .map(representation -> enqueueForRepresentation(documentId, representation.getId(), modelKey, EmbeddingJobType.DOCUMENT_EMBED))
-                .toList();
-    }
-
    public EmbeddingJob enqueueForRepresentation(UUID documentId, UUID representationId, String modelKey, EmbeddingJobType jobType) {
        return jobRepository.findFirstByRepresentationIdAndModelKeyAndJobTypeAndStatusIn(
                        representationId,
--- a/src/main/java/at/procon/dip/embedding/model/ResolvedEmbeddingProviderConfig.java
+++ b/src/main/java/at/procon/dip/embedding/model/ResolvedEmbeddingProviderConfig.java
@ -13,9 +13,6 @@ public record ResolvedEmbeddingProviderConfig(
        Duration connectTimeout,
        Duration readTimeout,
        Map<String, String> headers,
-        Integer dimensions,
-        Boolean batchTruncateText,
-        Integer batchTruncateLength,
-        Integer batchChunkSize
+        Integer dimensions
 ) {
 }
--- a/src/main/java/at/procon/dip/embedding/policy/DefaultEmbeddingSelectionPolicy.java
+++ b/src/main/java/at/procon/dip/embedding/policy/DefaultEmbeddingSelectionPolicy.java
@ -23,24 +23,18 @@ public class DefaultEmbeddingSelectionPolicy implements EmbeddingSelectionPolicy

    @Override
    public List<DocumentTextRepresentation> selectRepresentations(UUID documentId, EmbeddingModelDescriptor model) {
-        return selectRepresentations(documentId, model, null);
-    }
-
-    @Override
-    public List<DocumentTextRepresentation> selectRepresentations(UUID documentId, EmbeddingModelDescriptor model, EmbeddingProfile profile) {
        List<DocumentTextRepresentation> representations = representationRepository.findByDocument_Id(documentId);
        List<DocumentTextRepresentation> selected = new ArrayList<>();
        EmbeddingProperties.IndexingProperties indexing = embeddingProperties.getIndexing();

        for (DocumentTextRepresentation representation : representations) {
-            if (include(representation, indexing, profile)) {
+            if (include(representation, indexing)) {
                selected.add(representation);
            }
        }

        if (selected.isEmpty()) {
            representationRepository.findFirstByDocument_IdAndPrimaryRepresentationTrue(documentId)
-                    .filter(rep -> include(rep, indexing, profile))
                    .ifPresent(selected::add);
        }

@ -54,12 +48,7 @@ public class DefaultEmbeddingSelectionPolicy implements EmbeddingSelectionPolicy
                .toList();
    }

-    private boolean include(DocumentTextRepresentation representation,
-                            EmbeddingProperties.IndexingProperties indexing,
-                            EmbeddingProfile profile) {
-        if (profile != null && !profile.includes(representation.getRepresentationType())) {
-            return false;
-        }
+    private boolean include(DocumentTextRepresentation representation, EmbeddingProperties.IndexingProperties indexing) {
        return switch (representation.getRepresentationType()) {
            case SEMANTIC_TEXT -> indexing.isEmbedSemanticText();
            case TITLE_ABSTRACT -> indexing.isEmbedTitleAbstract();
--- a/src/main/java/at/procon/dip/embedding/policy/EmbeddingPolicy.java
+++ b/src/main/java/at/procon/dip/embedding/policy/EmbeddingPolicy.java
@ -1,10 +0,0 @@
-package at.procon.dip.embedding.policy;
-
-public record EmbeddingPolicy(
-        String policyKey,
-        String modelKey,
-        String queryModelKey,
-        String profileKey,
-        boolean enabled
-) {
-}
--- a/src/main/java/at/procon/dip/embedding/policy/EmbeddingProfile.java
+++ b/src/main/java/at/procon/dip/embedding/policy/EmbeddingProfile.java
@ -1,13 +0,0 @@
-package at.procon.dip.embedding.policy;
-
-import at.procon.dip.domain.document.RepresentationType;
-import java.util.List;
-
-public record EmbeddingProfile(
-        String profileKey,
-        List<RepresentationType> embedRepresentationTypes
-) {
-    public boolean includes(RepresentationType representationType) {
-        return embedRepresentationTypes != null && embedRepresentationTypes.contains(representationType);
-    }
-}
--- a/src/main/java/at/procon/dip/embedding/policy/EmbeddingSelectionPolicy.java
+++ b/src/main/java/at/procon/dip/embedding/policy/EmbeddingSelectionPolicy.java
@ -8,6 +8,4 @@ import java.util.UUID;
 public interface EmbeddingSelectionPolicy {

    List<DocumentTextRepresentation> selectRepresentations(UUID documentId, EmbeddingModelDescriptor model);
-
-    List<DocumentTextRepresentation> selectRepresentations(UUID documentId, EmbeddingModelDescriptor model, EmbeddingProfile profile);
 }
--- a/src/main/java/at/procon/dip/embedding/provider/http/AbstractHttpEmbeddingProviderSupport.java
+++ b/src/main/java/at/procon/dip/embedding/provider/http/AbstractHttpEmbeddingProviderSupport.java
@ -1,68 +0,0 @@
-package at.procon.dip.embedding.provider.http;
-
-import at.procon.dip.embedding.model.ResolvedEmbeddingProviderConfig;
-import com.fasterxml.jackson.databind.ObjectMapper;
-import java.io.IOException;
-import java.net.URI;
-import java.net.http.HttpClient;
-import java.net.http.HttpRequest;
-import java.net.http.HttpResponse;
-import java.nio.charset.StandardCharsets;
-import java.time.Duration;
-import java.util.List;
-import lombok.RequiredArgsConstructor;
-
-@RequiredArgsConstructor
-abstract class AbstractHttpEmbeddingProviderSupport {
-
-    protected final ObjectMapper objectMapper;
-    protected final HttpClient httpClient = HttpClient.newBuilder()
-            .version(HttpClient.Version.HTTP_1_1)
-            .build();
-
-    protected String trimTrailingSlash(String value) {
-        if (value == null || value.isBlank()) {
-            throw new IllegalArgumentException("Embedding provider baseUrl must be configured");
-        }
-        return value.endsWith("/") ? value.substring(0, value.length() - 1) : value;
-    }
-
-    protected HttpResponse<String> postJson(ResolvedEmbeddingProviderConfig providerConfig,
-                                            String path,
-                                            Object body) throws IOException, InterruptedException {
-        HttpRequest.Builder builder = HttpRequest.newBuilder()
-                .uri(URI.create(trimTrailingSlash(providerConfig.baseUrl()) + path))
-                .timeout(providerConfig.readTimeout() == null ? Duration.ofSeconds(60) : providerConfig.readTimeout())
-                .header("Content-Type", "application/json")
-                .POST(HttpRequest.BodyPublishers.ofString(
-                        objectMapper.writeValueAsString(body),
-                        StandardCharsets.UTF_8
-                ));
-
-        if (providerConfig.apiKey() != null && !providerConfig.apiKey().isBlank()) {
-            builder.header("Authorization", "Bearer " + providerConfig.apiKey());
-        }
-        if (providerConfig.headers() != null) {
-            providerConfig.headers().forEach(builder::header);
-        }
-
-        HttpResponse<String> response = httpClient.send(
-                builder.build(),
-                HttpResponse.BodyHandlers.ofString(StandardCharsets.UTF_8)
-        );
-        if (response.statusCode() / 100 != 2) {
-            throw new IllegalStateException(
-                    "Embedding provider returned status %d: %s".formatted(response.statusCode(), response.body())
-            );
-        }
-        return response;
-    }
-
-    protected float[] toArray(List<Float> embedding) {
-        float[] result = new float[embedding.size()];
-        for (int i = 0; i < embedding.size(); i++) {
-            result[i] = embedding.get(i);
-        }
-        return result;
-    }
-}
--- a/src/main/java/at/procon/dip/embedding/provider/http/ExternalHttpEmbeddingProvider.java
+++ b/src/main/java/at/procon/dip/embedding/provider/http/ExternalHttpEmbeddingProvider.java
@ -9,22 +9,26 @@ import at.procon.dip.embedding.provider.EmbeddingProvider;
 import com.fasterxml.jackson.annotation.JsonProperty;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import java.io.IOException;
+import java.net.URI;
+import java.net.http.HttpClient;
+import java.net.http.HttpRequest;
 import java.net.http.HttpResponse;
+import java.nio.charset.StandardCharsets;
+import java.time.Duration;
+import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Component;

-/**
- * Existing HTTP/JSON embedding provider using the /embed contract.
- */
@Component
-public class ExternalHttpEmbeddingProvider extends AbstractHttpEmbeddingProviderSupport implements EmbeddingProvider {
+@RequiredArgsConstructor
+public class ExternalHttpEmbeddingProvider implements EmbeddingProvider {
+
    private static final String PROVIDER_TYPE = "http-json";

-    public ExternalHttpEmbeddingProvider(ObjectMapper objectMapper, ObjectMapper mapper) {
-        super(objectMapper);
-    }
+    private final ObjectMapper objectMapper;
+    private final HttpClient httpClient = HttpClient.newBuilder().version(HttpClient.Version.HTTP_1_1).build();

    @Override
    public String providerType() {
@ -40,43 +44,61 @@ public class ExternalHttpEmbeddingProvider extends AbstractHttpEmbeddingProvider
    public EmbeddingProviderResult embedDocuments(ResolvedEmbeddingProviderConfig providerConfig,
                                                  EmbeddingModelDescriptor model,
                                                  EmbeddingRequest request) {
-        return execute(providerConfig, request, EmbeddingUseCase.DOCUMENT);
+        return execute(providerConfig, model, request, EmbeddingUseCase.DOCUMENT);
    }

    @Override
    public EmbeddingProviderResult embedQuery(ResolvedEmbeddingProviderConfig providerConfig,
                                              EmbeddingModelDescriptor model,
                                              EmbeddingRequest request) {
-        return execute(providerConfig, request, EmbeddingUseCase.QUERY);
+        return execute(providerConfig, model, request, EmbeddingUseCase.QUERY);
    }

    private EmbeddingProviderResult execute(ResolvedEmbeddingProviderConfig providerConfig,
+                                            EmbeddingModelDescriptor model,
                                            EmbeddingRequest request,
                                            EmbeddingUseCase useCase) {
-        if (request.texts() == null || request.texts().isEmpty()) {
-            throw new IllegalArgumentException("Embedding request texts must not be empty");
-        }
-
        try {
-            HttpResponse<String> response = postJson(
-                    providerConfig,
-                    "/embed",
-                    Map.of(
-                            "text", request.texts().getFirst(),
-                            "isQuery", useCase == EmbeddingUseCase.QUERY
-                    )
+            var payload = new ProviderRequest(
+                    model.providerModelKey(),
+                    request.texts(),
+                    useCase == EmbeddingUseCase.QUERY,
+                    request.providerOptions() == null ? Map.of() : request.providerOptions()
            );

-            EmbedResponse parsed = objectMapper.readValue(response.body(), EmbedResponse.class);
-            if (parsed.embedding == null) {
-                throw new IllegalStateException("Embedding provider returned no embedding");
+            HttpRequest.Builder builder = HttpRequest.newBuilder()
+                    .uri(URI.create(trimTrailingSlash(providerConfig.baseUrl()) + "/embed"))
+                    .timeout(providerConfig.readTimeout() == null ? Duration.ofSeconds(60) : providerConfig.readTimeout())
+                    .header("Content-Type", "application/json")
+                    .POST(HttpRequest.BodyPublishers.ofString(objectMapper.writeValueAsString(payload), StandardCharsets.UTF_8));
+
+            if (providerConfig.apiKey() != null && !providerConfig.apiKey().isBlank()) {
+                builder.header("Authorization", "Bearer " + providerConfig.apiKey());
+            }
+            if (providerConfig.headers() != null) {
+                providerConfig.headers().forEach(builder::header);
+            }
+
+            HttpResponse<String> response = httpClient.send(builder.build(), HttpResponse.BodyHandlers.ofString(StandardCharsets.UTF_8));
+            if (response.statusCode() / 100 != 2) {
+                throw new IllegalStateException("Embedding provider returned status %d: %s".formatted(response.statusCode(), response.body()));
+            }
+
+            ProviderResponse parsed = objectMapper.readValue(response.body(), ProviderResponse.class);
+            List<float[]> vectors = new ArrayList<>();
+            if (parsed.embeddings != null) {
+                for (List<Float> embedding : parsed.embeddings) {
+                    vectors.add(toArray(embedding));
+                }
+            } else if (parsed.embedding != null) {
+                vectors.add(toArray(parsed.embedding));
            }

            return new EmbeddingProviderResult(
-                    null,
-                    List.of(parsed.embedding),
-                    List.of(),
-                    null,
+                    model,
+                    vectors,
+                    parsed.warnings == null ? List.of() : parsed.warnings,
+                    parsed.requestId,
                    parsed.tokenCount
            );
        } catch (InterruptedException e) {
@ -87,12 +109,41 @@ public class ExternalHttpEmbeddingProvider extends AbstractHttpEmbeddingProvider
        }
    }

-    public static class EmbedResponse {
+    private float[] toArray(List<Float> embedding) {
+        float[] result = new float[embedding.size()];
+        for (int i = 0; i < embedding.size(); i++) {
+            result[i] = embedding.get(i);
+        }
+        return result;
+    }
+
+    private String trimTrailingSlash(String value) {
+        if (value == null || value.isBlank()) {
+            throw new IllegalArgumentException("Embedding provider baseUrl must be configured");
+        }
+        return value.endsWith("/") ? value.substring(0, value.length() - 1) : value;
+    }
+
+    private record ProviderRequest(
+            @JsonProperty("model") String model,
+            @JsonProperty("texts") List<String> texts,
+            @JsonProperty("is_query") boolean query,
+            @JsonProperty("options") Map<String, Object> options
+    ) {
+    }
+
+    private static class ProviderResponse {
        @JsonProperty("embedding")
-        public float[] embedding;
+        public List<Float> embedding;
+
+        @JsonProperty("embeddings")
+        public List<List<Float>> embeddings;
+
+        @JsonProperty("warnings")
+        public List<String> warnings;

-        @JsonProperty("dimensions")
-        public Integer dimensions;
+        @JsonProperty("request_id")
+        public String requestId;

        @JsonProperty("token_count")
        public Integer tokenCount;
--- a/src/main/java/at/procon/dip/embedding/provider/http/VectorSyncHttpEmbeddingProvider.java
+++ b/src/main/java/at/procon/dip/embedding/provider/http/VectorSyncHttpEmbeddingProvider.java
@ -1,374 +0,0 @@
-package at.procon.dip.embedding.provider.http;
-
-import at.procon.dip.embedding.model.EmbeddingModelDescriptor;
-import at.procon.dip.embedding.model.EmbeddingProviderResult;
-import at.procon.dip.embedding.model.EmbeddingRequest;
-import at.procon.dip.embedding.model.ResolvedEmbeddingProviderConfig;
-import at.procon.dip.embedding.provider.EmbeddingProvider;
-import com.fasterxml.jackson.annotation.JsonProperty;
-import com.fasterxml.jackson.databind.ObjectMapper;
-import java.io.IOException;
-import java.net.http.HttpResponse;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.UUID;
-import org.springframework.stereotype.Component;
-
-/**
- * HTTP provider for vector APIs.
- *
- * Supported endpoints:
- *   POST {baseUrl}/vector-sync      - single text
- *   POST {baseUrl}/vectorize-batch  - multiple texts
- */
-@Component
-public class VectorSyncHttpEmbeddingProvider extends AbstractHttpEmbeddingProviderSupport implements EmbeddingProvider {
-    private static final String PROVIDER_TYPE = "http-vector-sync";
-
-    private static final boolean DEFAULT_TRUNCATE_TEXT = false;
-    private static final int DEFAULT_TRUNCATE_LENGTH = 512;
-    private static final int DEFAULT_CHUNK_SIZE = 20;
-
-    private static final List<String> TRUNCATE_TEXT_KEYS = List.of(
-            "vectorize-batch.truncate-text",
-            "vectorize-batch.truncate_text",
-            "truncate_text",
-            "truncate-text",
-            "truncateText"
-    );
-
-    private static final List<String> TRUNCATE_LENGTH_KEYS = List.of(
-            "vectorize-batch.truncate-length",
-            "vectorize-batch.truncate_length",
-            "truncate_length",
-            "truncate-length",
-            "truncateLength"
-    );
-
-    private static final List<String> CHUNK_SIZE_KEYS = List.of(
-            "vectorize-batch.chunk-size",
-            "vectorize-batch.chunk_size",
-            "chunk_size",
-            "chunk-size",
-            "chunkSize"
-    );
-
-    public VectorSyncHttpEmbeddingProvider(ObjectMapper objectMapper) {
-        super(objectMapper);
-    }
-
-    @Override
-    public String providerType() {
-        return PROVIDER_TYPE;
-    }
-
-    @Override
-    public boolean supports(EmbeddingModelDescriptor model, ResolvedEmbeddingProviderConfig providerConfig) {
-        return PROVIDER_TYPE.equalsIgnoreCase(providerConfig.providerType());
-    }
-
-    @Override
-    public EmbeddingProviderResult embedDocuments(ResolvedEmbeddingProviderConfig providerConfig,
-                                                  EmbeddingModelDescriptor model,
-                                                  EmbeddingRequest request) {
-        return execute(providerConfig, model, request);
-    }
-
-    @Override
-    public EmbeddingProviderResult embedQuery(ResolvedEmbeddingProviderConfig providerConfig,
-                                              EmbeddingModelDescriptor model,
-                                              EmbeddingRequest request) {
-        return execute(providerConfig, model, request);
-    }
-
-    private EmbeddingProviderResult execute(ResolvedEmbeddingProviderConfig providerConfig,
-                                            EmbeddingModelDescriptor model,
-                                            EmbeddingRequest request) {
-        if (request.texts() == null || request.texts().isEmpty()) {
-            throw new IllegalArgumentException("Embedding request texts must not be empty");
-        }
-
-        try {
-            return request.texts().size() == 1
-                    ? executeSingle(providerConfig, model, request.texts().getFirst())
-                    : executeBatch(providerConfig, model, request);
-        } catch (InterruptedException e) {
-            Thread.currentThread().interrupt();
-            throw new IllegalStateException("Embedding provider call interrupted", e);
-        } catch (IOException e) {
-            throw new IllegalStateException("Failed to call embedding provider", e);
-        }
-    }
-
-    private EmbeddingProviderResult executeSingle(ResolvedEmbeddingProviderConfig providerConfig,
-                                                  EmbeddingModelDescriptor model,
-                                                  String text) throws IOException, InterruptedException {
-        HttpResponse<String> response = postJson(
-                providerConfig,
-                "/vector-sync",
-                new VectorSyncRequest(model.providerModelKey(), text)
-        );
-
-        VectorSyncResponse parsed = objectMapper.readValue(response.body(), VectorSyncResponse.class);
-        float[] vector = extractVector(parsed.vector, parsed.combinedVector, model);
-
-        return new EmbeddingProviderResult(
-                model,
-                List.of(vector),
-                List.of(),
-                null,
-                parsed.tokenCount
-        );
-    }
-
-    private EmbeddingProviderResult executeBatch(ResolvedEmbeddingProviderConfig providerConfig,
-                                                 EmbeddingModelDescriptor model,
-                                                 EmbeddingRequest request) throws IOException, InterruptedException {
-        BatchRequestSettings settings = resolveBatchRequestSettings(providerConfig, request.providerOptions());
-
-        if (settings.truncateLength() <= 0) {
-            throw new IllegalArgumentException("Batch truncate length must be > 0");
-        }
-        if (settings.chunkSize() <= 0) {
-            throw new IllegalArgumentException("Batch chunk size must be > 0");
-        }
-
-        List<String> requestOrder = new ArrayList<>(request.texts().size());
-        List<VectorizeBatchItemRequest> items = new ArrayList<>(request.texts().size());
-
-        for (String text : request.texts()) {
-            String id = UUID.randomUUID().toString();
-            requestOrder.add(id);
-            items.add(new VectorizeBatchItemRequest(id, text));
-        }
-
-        HttpResponse<String> response = postJson(
-                providerConfig,
-                "/vectorize-batch",
-                new VectorizeBatchRequest(
-                        model.providerModelKey(),
-                        settings.truncateText(),
-                        settings.truncateLength(),
-                        settings.chunkSize(),
-                        items
-                )
-        );
-
-        VectorizeBatchResponse parsed = objectMapper.readValue(response.body(), VectorizeBatchResponse.class);
-        if (parsed.results == null || parsed.results.isEmpty()) {
-            throw new IllegalStateException("Vectorize-batch provider returned no results");
-        }
-
-        Map<String, VectorizeBatchItemResponse> resultById = new HashMap<>();
-        for (VectorizeBatchItemResponse result : parsed.results) {
-            resultById.put(result.id, result);
-        }
-
-        List<float[]> vectors = new ArrayList<>(request.texts().size());
-        int totalTokenCount = 0;
-        boolean hasAnyTokenCount = false;
-
-        for (String id : requestOrder) {
-            VectorizeBatchItemResponse item = resultById.get(id);
-            if (item == null) {
-                throw new IllegalStateException("Vectorize-batch provider response is missing item for id " + id);
-            }
-
-            vectors.add(extractVector(item.vector, item.combinedVector, model));
-
-            if (item.tokenCount != null) {
-                totalTokenCount += item.tokenCount;
-                hasAnyTokenCount = true;
-            }
-        }
-
-        return new EmbeddingProviderResult(
-                model,
-                vectors,
-                List.of(),
-                null,
-                hasAnyTokenCount ? totalTokenCount : null
-        );
-    }
-
-    private BatchRequestSettings resolveBatchRequestSettings(ResolvedEmbeddingProviderConfig providerConfig,
-                                                             Map<String, Object> providerOptions) {
-        boolean truncateText = resolveBooleanOption(
-                providerOptions,
-                TRUNCATE_TEXT_KEYS,
-                providerConfig.batchTruncateText() != null ? providerConfig.batchTruncateText() : DEFAULT_TRUNCATE_TEXT
-        );
-        int truncateLength = resolveIntOption(
-                providerOptions,
-                TRUNCATE_LENGTH_KEYS,
-                providerConfig.batchTruncateLength() != null ? providerConfig.batchTruncateLength() : DEFAULT_TRUNCATE_LENGTH
-        );
-        int chunkSize = resolveIntOption(
-                providerOptions,
-                CHUNK_SIZE_KEYS,
-                providerConfig.batchChunkSize() != null ? providerConfig.batchChunkSize() : DEFAULT_CHUNK_SIZE
-        );
-        return new BatchRequestSettings(truncateText, truncateLength, chunkSize);
-    }
-
-    private boolean resolveBooleanOption(Map<String, Object> providerOptions,
-                                         List<String> keys,
-                                         boolean defaultValue) {
-        Object raw = resolveOption(providerOptions, keys);
-        if (raw == null) {
-            return defaultValue;
-        }
-        if (raw instanceof Boolean booleanValue) {
-            return booleanValue;
-        }
-        String normalized = String.valueOf(raw).trim();
-        if (normalized.isEmpty()) {
-            return defaultValue;
-        }
-        return Boolean.parseBoolean(normalized);
-    }
-
-    private int resolveIntOption(Map<String, Object> providerOptions,
-                                 List<String> keys,
-                                 int defaultValue) {
-        Object raw = resolveOption(providerOptions, keys);
-        if (raw == null) {
-            return defaultValue;
-        }
-        if (raw instanceof Number number) {
-            return number.intValue();
-        }
-        String normalized = String.valueOf(raw).trim();
-        if (normalized.isEmpty()) {
-            return defaultValue;
-        }
-        return Integer.parseInt(normalized);
-    }
-
-    private Object resolveOption(Map<String, Object> providerOptions, List<String> keys) {
-        if (providerOptions == null || providerOptions.isEmpty()) {
-            return null;
-        }
-        for (String key : keys) {
-            if (providerOptions.containsKey(key)) {
-                return providerOptions.get(key);
-            }
-        }
-        return null;
-    }
-
-    private float[] extractVector(List<Float> vector,
-                                  List<Float> combinedVector,
-                                  EmbeddingModelDescriptor model) {
-        float[] resolved;
-
-        if (combinedVector != null && !combinedVector.isEmpty()) {
-            resolved = toArray(combinedVector);
-        } else if (vector != null && !vector.isEmpty()) {
-            resolved = toArray(vector);
-        } else {
-            throw new IllegalStateException("Embedding provider returned no vector");
-        }
-
-        if (model.dimensions() > 0 && resolved.length != model.dimensions()) {
-            throw new IllegalStateException(
-                    "Embedding provider returned dimension %d for model %s, expected %d"
-                            .formatted(resolved.length, model.modelKey(), model.dimensions())
-            );
-        }
-
-        return resolved;
-    }
-
-    private record BatchRequestSettings(boolean truncateText, int truncateLength, int chunkSize) {
-    }
-
-    private record VectorSyncRequest(
-            @JsonProperty("model") String model,
-            @JsonProperty("text") String text
-    ) {
-    }
-
-    private record VectorizeBatchRequest(
-            @JsonProperty("model") String model,
-            @JsonProperty("truncate_text") boolean truncateText,
-            @JsonProperty("truncate_length") int truncateLength,
-            @JsonProperty("chunk_size") int chunkSize,
-            @JsonProperty("items") List<VectorizeBatchItemRequest> items
-    ) {
-    }
-
-    private record VectorizeBatchItemRequest(
-            @JsonProperty("id") String id,
-            @JsonProperty("text") String text
-    ) {
-    }
-
-    static class VectorSyncResponse {
-        @JsonProperty("runtime_ms")
-        public Double runtimeMs;
-
-        @JsonProperty("vector")
-        public List<Float> vector;
-
-        @JsonProperty("incomplete")
-        public Boolean incomplete;
-
-        @JsonProperty("combined_vector")
-        public List<Float> combinedVector;
-
-        @JsonProperty("token_count")
-        public Integer tokenCount;
-
-        @JsonProperty("model")
-        public String model;
-
-        @JsonProperty("max_seq_length")
-        public Integer maxSeqLength;
-    }
-
-    static class VectorizeBatchResponse {
-        @JsonProperty("model")
-        public String model;
-
-        @JsonProperty("count")
-        public Integer count;
-
-        @JsonProperty("results")
-        public List<VectorizeBatchItemResponse> results;
-    }
-
-    static class VectorizeBatchItemResponse {
-        @JsonProperty("id")
-        public String id;
-
-        @JsonProperty("vector")
-        public List<Float> vector;
-
-        @JsonProperty("token_count")
-        public Integer tokenCount;
-
-        @JsonProperty("runtime_ms")
-        public Double runtimeMs;
-
-        @JsonProperty("incomplete")
-        public Boolean incomplete;
-
-        @JsonProperty("combined_vector")
-        public List<Float> combinedVector;
-
-        @JsonProperty("truncated")
-        public Boolean truncated;
-
-        @JsonProperty("truncate_length")
-        public Integer truncateLength;
-
-        @JsonProperty("model")
-        public String model;
-
-        @JsonProperty("max_seq_length")
-        public Integer maxSeqLength;
-    }
-}
--- a/src/main/java/at/procon/dip/embedding/registry/EmbeddingProviderConfigResolver.java
+++ b/src/main/java/at/procon/dip/embedding/registry/EmbeddingProviderConfigResolver.java
@ -18,10 +18,6 @@ public class EmbeddingProviderConfigResolver {
            throw new IllegalArgumentException("Unknown embedding provider config key: " + providerConfigKey);
        }

-        EmbeddingProperties.BatchRequestProperties batchRequest = provider.getBatchRequest() == null
-                ? new EmbeddingProperties.BatchRequestProperties()
-                : provider.getBatchRequest();
-
        return ResolvedEmbeddingProviderConfig.builder()
                .key(providerConfigKey)
                .providerType(provider.getType())
@ -31,9 +27,6 @@ public class EmbeddingProviderConfigResolver {
                .readTimeout(provider.getReadTimeout())
                .headers(provider.getHeaders() == null ? Map.of() : Map.copyOf(provider.getHeaders()))
                .dimensions(provider.getDimensions())
-                .batchTruncateText(batchRequest.isTruncateText())
-                .batchTruncateLength(batchRequest.getTruncateLength())
-                .batchChunkSize(batchRequest.getChunkSize())
                .build();
    }
 }
--- a/src/main/java/at/procon/dip/embedding/service/DefaultEmbeddingPolicyResolver.java
+++ b/src/main/java/at/procon/dip/embedding/service/DefaultEmbeddingPolicyResolver.java
@ -1,131 +0,0 @@
-package at.procon.dip.embedding.service;
-
-import at.procon.dip.domain.document.entity.Document;
-import at.procon.dip.embedding.config.EmbeddingPolicyCondition;
-import at.procon.dip.embedding.config.EmbeddingPolicyProperties;
-import at.procon.dip.embedding.config.EmbeddingPolicyRule;
-import at.procon.dip.embedding.config.EmbeddingPolicyUse;
-import at.procon.dip.embedding.policy.EmbeddingPolicy;
-import at.procon.dip.ingestion.spi.SourceDescriptor;
-import java.util.Map;
-import java.util.Objects;
-import java.util.regex.Pattern;
-import lombok.RequiredArgsConstructor;
-import org.springframework.stereotype.Service;
-
-@Service
-@RequiredArgsConstructor
-public class DefaultEmbeddingPolicyResolver implements EmbeddingPolicyResolver {
-
-    private final EmbeddingPolicyProperties properties;
-
-    @Override
-    public EmbeddingPolicy resolve(Document document, SourceDescriptor sourceDescriptor) {
-        String overridePolicy = attributeValue(sourceDescriptor, "embeddingPolicyKey");
-        if (overridePolicy != null) {
-            return policyByKey(overridePolicy);
-        }
-
-        String policyHint = policyHint(sourceDescriptor);
-        if (policyHint != null) {
-            return policyByKey(policyHint);
-        }
-
-        for (EmbeddingPolicyRule rule : properties.getRules()) {
-            if (matches(rule.getWhen(), document, sourceDescriptor)) {
-                return toPolicy(rule.getUse());
-            }
-        }
-
-        return toPolicy(properties.getDefaultPolicy());
-    }
-
-    private EmbeddingPolicy policyByKey(String policyKey) {
-        for (EmbeddingPolicyRule rule : properties.getRules()) {
-            if (rule.getUse() != null && policyKey.equals(rule.getUse().getPolicyKey())) {
-                return toPolicy(rule.getUse());
-            }
-        }
-        EmbeddingPolicyUse def = properties.getDefaultPolicy();
-        if (def != null && policyKey.equals(def.getPolicyKey())) {
-            return toPolicy(def);
-        }
-        throw new IllegalArgumentException("Unknown embedding policy key: " + policyKey);
-    }
-
-    private EmbeddingPolicy toPolicy(EmbeddingPolicyUse use) {
-        if (use == null) {
-            throw new IllegalStateException("Embedding policy configuration is missing");
-        }
-        return new EmbeddingPolicy(
-                use.getPolicyKey(),
-                use.getModelKey(),
-                use.getQueryModelKey(),
-                use.getProfileKey(),
-                use.isEnabled()
-        );
-    }
-
-    private boolean matches(EmbeddingPolicyCondition c, Document document, SourceDescriptor sourceDescriptor) {
-        if (c == null) {
-            return true;
-        }
-
-        if (!matchesExact(c.getDocumentType(), enumName(document != null ? document.getDocumentType() : null))) {
-            return false;
-        }
-        if (!matchesExact(c.getDocumentFamily(), enumName(document != null ? document.getDocumentFamily() : null))) {
-            return false;
-        }
-        if (!matchesExact(c.getSourceType(), enumName(sourceDescriptor != null ? sourceDescriptor.sourceType() : null))) {
-            return false;
-        }
-        if (!matchesMime(c.getMimeType(), sourceDescriptor != null ? sourceDescriptor.mediaType() : null)) {
-            return false;
-        }
-        if (!matchesExact(c.getLanguage(), document != null ? document.getLanguageCode() : null)) {
-            return false;
-        }
-        if (!matchesExact(c.getOwnerTenantKey(), document != null && document.getOwnerTenant() != null ? document.getOwnerTenant().getTenantKey() : null )) {
-            return false;
-        }
-        return matchesExact(c.getEmbeddingPolicyHint(), policyHint(sourceDescriptor));
-    }
-
-    private boolean matchesExact(String expected, String actual) {
-        if (expected == null || expected.isBlank()) {
-            return true;
-        }
-        return Objects.equals(expected, actual);
-    }
-
-    private boolean matchesMime(String pattern, String actual) {
-        if (pattern == null || pattern.isBlank()) {
-            return true;
-        }
-        if (actual == null || actual.isBlank()) {
-            return false;
-        }
-        return Pattern.compile(pattern, Pattern.CASE_INSENSITIVE).matcher(actual).matches();
-    }
-
-    private String enumName(Enum<?> value) {
-        return value != null ? value.name() : null;
-    }
-
-    private String policyHint(SourceDescriptor sourceDescriptor) {
-        return attributeValue(sourceDescriptor, "embeddingPolicyHint");
-    }
-
-    private String attributeValue(SourceDescriptor sourceDescriptor, String key) {
-        if (sourceDescriptor == null) {
-            return null;
-        }
-        Map<String, String> attributes = sourceDescriptor.attributes();
-        if (attributes == null) {
-            return null;
-        }
-        String value = attributes.get(key);
-        return (value == null || value.isBlank()) ? null : value;
-    }
-}
--- a/src/main/java/at/procon/dip/embedding/service/DefaultEmbeddingProfileResolver.java
+++ b/src/main/java/at/procon/dip/embedding/service/DefaultEmbeddingProfileResolver.java
@ -1,31 +0,0 @@
-package at.procon.dip.embedding.service;
-
-import at.procon.dip.embedding.config.EmbeddingProfileProperties;
-import at.procon.dip.embedding.policy.EmbeddingProfile;
-import java.util.List;
-import lombok.RequiredArgsConstructor;
-import org.springframework.stereotype.Service;
-
-@Service
-@RequiredArgsConstructor
-public class DefaultEmbeddingProfileResolver implements EmbeddingProfileResolver {
-
-    private final EmbeddingProfileProperties properties;
-
-    @Override
-    public EmbeddingProfile resolve(String profileKey) {
-        if (profileKey == null || profileKey.isBlank()) {
-            throw new IllegalArgumentException("Embedding profile key must not be blank");
-        }
-
-        EmbeddingProfileProperties.ProfileDefinition definition = properties.getDefinitions().get(profileKey);
-        if (definition == null) {
-            throw new IllegalArgumentException("Unknown embedding profile: " + profileKey);
-        }
-
-        return new EmbeddingProfile(
-                profileKey,
-                List.copyOf(definition.getEmbedRepresentationTypes())
-        );
-    }
-}
--- a/src/main/java/at/procon/dip/embedding/service/EmbeddingPersistenceService.java
+++ b/src/main/java/at/procon/dip/embedding/service/EmbeddingPersistenceService.java
@ -8,6 +8,7 @@ import at.procon.dip.domain.document.repository.DocumentEmbeddingRepository;
 import at.procon.dip.domain.document.repository.DocumentTextRepresentationRepository;
 import at.procon.dip.domain.document.service.DocumentEmbeddingService;
 import at.procon.dip.embedding.model.EmbeddingProviderResult;
+import at.procon.dip.embedding.support.EmbeddingVectorCodec;
 import java.time.OffsetDateTime;
 import java.util.UUID;
 import lombok.RequiredArgsConstructor;
@ -43,17 +44,11 @@ public class EmbeddingPersistenceService {
        if (result.vectors() == null || result.vectors().isEmpty()) {
            throw new IllegalArgumentException("Embedding provider result contains no vectors");
        }
-        saveCompleted(embeddingId, result.vectors().getFirst(), result.tokenCount());
-    }
-
-    public void saveCompleted(UUID embeddingId, float[] vector, Integer tokenCount) {
-        if (vector == null || vector.length == 0) {
-            throw new IllegalArgumentException("Embedding vector must not be empty");
-        }
+        float[] vector = result.vectors().getFirst();
        embeddingRepository.updateEmbeddingVector(
                embeddingId,
-                vector,
-                tokenCount,
+                EmbeddingVectorCodec.toPgVector(vector),
+                result.tokenCount(),
                vector.length
        );
    }
--- a/src/main/java/at/procon/dip/embedding/service/EmbeddingPolicyResolver.java
+++ b/src/main/java/at/procon/dip/embedding/service/EmbeddingPolicyResolver.java
@ -1,9 +0,0 @@
-package at.procon.dip.embedding.service;
-
-import at.procon.dip.domain.document.entity.Document;
-import at.procon.dip.embedding.policy.EmbeddingPolicy;
-import at.procon.dip.ingestion.spi.SourceDescriptor;
-
-public interface EmbeddingPolicyResolver {
-    EmbeddingPolicy resolve(Document document, SourceDescriptor sourceDescriptor);
-}
--- a/src/main/java/at/procon/dip/embedding/service/EmbeddingProfileResolver.java
+++ b/src/main/java/at/procon/dip/embedding/service/EmbeddingProfileResolver.java
@ -1,7 +0,0 @@
-package at.procon.dip.embedding.service;
-
-import at.procon.dip.embedding.policy.EmbeddingProfile;
-
-public interface EmbeddingProfileResolver {
-    EmbeddingProfile resolve(String profileKey);
-}
--- a/src/main/java/at/procon/dip/embedding/service/RepresentationEmbeddingOrchestrator.java
+++ b/src/main/java/at/procon/dip/embedding/service/RepresentationEmbeddingOrchestrator.java
@ -7,14 +7,9 @@ import at.procon.dip.embedding.config.EmbeddingProperties;
 import at.procon.dip.embedding.job.entity.EmbeddingJob;
 import at.procon.dip.embedding.job.service.EmbeddingJobService;
 import at.procon.dip.embedding.model.EmbeddingJobType;
-import at.procon.dip.embedding.model.EmbeddingModelDescriptor;
 import at.procon.dip.embedding.model.EmbeddingProviderResult;
 import at.procon.dip.embedding.model.EmbeddingUseCase;
-import at.procon.dip.embedding.policy.EmbeddingProfile;
-import at.procon.dip.embedding.policy.EmbeddingSelectionPolicy;
 import at.procon.dip.embedding.registry.EmbeddingModelRegistry;
-import java.util.ArrayList;
-import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.UUID;
 import lombok.RequiredArgsConstructor;
@ -31,7 +26,6 @@ public class RepresentationEmbeddingOrchestrator {
    private final EmbeddingExecutionService executionService;
    private final EmbeddingPersistenceService persistenceService;
    private final DocumentTextRepresentationRepository representationRepository;
-    private final EmbeddingSelectionPolicy selectionPolicy;
    private final EmbeddingModelRegistry modelRegistry;
    private final EmbeddingProperties embeddingProperties;

@ -45,14 +39,6 @@ public class RepresentationEmbeddingOrchestrator {
        return jobService.enqueueForDocument(documentId, modelKey);
    }

-    @Transactional
-    public List<EmbeddingJob> enqueueDocument(UUID documentId, String modelKey, EmbeddingProfile profile) {
-        var model = modelRegistry.getRequired(modelKey);
-        return selectionPolicy.selectRepresentations(documentId, model, profile).stream()
-                .map(representation -> enqueueRepresentation(documentId, representation.getId(), modelKey))
-                .toList();
-    }
-
    @Transactional
    public EmbeddingJob enqueueRepresentation(UUID documentId, UUID representationId, String modelKey) {
        return jobService.enqueueForRepresentation(documentId, representationId, modelKey, EmbeddingJobType.DOCUMENT_EMBED);
@ -66,138 +52,25 @@ public class RepresentationEmbeddingOrchestrator {
        }

        List<EmbeddingJob> jobs = jobService.claimNextReadyJobs(embeddingProperties.getJobs().getBatchSize());
-        if (jobs.isEmpty()) {
-            return 0;
-        }
-
-        if (embeddingProperties.getJobs().isProcessInBatches()) {
-            processClaimedJobsInBatches(jobs);
-        } else {
-            jobs.forEach(this::processClaimedJobSafely);
+        for (EmbeddingJob job : jobs) {
+            processClaimedJob(job);
        }
        return jobs.size();
    }

    @Transactional
    public void processClaimedJob(EmbeddingJob job) {
-        EmbeddingModelDescriptor model = modelRegistry.getRequired(job.getModelKey());
-        PreparedEmbedding prepared = prepareEmbedding(job, model);
-        if (prepared == null) {
-            return;
-        }
-
-        try {
-            EmbeddingProviderResult result = executionService.embedTexts(
-                    job.getModelKey(),
-                    EmbeddingUseCase.DOCUMENT,
-                    List.of(prepared.text())
-            );
-            persistenceService.saveCompleted(prepared.embeddingId(), result);
-            jobService.markCompleted(job.getId(), result.providerRequestId());
-        } catch (RuntimeException ex) {
-            persistenceService.markFailed(prepared.embeddingId(), ex.getMessage());
-            jobService.markFailed(job.getId(), ex.getMessage(), true);
-            throw ex;
-        }
-    }
-
-    private void processClaimedJobsInBatches(List<EmbeddingJob> jobs) {
-        LinkedHashMap<String, List<EmbeddingJob>> jobsByModelKey = new LinkedHashMap<>();
-        for (EmbeddingJob job : jobs) {
-            jobsByModelKey.computeIfAbsent(job.getModelKey(), ignored -> new ArrayList<>()).add(job);
-        }
-
-        int executionBatchSize = Math.max(1, embeddingProperties.getJobs().getExecutionBatchSize());
-        for (var entry : jobsByModelKey.entrySet()) {
-            EmbeddingModelDescriptor model = modelRegistry.getRequired(entry.getKey());
-            if (!model.supportsBatch()) {
-                entry.getValue().forEach(this::processClaimedJobSafely);
-                continue;
-            }
-
-            List<EmbeddingJob> sameModelJobs = entry.getValue();
-            for (int start = 0; start < sameModelJobs.size(); start += executionBatchSize) {
-                List<EmbeddingJob> partition = sameModelJobs.subList(start, Math.min(start + executionBatchSize, sameModelJobs.size()));
-                if (partition.size() == 1) {
-                    processClaimedJobSafely(partition.getFirst());
-                } else {
-                    processClaimedBatchSafely(partition, model);
-                }
-            }
-        }
-    }
-
-    private void processClaimedBatchSafely(List<EmbeddingJob> jobs, EmbeddingModelDescriptor model) {
-        try {
-            processClaimedBatch(jobs, model);
-        } catch (RuntimeException ex) {
-            log.warn("Failed to process embedding batch for model {} ({} jobs): {}",
-                    model.modelKey(), jobs.size(), ex.getMessage(), ex);
-        }
-    }
-
-    private void processClaimedJobSafely(EmbeddingJob job) {
-        try {
-            processClaimedJob(job);
-        } catch (RuntimeException ex) {
-            log.warn("Failed to process embedding job {} for representation {}: {}",
-                    job.getId(), job.getRepresentationId(), ex.getMessage(), ex);
-        }
-    }
-
-    private void processClaimedBatch(List<EmbeddingJob> jobs, EmbeddingModelDescriptor model) {
-        List<PreparedEmbedding> preparedItems = new ArrayList<>(jobs.size());
-        for (EmbeddingJob job : jobs) {
-            PreparedEmbedding prepared = prepareEmbedding(job, model);
-            if (prepared != null) {
-                preparedItems.add(prepared);
-            }
-        }
-
-        if (preparedItems.isEmpty()) {
-            return;
-        }
-
-        try {
-            EmbeddingProviderResult result = executionService.embedTexts(
-                    model.modelKey(),
-                    EmbeddingUseCase.DOCUMENT,
-                    preparedItems.stream().map(PreparedEmbedding::text).toList()
-            );
-
-            if (result.vectors() == null || result.vectors().size() != preparedItems.size()) {
-                throw new IllegalStateException(
-                        "Embedding provider returned %d vectors for %d batch items"
-                                .formatted(result.vectors() == null ? 0 : result.vectors().size(), preparedItems.size())
-                );
-            }
-
-            for (int i = 0; i < preparedItems.size(); i++) {
-                PreparedEmbedding prepared = preparedItems.get(i);
-                persistenceService.saveCompleted(prepared.embeddingId(), result.vectors().get(i), null);
-                jobService.markCompleted(prepared.job().getId(), result.providerRequestId());
-            }
-        } catch (RuntimeException ex) {
-            for (PreparedEmbedding prepared : preparedItems) {
-                persistenceService.markFailed(prepared.embeddingId(), ex.getMessage());
-                jobService.markFailed(prepared.job().getId(), ex.getMessage(), true);
-            }
-            throw ex;
-        }
-    }
-
-    private PreparedEmbedding prepareEmbedding(EmbeddingJob job, EmbeddingModelDescriptor model) {
        DocumentTextRepresentation representation = representationRepository.findById(job.getRepresentationId())
                .orElseThrow(() -> new IllegalArgumentException("Unknown representation id: " + job.getRepresentationId()));

        String text = representation.getTextBody();
        if (text == null || text.isBlank()) {
            jobService.markFailed(job.getId(), "No text representation available", false);
-            return null;
+            return;
        }

-        int maxChars = model.maxInputChars() != null
-                ? model.maxInputChars()
+        int maxChars = modelRegistry.getRequired(job.getModelKey()).maxInputChars() != null
+                ? modelRegistry.getRequired(job.getModelKey()).maxInputChars()
                : embeddingProperties.getIndexing().getFallbackMaxInputChars();
        if (text.length() > maxChars) {
            text = text.substring(0, maxChars);
@ -205,9 +78,19 @@ public class RepresentationEmbeddingOrchestrator {

        DocumentEmbedding embedding = persistenceService.ensurePending(representation.getId(), job.getModelKey());
        persistenceService.markProcessing(embedding.getId());
-        return new PreparedEmbedding(job, embedding.getId(), text);
-    }

-    private record PreparedEmbedding(EmbeddingJob job, UUID embeddingId, String text) {
+        try {
+            EmbeddingProviderResult result = executionService.embedTexts(
+                    job.getModelKey(),
+                    EmbeddingUseCase.DOCUMENT,
+                    List.of(text)
+            );
+            persistenceService.saveCompleted(embedding.getId(), result);
+            jobService.markCompleted(job.getId(), result.providerRequestId());
+        } catch (RuntimeException ex) {
+            persistenceService.markFailed(embedding.getId(), ex.getMessage());
+            jobService.markFailed(job.getId(), ex.getMessage(), true);
+            throw ex;
+        }
    }
 }
--- a/src/main/java/at/procon/dip/ingestion/adapter/FileSystemDocumentIngestionAdapter.java
+++ b/src/main/java/at/procon/dip/ingestion/adapter/FileSystemDocumentIngestionAdapter.java
@ -6,15 +6,11 @@ import at.procon.dip.ingestion.spi.DocumentIngestionAdapter;
 import at.procon.dip.ingestion.spi.IngestionResult;
 import at.procon.dip.ingestion.spi.SourceDescriptor;
 import java.util.List;
-
-import at.procon.dip.runtime.condition.ConditionalOnRuntimeMode;
-import at.procon.dip.runtime.config.RuntimeMode;
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Component;

@Component
@RequiredArgsConstructor
-@ConditionalOnRuntimeMode(RuntimeMode.NEW)
 public class FileSystemDocumentIngestionAdapter implements DocumentIngestionAdapter {

    private final GenericDocumentImportService importService;
--- a/src/main/java/at/procon/dip/ingestion/adapter/InlineContentDocumentIngestionAdapter.java
+++ b/src/main/java/at/procon/dip/ingestion/adapter/InlineContentDocumentIngestionAdapter.java
@ -7,15 +7,11 @@ import at.procon.dip.ingestion.spi.DocumentIngestionAdapter;
 import at.procon.dip.ingestion.spi.IngestionResult;
 import at.procon.dip.ingestion.spi.SourceDescriptor;
 import java.util.List;
-
-import at.procon.dip.runtime.condition.ConditionalOnRuntimeMode;
-import at.procon.dip.runtime.config.RuntimeMode;
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Component;

@Component
@RequiredArgsConstructor
-@ConditionalOnRuntimeMode(RuntimeMode.NEW)
 public class InlineContentDocumentIngestionAdapter implements DocumentIngestionAdapter {

    private final GenericDocumentImportService importService;
--- a/src/main/java/at/procon/dip/ingestion/adapter/MailDocumentIngestionAdapter.java
+++ b/src/main/java/at/procon/dip/ingestion/adapter/MailDocumentIngestionAdapter.java
@ -17,9 +17,7 @@ import at.procon.dip.ingestion.spi.IngestionResult;
 import at.procon.dip.ingestion.spi.OriginalContentStoragePolicy;
 import at.procon.dip.ingestion.spi.SourceDescriptor;
 import at.procon.dip.ingestion.util.DocumentImportSupport;
-import at.procon.dip.ingestion.config.DipIngestionProperties;
-import at.procon.dip.runtime.condition.ConditionalOnRuntimeMode;
-import at.procon.dip.runtime.config.RuntimeMode;
+import at.procon.ted.config.TedProcessorProperties;
 import at.procon.ted.service.attachment.AttachmentExtractor;
 import at.procon.ted.service.attachment.ZipExtractionService;
 import java.time.OffsetDateTime;
@ -32,12 +30,11 @@ import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Component;

@Component
-@ConditionalOnRuntimeMode(RuntimeMode.NEW)
@RequiredArgsConstructor
@Slf4j
 public class MailDocumentIngestionAdapter implements DocumentIngestionAdapter {

-    private final DipIngestionProperties properties;
+    private final TedProcessorProperties properties;
    private final GenericDocumentImportService importService;
    private final MailMessageExtractionService mailExtractionService;
    private final DocumentRelationService relationService;
@ -46,8 +43,8 @@ public class MailDocumentIngestionAdapter implements DocumentIngestionAdapter {
    @Override
    public boolean supports(SourceDescriptor sourceDescriptor) {
        return sourceDescriptor.sourceType() == SourceType.MAIL
-                && properties.isEnabled()
-                && properties.isMailAdapterEnabled();
+                && properties.getGenericIngestion().isEnabled()
+                && properties.getGenericIngestion().isMailAdapterEnabled();
    }

    @Override
@ -65,7 +62,7 @@ public class MailDocumentIngestionAdapter implements DocumentIngestionAdapter {
        if (!parsed.recipients().isEmpty()) rootAttributes.put("to", String.join(", ", parsed.recipients()));
        rootAttributes.putIfAbsent("title", parsed.subject() != null ? parsed.subject() : sourceDescriptor.fileName());
        rootAttributes.put("attachmentCount", Integer.toString(parsed.attachments().size()));
-        rootAttributes.put("importBatchId", properties.getMailImportBatchId());
+        rootAttributes.put("importBatchId", properties.getGenericIngestion().getMailImportBatchId());

        ImportedDocumentResult rootResult = importService.importDocument(new SourceDescriptor(
                accessContext,
@ -96,13 +93,13 @@ public class MailDocumentIngestionAdapter implements DocumentIngestionAdapter {
    private void importAttachment(java.util.UUID parentDocumentId, DocumentAccessContext accessContext, SourceDescriptor parentSource,
                                  MailAttachment attachment, List<at.procon.dip.domain.document.CanonicalDocumentMetadata> documents,
                                  List<String> warnings, int sortOrder, int depth) {
-        boolean expandableWrapper = properties.isExpandMailZipAttachments()
+        boolean expandableWrapper = properties.getGenericIngestion().isExpandMailZipAttachments()
                && zipExtractionService.canHandle(attachment.fileName(), attachment.contentType());

        Map<String, String> attachmentAttributes = new LinkedHashMap<>();
        attachmentAttributes.put("title", attachment.fileName());
        attachmentAttributes.put("mailSourceIdentifier", parentSource.sourceIdentifier());
-        attachmentAttributes.put("importBatchId", properties.getMailImportBatchId());
+        attachmentAttributes.put("importBatchId", properties.getGenericIngestion().getMailImportBatchId());
        if (expandableWrapper) {
            attachmentAttributes.put("wrapperDocument", Boolean.TRUE.toString());
        }
@ -147,11 +144,11 @@ public class MailDocumentIngestionAdapter implements DocumentIngestionAdapter {
    }

    private DocumentAccessContext defaultMailAccessContext() {
-        String tenantKey = properties.getMailDefaultOwnerTenantKey();
+        String tenantKey = properties.getGenericIngestion().getMailDefaultOwnerTenantKey();
        if (tenantKey == null || tenantKey.isBlank()) {
-            tenantKey = properties.getDefaultOwnerTenantKey();
+            tenantKey = properties.getGenericIngestion().getDefaultOwnerTenantKey();
        }
-        DocumentVisibility visibility = properties.getMailDefaultVisibility();
+        DocumentVisibility visibility = properties.getGenericIngestion().getMailDefaultVisibility();
        TenantRef tenant = (tenantKey == null || tenantKey.isBlank()) ? null : new TenantRef(null, tenantKey, tenantKey);
        if (tenant == null && visibility == DocumentVisibility.TENANT) {
            visibility = DocumentVisibility.RESTRICTED;
--- a/src/main/java/at/procon/dip/ingestion/adapter/TedPackageDocumentIngestionAdapter.java
+++ b/src/main/java/at/procon/dip/ingestion/adapter/TedPackageDocumentIngestionAdapter.java
@ -1,8 +1,6 @@
 package at.procon.dip.ingestion.adapter;

 import at.procon.dip.domain.access.DocumentAccessContext;
-import at.procon.dip.domain.document.CanonicalDocumentMetadata;
-import at.procon.dip.domain.document.SourceType;
 import at.procon.dip.ingestion.dto.ImportedDocumentResult;
 import at.procon.dip.ingestion.service.GenericDocumentImportService;
 import at.procon.dip.ingestion.service.TedPackageChildImportProcessor;
@ -11,9 +9,7 @@ import at.procon.dip.ingestion.spi.DocumentIngestionAdapter;
 import at.procon.dip.ingestion.spi.IngestionResult;
 import at.procon.dip.ingestion.spi.OriginalContentStoragePolicy;
 import at.procon.dip.ingestion.spi.SourceDescriptor;
-import at.procon.dip.ingestion.config.DipIngestionProperties;
-import at.procon.dip.runtime.condition.ConditionalOnRuntimeMode;
-import at.procon.dip.runtime.config.RuntimeMode;
+import at.procon.ted.config.TedProcessorProperties;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.time.OffsetDateTime;
@ -24,28 +20,26 @@ import java.util.Map;
 import java.util.concurrent.atomic.AtomicInteger;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
-import org.springframework.beans.factory.annotation.Qualifier;
 import org.springframework.stereotype.Component;
 import org.springframework.transaction.annotation.Propagation;
 import org.springframework.transaction.annotation.Transactional;
 import org.springframework.util.StringUtils;

@Component
-@ConditionalOnRuntimeMode(RuntimeMode.NEW)
@RequiredArgsConstructor
@Slf4j
 public class TedPackageDocumentIngestionAdapter implements DocumentIngestionAdapter {

-    private final DipIngestionProperties properties;
+    private final TedProcessorProperties properties;
    private final GenericDocumentImportService importService;
    private final TedPackageExpansionService expansionService;
    private final TedPackageChildImportProcessor childImportProcessor;

    @Override
    public boolean supports(SourceDescriptor sourceDescriptor) {
-        return sourceDescriptor.sourceType() == SourceType.TED_PACKAGE
-                && properties.isEnabled()
-                && properties.isTedPackageAdapterEnabled();
+        return sourceDescriptor.sourceType() == at.procon.dip.domain.document.SourceType.TED_PACKAGE
+                && properties.getGenericIngestion().isEnabled()
+                && properties.getGenericIngestion().isTedPackageAdapterEnabled();
    }

    @Override
@ -57,11 +51,11 @@ public class TedPackageDocumentIngestionAdapter implements DocumentIngestionAdap
        rootAttributes.putIfAbsent("packageId", sourceDescriptor.sourceIdentifier());
        rootAttributes.putIfAbsent("title", sourceDescriptor.fileName() != null ? sourceDescriptor.fileName() : sourceDescriptor.sourceIdentifier());
        rootAttributes.put("wrapperDocument", Boolean.TRUE.toString());
-        rootAttributes.put("importBatchId", properties.getTedPackageImportBatchId());
+        rootAttributes.put("importBatchId", properties.getGenericIngestion().getTedPackageImportBatchId());

        ImportedDocumentResult packageDocument = importService.importDocument(new SourceDescriptor(
                sourceDescriptor.accessContext() == null ? DocumentAccessContext.publicDocument() : sourceDescriptor.accessContext(),
-                SourceType.TED_PACKAGE,
+                at.procon.dip.domain.document.SourceType.TED_PACKAGE,
                sourceDescriptor.sourceIdentifier(),
                packageRootSource.sourceUri(),
                sourceDescriptor.fileName(),
@ -74,7 +68,7 @@ public class TedPackageDocumentIngestionAdapter implements DocumentIngestionAdap
        ));

        List<String> warnings = new ArrayList<>(packageDocument.warnings());
-        List<CanonicalDocumentMetadata> documents = new ArrayList<>();
+        List<at.procon.dip.domain.document.CanonicalDocumentMetadata> documents = new ArrayList<>();
        documents.add(packageDocument.document().toCanonicalMetadata());

        AtomicInteger sortOrder = new AtomicInteger();
--- a/src/main/java/at/procon/dip/ingestion/camel/GenericFileSystemIngestionRoute.java
+++ b/src/main/java/at/procon/dip/ingestion/camel/GenericFileSystemIngestionRoute.java
@ -7,9 +7,7 @@ import at.procon.dip.domain.tenant.TenantRef;
 import at.procon.dip.ingestion.service.DocumentIngestionGateway;
 import at.procon.dip.ingestion.spi.OriginalContentStoragePolicy;
 import at.procon.dip.ingestion.spi.SourceDescriptor;
-import at.procon.dip.ingestion.config.DipIngestionProperties;
-import at.procon.dip.runtime.condition.ConditionalOnRuntimeMode;
-import at.procon.dip.runtime.config.RuntimeMode;
+import at.procon.ted.config.TedProcessorProperties;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.time.OffsetDateTime;
@ -23,22 +21,21 @@ import org.springframework.stereotype.Component;
 import org.springframework.util.StringUtils;

@Component
-@ConditionalOnRuntimeMode(RuntimeMode.NEW)
@RequiredArgsConstructor
@Slf4j
 public class GenericFileSystemIngestionRoute extends RouteBuilder {

-    private final DipIngestionProperties properties;
+    private final TedProcessorProperties properties;
    private final DocumentIngestionGateway ingestionGateway;

    @Override
    public void configure() {
-        if (!properties.isEnabled() || !properties.isFileSystemEnabled()) {
+        if (!properties.getGenericIngestion().isEnabled() || !properties.getGenericIngestion().isFileSystemEnabled()) {
            log.info("Phase 4 generic filesystem ingestion route disabled");
            return;
        }

-        var config = properties;
+        var config = properties.getGenericIngestion();
        log.info("Configuring Phase 4 generic filesystem ingestion from {}", config.getInputDirectory());

        fromF("file:%s?recursive=true&include=%s&delay=%d&maxMessagesPerPoll=%d&move=%s&moveFailed=%s",
@ -61,7 +58,7 @@ public class GenericFileSystemIngestionRoute extends RouteBuilder {
        }
        byte[] payload = Files.readAllBytes(path);
        Map<String, String> attributes = new LinkedHashMap<>();
-        String languageCode = properties.getDefaultLanguageCode();
+        String languageCode = properties.getGenericIngestion().getDefaultLanguageCode();
        if (StringUtils.hasText(languageCode)) {
            attributes.put("languageCode", languageCode);
        }
@ -83,8 +80,8 @@ public class GenericFileSystemIngestionRoute extends RouteBuilder {
    }

    private DocumentAccessContext buildDefaultAccessContext() {
-        String ownerTenantKey = properties.getDefaultOwnerTenantKey();
-        DocumentVisibility visibility = properties.getDefaultVisibility();
+        String ownerTenantKey = properties.getGenericIngestion().getDefaultOwnerTenantKey();
+        DocumentVisibility visibility = properties.getGenericIngestion().getDefaultVisibility();
        if (!StringUtils.hasText(ownerTenantKey)) {
            return new DocumentAccessContext(null, visibility);
        }
--- a/src/main/java/at/procon/dip/ingestion/camel/TedPackageDownloadRoute.java
+++ b/src/main/java/at/procon/dip/ingestion/camel/TedPackageDownloadRoute.java
@ -1,328 +0,0 @@
-package at.procon.dip.ingestion.camel;
-
-import at.procon.dip.domain.document.SourceType;
-import at.procon.dip.ingestion.config.TedPackageDownloadProperties;
-import at.procon.dip.ingestion.service.DocumentIngestionGateway;
-import at.procon.dip.ingestion.spi.IngestionResult;
-import at.procon.dip.ingestion.spi.OriginalContentStoragePolicy;
-import at.procon.dip.ingestion.spi.SourceDescriptor;
-import at.procon.dip.runtime.condition.ConditionalOnRuntimeMode;
-import at.procon.dip.runtime.config.RuntimeMode;
-import at.procon.ted.model.entity.TedDailyPackage;
-import at.procon.ted.repository.TedDailyPackageRepository;
-import at.procon.dip.domain.ted.service.TedPackageSequenceService;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.nio.file.Paths;
-import java.security.MessageDigest;
-import java.time.OffsetDateTime;
-import java.util.List;
-import java.util.Map;
-import java.util.Optional;
-import lombok.RequiredArgsConstructor;
-import lombok.extern.slf4j.Slf4j;
-import org.apache.camel.Exchange;
-import org.apache.camel.LoggingLevel;
-import org.apache.camel.builder.RouteBuilder;
-import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
-import org.springframework.stereotype.Component;
-
-/**
- * NEW-runtime TED daily package download route.
- * <p>
- * Reuses the proven package sequencing rules through {@link TedPackageSequenceService},
- * but hands off processing only to the NEW ingestion gateway. No legacy XML batch persistence,
- * no legacy vectorization route, no old semantic path.
- */
-@Component
-@ConditionalOnRuntimeMode(RuntimeMode.NEW)
-@ConditionalOnProperty(name = "dip.ingestion.ted-download.enabled", havingValue = "true")
-@RequiredArgsConstructor
-@Slf4j
-public class TedPackageDownloadRoute extends RouteBuilder {
-
-    private static final String ROUTE_ID_SCHEDULER = "ted-package-new-scheduler";
-    private static final String ROUTE_ID_DOWNLOADER = "ted-package-new-downloader";
-    private static final String ROUTE_ID_ERROR = "ted-package-new-error-handler";
-
-    private final TedPackageDownloadProperties properties;
-    private final TedDailyPackageRepository packageRepository;
-    private final TedPackageSequenceService sequenceService;
-    private final DocumentIngestionGateway documentIngestionGateway;
-
-    @Override
-    public void configure() {
-        errorHandler(deadLetterChannel("direct:ted-package-new-error")
-                .maximumRedeliveries(3)
-                .redeliveryDelay(10_000)
-                .retryAttemptedLogLevel(LoggingLevel.WARN)
-                .logStackTrace(true));
-
-        from("direct:ted-package-new-error")
-                .routeId(ROUTE_ID_ERROR)
-                .process(this::handleError);
-
-        from("timer:ted-package-new-scheduler?period={{dip.ingestion.ted-download.poll-interval:3600000}}&delay=0")
-                .routeId(ROUTE_ID_SCHEDULER)
-                .process(this::checkRunningPackages)
-                .choice()
-                    .when(header("tooManyRunning").isEqualTo(true))
-                        .log(LoggingLevel.INFO, "Skipping NEW TED package download - already ${header.runningCount} packages in progress")
-                    .otherwise()
-                        .process(this::determineNextPackage)
-                        .choice()
-                            .when(header("packageId").isNotNull())
-                                .to("direct:download-ted-package-new")
-                            .otherwise()
-                                .log(LoggingLevel.INFO, "No NEW TED package to download right now")
-                        .end()
-                .end();
-
-        from("direct:download-ted-package-new")
-                .routeId(ROUTE_ID_DOWNLOADER)
-                .log(LoggingLevel.INFO, "NEW TED package download started: ${header.packageId}")
-                .setHeader("downloadStartTime", constant(System.currentTimeMillis()))
-                .process(this::createPackageRecord)
-                .delay(simple("{{dip.ingestion.ted-download.delay-between-downloads:5000}}"))
-                .setHeader(Exchange.HTTP_METHOD, constant("GET"))
-                .setHeader("CamelHttpConnectionClose", constant(true))
-                .toD("${header.downloadUrl}?bridgeEndpoint=true&throwExceptionOnFailure=false&socketTimeout={{dip.ingestion.ted-download.download-timeout:300000}}")
-                .choice()
-                    .when(header(Exchange.HTTP_RESPONSE_CODE).isEqualTo(200))
-                        .process(this::calculateHash)
-                        .process(this::checkDuplicateByHash)
-                        .choice()
-                            .when(header("isDuplicate").isEqualTo(true))
-                                .process(this::markDuplicate)
-                            .otherwise()
-                                .process(this::saveDownloadedPackage)
-                                .process(this::ingestThroughGateway)
-                                .process(this::markCompleted)
-                        .endChoice()
-                    .when(header(Exchange.HTTP_RESPONSE_CODE).isEqualTo(404))
-                        .process(this::markNotFound)
-                    .otherwise()
-                        .process(this::markFailed)
-                .end();
-    }
-
-    private void checkRunningPackages(Exchange exchange) {
-        long downloadingCount = packageRepository.findByDownloadStatus(TedDailyPackage.DownloadStatus.DOWNLOADING).size();
-        long processingCount = packageRepository.findByDownloadStatus(TedDailyPackage.DownloadStatus.PROCESSING).size();
-        long runningCount = downloadingCount + processingCount;
-
-        exchange.getIn().setHeader("runningCount", runningCount);
-        exchange.getIn().setHeader("tooManyRunning", runningCount >= properties.getMaxRunningPackages());
-
-        if (runningCount > 0) {
-            log.info("Currently {} TED packages in progress in NEW runtime ({} downloading, {} processing)",
-                    runningCount, downloadingCount, processingCount);
-        }
-    }
-
-    private void determineNextPackage(Exchange exchange) {
-        List<TedDailyPackage> pendingPackages = packageRepository.findByDownloadStatus(TedDailyPackage.DownloadStatus.PENDING);
-
-        if (!pendingPackages.isEmpty()) {
-            TedDailyPackage pkg = pendingPackages.get(0);
-            log.info("Retrying PENDING TED package in NEW runtime: {}", pkg.getPackageIdentifier());
-            setPackageHeaders(exchange, pkg.getYear(), pkg.getSerialNumber());
-            return;
-        }
-
-        TedPackageSequenceService.PackageInfo packageInfo = sequenceService.getNextPackageToDownload();
-        if (packageInfo == null) {
-            exchange.getIn().setHeader("packageId", null);
-            return;
-        }
-
-        setPackageHeaders(exchange, packageInfo.year(), packageInfo.serialNumber());
-    }
-
-    private void setPackageHeaders(Exchange exchange, int year, int serialNumber) {
-        String packageId = "%04d%05d".formatted(year, serialNumber);
-        String downloadUrl = properties.getBaseUrl() + packageId;
-
-        exchange.getIn().setHeader("packageId", packageId);
-        exchange.getIn().setHeader("year", year);
-        exchange.getIn().setHeader("serialNumber", serialNumber);
-        exchange.getIn().setHeader("downloadUrl", downloadUrl);
-    }
-
-    private void createPackageRecord(Exchange exchange) {
-        String packageId = exchange.getIn().getHeader("packageId", String.class);
-        Integer year = exchange.getIn().getHeader("year", Integer.class);
-        Integer serialNumber = exchange.getIn().getHeader("serialNumber", Integer.class);
-        String downloadUrl = exchange.getIn().getHeader("downloadUrl", String.class);
-
-        if (packageRepository.existsByPackageIdentifier(packageId)) {
-            return;
-        }
-
-        TedDailyPackage pkg = TedDailyPackage.builder()
-                .packageIdentifier(packageId)
-                .year(year)
-                .serialNumber(serialNumber)
-                .downloadUrl(downloadUrl)
-                .downloadStatus(TedDailyPackage.DownloadStatus.DOWNLOADING)
-                .build();
-
-        packageRepository.save(pkg);
-    }
-
-    private void calculateHash(Exchange exchange) throws Exception {
-        byte[] body = exchange.getIn().getBody(byte[].class);
-        MessageDigest digest = MessageDigest.getInstance("SHA-256");
-        byte[] hashBytes = digest.digest(body);
-
-        StringBuilder sb = new StringBuilder();
-        for (byte b : hashBytes) {
-            sb.append(String.format("%02x", b));
-        }
-
-        exchange.getIn().setHeader("fileHash", sb.toString());
-    }
-
-    private void checkDuplicateByHash(Exchange exchange) {
-        String hash = exchange.getIn().getHeader("fileHash", String.class);
-
-        Optional<TedDailyPackage> duplicate = packageRepository.findAll().stream()
-                .filter(p -> hash.equals(p.getFileHash()))
-                .findFirst();
-
-        exchange.getIn().setHeader("isDuplicate", duplicate.isPresent());
-        duplicate.ifPresent(pkg -> exchange.getIn().setHeader("duplicateOf", pkg.getPackageIdentifier()));
-    }
-
-    private void saveDownloadedPackage(Exchange exchange) throws Exception {
-        String packageId = exchange.getIn().getHeader("packageId", String.class);
-        String hash = exchange.getIn().getHeader("fileHash", String.class);
-        byte[] body = exchange.getIn().getBody(byte[].class);
-
-        Path downloadDir = Paths.get(properties.getDownloadDirectory());
-        Files.createDirectories(downloadDir);
-        Path downloadPath = downloadDir.resolve(packageId + ".tar.gz");
-        Files.write(downloadPath, body);
-
-        long downloadDuration = System.currentTimeMillis() -
-                exchange.getIn().getHeader("downloadStartTime", Long.class);
-
-        packageRepository.findByPackageIdentifier(packageId).ifPresent(pkg -> {
-            pkg.setFileHash(hash);
-            pkg.setDownloadStatus(TedDailyPackage.DownloadStatus.DOWNLOADED);
-            pkg.setDownloadedAt(OffsetDateTime.now());
-            pkg.setDownloadDurationMs(downloadDuration);
-            packageRepository.save(pkg);
-        });
-
-        exchange.getIn().setHeader("downloadPath", downloadPath.toString());
-    }
-
-    private void ingestThroughGateway(Exchange exchange) {
-        String packageId = exchange.getIn().getHeader("packageId", String.class);
-        String downloadPath = exchange.getIn().getHeader("downloadPath", String.class);
-
-        packageRepository.findByPackageIdentifier(packageId).ifPresent(pkg -> {
-            pkg.setDownloadStatus(TedDailyPackage.DownloadStatus.PROCESSING);
-            packageRepository.save(pkg);
-        });
-
-        IngestionResult ingestionResult = documentIngestionGateway.ingest(new SourceDescriptor(
-                null,
-                SourceType.TED_PACKAGE,
-                packageId,
-                downloadPath,
-                packageId + ".tar.gz",
-                "application/gzip",
-                null,
-                null,
-                OffsetDateTime.now(),
-                OriginalContentStoragePolicy.DEFAULT,
-                Map.of(
-                        "packageId", packageId,
-                        "title", packageId + ".tar.gz"
-                )
-        ));
-
-        int importedChildCount = Math.max(0, ingestionResult.documents().size() - 1);
-        exchange.getIn().setHeader("gatewayImportedChildCount", importedChildCount);
-        exchange.getIn().setHeader("gatewayImportWarnings", ingestionResult.warnings().size());
-
-        packageRepository.findByPackageIdentifier(packageId).ifPresent(pkg -> {
-            pkg.setXmlFileCount(importedChildCount);
-            pkg.setProcessedCount(importedChildCount);
-            pkg.setFailedCount(0);
-            packageRepository.save(pkg);
-        });
-    }
-
-    private void markCompleted(Exchange exchange) throws Exception {
-        String packageId = exchange.getIn().getHeader("packageId", String.class);
-        String downloadPath = exchange.getIn().getHeader("downloadPath", String.class);
-
-        packageRepository.findByPackageIdentifier(packageId).ifPresent(pkg -> {
-            pkg.setDownloadStatus(TedDailyPackage.DownloadStatus.COMPLETED);
-            pkg.setProcessedAt(OffsetDateTime.now());
-            if (pkg.getDownloadedAt() != null) {
-                long processingDuration = Math.max(0L,
-                        java.time.Duration.between(pkg.getDownloadedAt(), OffsetDateTime.now()).toMillis());
-                pkg.setProcessingDurationMs(processingDuration);
-            }
-            packageRepository.save(pkg);
-        });
-
-        if (properties.isDeleteAfterIngestion() && downloadPath != null) {
-            Files.deleteIfExists(Path.of(downloadPath));
-        }
-
-        packageRepository.findByPackageIdentifier(packageId).ifPresent(pkg -> {
-            long totalDuration = (pkg.getDownloadDurationMs() != null ? pkg.getDownloadDurationMs() : 0L)
-                    + (pkg.getProcessingDurationMs() != null ? pkg.getProcessingDurationMs() : 0L);
-            log.info("NEW TED package {} completed: xmlCount={}, processed={}, failed={}, totalDuration={}ms",
-                    packageId, pkg.getXmlFileCount(), pkg.getProcessedCount(), pkg.getFailedCount(), totalDuration);
-        });
-    }
-
-    private void markNotFound(Exchange exchange) {
-        String packageId = exchange.getIn().getHeader("packageId", String.class);
-        packageRepository.findByPackageIdentifier(packageId).ifPresent(pkg -> {
-            pkg.setDownloadStatus(TedDailyPackage.DownloadStatus.NOT_FOUND);
-            pkg.setErrorMessage("Package not found (404)");
-            packageRepository.save(pkg);
-        });
-    }
-
-    private void markFailed(Exchange exchange) {
-        String packageId = exchange.getIn().getHeader("packageId", String.class);
-        Integer httpCode = exchange.getIn().getHeader(Exchange.HTTP_RESPONSE_CODE, Integer.class);
-        packageRepository.findByPackageIdentifier(packageId).ifPresent(pkg -> {
-            pkg.setDownloadStatus(TedDailyPackage.DownloadStatus.FAILED);
-            pkg.setErrorMessage("HTTP " + httpCode);
-            packageRepository.save(pkg);
-        });
-    }
-
-    private void markDuplicate(Exchange exchange) {
-        String packageId = exchange.getIn().getHeader("packageId", String.class);
-        String duplicateOf = exchange.getIn().getHeader("duplicateOf", String.class);
-        packageRepository.findByPackageIdentifier(packageId).ifPresent(pkg -> {
-            pkg.setDownloadStatus(TedDailyPackage.DownloadStatus.COMPLETED);
-            pkg.setErrorMessage("Duplicate of " + duplicateOf);
-            pkg.setProcessedAt(OffsetDateTime.now());
-            packageRepository.save(pkg);
-        });
-    }
-
-    private void handleError(Exchange exchange) {
-        Exception exception = exchange.getProperty(Exchange.EXCEPTION_CAUGHT, Exception.class);
-        String packageId = exchange.getIn().getHeader("packageId", String.class);
-
-        if (packageId != null) {
-            packageRepository.findByPackageIdentifier(packageId).ifPresent(pkg -> {
-                pkg.setDownloadStatus(TedDailyPackage.DownloadStatus.FAILED);
-                pkg.setErrorMessage(exception != null ? exception.getMessage() : "Unknown route error");
-                packageRepository.save(pkg);
-            });
-        }
-    }
-}
--- a/src/main/java/at/procon/dip/ingestion/config/DipIngestionProperties.java
+++ b/src/main/java/at/procon/dip/ingestion/config/DipIngestionProperties.java
@ -1,61 +0,0 @@
-package at.procon.dip.ingestion.config;
-
-import at.procon.dip.domain.access.DocumentVisibility;
-import at.procon.dip.runtime.condition.ConditionalOnRuntimeMode;
-import at.procon.dip.runtime.config.RuntimeMode;
-import jakarta.validation.constraints.NotBlank;
-import jakarta.validation.constraints.Positive;
-import lombok.Data;
-import org.springframework.boot.context.properties.ConfigurationProperties;
-import org.springframework.context.annotation.Configuration;
-
-@Configuration
-@ConfigurationProperties(prefix = "dip.ingestion")
-@Data
-public class DipIngestionProperties {
-
-    private boolean enabled = false;
-    private boolean fileSystemEnabled = false;
-    private boolean restUploadEnabled = true;
-    private String inputDirectory = "/ted.europe/generic-input";
-    private String filePattern = ".*\\.(pdf|txt|html|htm|xml|md|markdown|csv|json|yaml|yml)$";
-    private String processedDirectory = ".dip-processed";
-    private String errorDirectory = ".dip-error";
-
-    @Positive
-    private long pollInterval = 15000;
-
-    @Positive
-    private int maxMessagesPerPoll = 10;
-
-    private String defaultOwnerTenantKey;
-    private DocumentVisibility defaultVisibility = DocumentVisibility.PUBLIC;
-    private String defaultLanguageCode;
-
-    private boolean storeOriginalBinaryInDb = true;
-
-    @Positive
-    private int maxBinaryBytesInDb = 5242880;
-
-    private boolean deduplicateByContentHash = true;
-    private boolean storeOriginalContentForWrapperDocuments = true;
-    private boolean vectorizePrimaryRepresentationOnly = true;
-
-    @NotBlank
-    private String importBatchId = "phase4-generic";
-
-    private boolean tedPackageAdapterEnabled = true;
-    private boolean mailAdapterEnabled = false;
-
-    private String mailDefaultOwnerTenantKey;
-    private DocumentVisibility mailDefaultVisibility = DocumentVisibility.TENANT;
-    private boolean expandMailZipAttachments = true;
-
-    @NotBlank
-    private String tedPackageImportBatchId = "phase41-ted-package";
-
-    private boolean gatewayOnlyForTedPackages = false;
-
-    @NotBlank
-    private String mailImportBatchId = "phase41-mail";
-}
--- a/src/main/java/at/procon/dip/ingestion/config/TedPackageDownloadProperties.java
+++ b/src/main/java/at/procon/dip/ingestion/config/TedPackageDownloadProperties.java
@ -1,52 +0,0 @@
-package at.procon.dip.ingestion.config;
-
-import jakarta.validation.constraints.Min;
-import jakarta.validation.constraints.NotBlank;
-import jakarta.validation.constraints.Positive;
-import lombok.Data;
-import org.springframework.boot.context.properties.ConfigurationProperties;
-import org.springframework.context.annotation.Configuration;
-
-/**
- * NEW-runtime TED package download configuration.
- * <p>
- * This is intentionally separate from the legacy {@code ted.download.*} tree.
- */
-@Configuration
-@ConfigurationProperties(prefix = "dip.ingestion.ted-download")
-@Data
-public class TedPackageDownloadProperties {
-
-    private boolean enabled = false;
-
-    @NotBlank
-    private String baseUrl = "https://ted.europa.eu/packages/daily/";
-
-    @NotBlank
-    private String downloadDirectory = "/ted.europe/downloads-new";
-
-    @Positive
-    private int startYear = 2015;
-
-    @Positive
-    private long pollInterval = 3_600_000L;
-
-    @Positive
-    private long notFoundRetryInterval = 21_600_000L;
-
-    @Min(0)
-    private int previousYearGracePeriodDays = 30;
-
-    private boolean retryCurrentYearNotFoundIndefinitely = true;
-
-    @Positive
-    private long downloadTimeout = 300_000L;
-
-    @Positive
-    private int maxRunningPackages = 2;
-
-    @Positive
-    private long delayBetweenDownloads = 5_000L;
-
-    private boolean deleteAfterIngestion = true;
-}
--- a/src/main/java/at/procon/dip/ingestion/controller/GenericDocumentImportController.java
+++ b/src/main/java/at/procon/dip/ingestion/controller/GenericDocumentImportController.java
@ -11,9 +11,7 @@ import at.procon.dip.ingestion.service.DocumentIngestionGateway;
 import at.procon.dip.ingestion.spi.IngestionResult;
 import at.procon.dip.ingestion.spi.OriginalContentStoragePolicy;
 import at.procon.dip.ingestion.spi.SourceDescriptor;
-import at.procon.dip.ingestion.config.DipIngestionProperties;
-import at.procon.dip.runtime.condition.ConditionalOnRuntimeMode;
-import at.procon.dip.runtime.config.RuntimeMode;
+import at.procon.ted.config.TedProcessorProperties;
 import java.time.OffsetDateTime;
 import java.util.LinkedHashMap;
 import java.util.Map;
@ -30,11 +28,10 @@ import org.springframework.web.multipart.MultipartFile;

@RestController
@RequestMapping("/v1/dip/import")
-@ConditionalOnRuntimeMode(RuntimeMode.NEW)
@RequiredArgsConstructor
 public class GenericDocumentImportController {

-    private final DipIngestionProperties properties;
+    private final TedProcessorProperties properties;
    private final DocumentIngestionGateway ingestionGateway;

    @PostMapping(path = "/upload", consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
@ -102,7 +99,7 @@ public class GenericDocumentImportController {
    }

    private void ensureRestUploadEnabled() {
-        if (!properties.isEnabled() || !properties.isRestUploadEnabled()) {
+        if (!properties.getGenericIngestion().isEnabled() || !properties.getGenericIngestion().isRestUploadEnabled()) {
            throw new IllegalStateException("Generic REST import is disabled");
        }
    }
@ -110,7 +107,7 @@ public class GenericDocumentImportController {
    private DocumentAccessContext buildAccessContext(String ownerTenantKey, DocumentVisibility visibility) {
        DocumentVisibility effectiveVisibility = visibility != null
                ? visibility
-                : properties.getDefaultVisibility();
+                : properties.getGenericIngestion().getDefaultVisibility();
        if (!StringUtils.hasText(ownerTenantKey)) {
            return new DocumentAccessContext(null, effectiveVisibility);
        }
--- a/src/main/java/at/procon/dip/ingestion/service/GenericDocumentImportService.java
+++ b/src/main/java/at/procon/dip/ingestion/service/GenericDocumentImportService.java
@ -10,9 +10,13 @@ import at.procon.dip.domain.document.DocumentStatus;
 import at.procon.dip.domain.document.StorageType;
 import at.procon.dip.domain.document.entity.Document;
 import at.procon.dip.domain.document.entity.DocumentContent;
+import at.procon.dip.domain.document.entity.DocumentEmbeddingModel;
+import at.procon.dip.domain.document.entity.DocumentSource;
+import at.procon.dip.domain.document.repository.DocumentEmbeddingRepository;
 import at.procon.dip.domain.document.repository.DocumentRepository;
 import at.procon.dip.domain.document.repository.DocumentSourceRepository;
 import at.procon.dip.domain.document.service.DocumentContentService;
+import at.procon.dip.domain.document.service.DocumentEmbeddingService;
 import at.procon.dip.domain.document.service.DocumentRepresentationService;
 import at.procon.dip.domain.document.service.DocumentService;
 import at.procon.dip.domain.document.service.DocumentSourceService;
@ -20,30 +24,21 @@ import at.procon.dip.domain.document.service.command.AddDocumentContentCommand;
 import at.procon.dip.domain.document.service.command.AddDocumentSourceCommand;
 import at.procon.dip.domain.document.service.command.AddDocumentTextRepresentationCommand;
 import at.procon.dip.domain.document.service.command.CreateDocumentCommand;
-import at.procon.dip.embedding.config.EmbeddingProperties;
-import at.procon.dip.embedding.policy.EmbeddingPolicy;
-import at.procon.dip.embedding.policy.EmbeddingProfile;
-import at.procon.dip.embedding.registry.EmbeddingModelRegistry;
-import at.procon.dip.embedding.service.EmbeddingModelCatalogService;
-import at.procon.dip.embedding.service.EmbeddingPolicyResolver;
-import at.procon.dip.embedding.service.EmbeddingProfileResolver;
-import at.procon.dip.embedding.service.RepresentationEmbeddingOrchestrator;
+import at.procon.dip.domain.document.service.command.RegisterEmbeddingModelCommand;
 import at.procon.dip.extraction.service.DocumentExtractionService;
 import at.procon.dip.extraction.spi.ExtractionRequest;
 import at.procon.dip.extraction.spi.ExtractionResult;
-import at.procon.dip.ingestion.config.DipIngestionProperties;
 import at.procon.dip.ingestion.dto.ImportedDocumentResult;
 import at.procon.dip.ingestion.spi.OriginalContentStoragePolicy;
 import at.procon.dip.ingestion.spi.SourceDescriptor;
 import at.procon.dip.ingestion.util.DocumentImportSupport;
 import at.procon.dip.normalization.service.TextRepresentationBuildService;
+import at.procon.dip.processing.service.StructuredDocumentProcessingService;
 import at.procon.dip.normalization.spi.RepresentationBuildRequest;
 import at.procon.dip.normalization.spi.TextRepresentationDraft;
-import at.procon.dip.processing.service.StructuredDocumentProcessingService;
 import at.procon.dip.processing.spi.DocumentProcessingPolicy;
 import at.procon.dip.processing.spi.StructuredProcessingRequest;
-import at.procon.dip.runtime.condition.ConditionalOnRuntimeMode;
-import at.procon.dip.runtime.config.RuntimeMode;
+import at.procon.ted.config.TedProcessorProperties;
 import at.procon.ted.util.HashUtils;
 import java.nio.charset.StandardCharsets;
 import java.time.OffsetDateTime;
@ -52,35 +47,34 @@ import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
+import java.util.UUID;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 import org.springframework.util.StringUtils;

+/**
+ * Phase 4 generic import pipeline that persists arbitrary document types into the DOC model.
+ */
@Service
-@ConditionalOnRuntimeMode(RuntimeMode.NEW)
@RequiredArgsConstructor
@Slf4j
 public class GenericDocumentImportService {

-    private final DipIngestionProperties properties;
+    private final TedProcessorProperties properties;
    private final DocumentRepository documentRepository;
    private final DocumentSourceRepository documentSourceRepository;
+    private final DocumentEmbeddingRepository documentEmbeddingRepository;
    private final DocumentService documentService;
    private final DocumentSourceService documentSourceService;
    private final DocumentContentService documentContentService;
    private final DocumentRepresentationService documentRepresentationService;
+    private final DocumentEmbeddingService documentEmbeddingService;
    private final DocumentClassificationService classificationService;
    private final DocumentExtractionService extractionService;
    private final TextRepresentationBuildService representationBuildService;
    private final StructuredDocumentProcessingService structuredProcessingService;
-    private final EmbeddingProperties embeddingProperties;
-    private final EmbeddingModelRegistry embeddingModelRegistry;
-    private final EmbeddingModelCatalogService embeddingModelCatalogService;
-    private final RepresentationEmbeddingOrchestrator representationEmbeddingOrchestrator;
-    private final EmbeddingPolicyResolver embeddingPolicyResolver;
-    private final EmbeddingProfileResolver embeddingProfileResolver;

    @Transactional
    public ImportedDocumentResult importDocument(SourceDescriptor sourceDescriptor) {
@ -92,7 +86,7 @@ public class GenericDocumentImportService {
                ? defaultAccessContext()
                : sourceDescriptor.accessContext();

-        if (properties.isDeduplicateByContentHash()) {
+        if (properties.getGenericIngestion().isDeduplicateByContentHash()) {
            Optional<Document> existing = resolveDeduplicatedDocument(dedupHash, accessContext);
            if (existing.isPresent()) {
                Document document = existing.get();
@ -164,7 +158,7 @@ public class GenericDocumentImportService {

            if (processingPolicy.runRepresentationBuilders()) {
                var drafts = representationBuildService.build(new RepresentationBuildRequest(sourceDescriptor, detection, extractionResult));
-                persistRepresentationsAndEmbeddings(document, originalContent, persistedDerivedContent, drafts, sourceDescriptor);
+                persistRepresentationsAndEmbeddings(document, originalContent, persistedDerivedContent, drafts);
            }

            if (processingPolicy.applyStructuredTitleIfMissing() && !extractionResult.structuredPayloads().isEmpty()) {
@ -183,7 +177,30 @@ public class GenericDocumentImportService {
        return new ImportedDocumentResult(reloaded, detection, warnings, false);
    }

+
+    private ExtractionResult emptyExtractionResult() {
+        return new ExtractionResult(java.util.Collections.emptyMap(), java.util.Collections.emptyList(), java.util.Collections.emptyList());
+    }
+
+    private Optional<Document> resolveDeduplicatedDocument(String dedupHash, DocumentAccessContext accessContext) {
+        return documentRepository.findAllByDedupHash(dedupHash).stream()
+                .filter(existing -> sameAccessScope(existing, accessContext))
+                .findFirst();
+    }
+
+    private boolean sameAccessScope(Document existing, DocumentAccessContext accessContext) {
+        if (existing.getVisibility() != accessContext.visibility()) {
+            return false;
+        }
+        String existingTenantKey = existing.getOwnerTenant() == null ? null : existing.getOwnerTenant().getTenantKey();
+        String requestedTenantKey = accessContext.ownerTenant() == null ? null : accessContext.ownerTenant().tenantKey();
+        return java.util.Objects.equals(existingTenantKey, requestedTenantKey);
+    }
+
    private SourceDescriptor withResolvedMediaType(SourceDescriptor sourceDescriptor, ResolvedPayload payload) {
+        if (StringUtils.hasText(sourceDescriptor.mediaType())) {
+            return sourceDescriptor;
+        }
        return new SourceDescriptor(
                sourceDescriptor.accessContext(),
                sourceDescriptor.sourceType(),
@ -231,8 +248,8 @@ public class GenericDocumentImportService {
    }

    private DocumentAccessContext defaultAccessContext() {
-        String tenantKey = properties.getDefaultOwnerTenantKey();
-        DocumentVisibility visibility = properties.getDefaultVisibility();
+        String tenantKey = properties.getGenericIngestion().getDefaultOwnerTenantKey();
+        DocumentVisibility visibility = properties.getGenericIngestion().getDefaultVisibility();
        if (!StringUtils.hasText(tenantKey)) {
            return new DocumentAccessContext(null, visibility);
        }
@ -247,7 +264,7 @@ public class GenericDocumentImportService {
            return sourceDescriptor.fileName();
        }
        if (StringUtils.hasText(payload.textContent())) {
-            for (String line : payload.textContent().split("\n")) {
+            for (String line : payload.textContent().split("\\n")) {
                if (StringUtils.hasText(line)) {
                    return DocumentImportSupport.ellipsize(line.trim(), 240);
                }
@ -277,7 +294,7 @@ public class GenericDocumentImportService {

        String importBatchId = sourceDescriptor.attributes() != null && StringUtils.hasText(sourceDescriptor.attributes().get("importBatchId"))
                ? sourceDescriptor.attributes().get("importBatchId")
-                : properties.getImportBatchId();
+                : properties.getGenericIngestion().getImportBatchId();

        documentSourceService.addSource(new AddDocumentSourceCommand(
                document.getId(),
@ -298,7 +315,7 @@ public class GenericDocumentImportService {
        if (sourceDescriptor.originalContentStoragePolicy() == OriginalContentStoragePolicy.SKIP) {
            return false;
        }
-        if (properties.isStoreOriginalContentForWrapperDocuments()) {
+        if (properties.getGenericIngestion().isStoreOriginalContentForWrapperDocuments()) {
            return true;
        }
        return !isWrapperDocument(sourceDescriptor);
@ -338,9 +355,9 @@ public class GenericDocumentImportService {
    }

    private boolean shouldStoreBinaryInDb(byte[] binaryContent) {
-        return properties.isStoreOriginalBinaryInDb()
+        return properties.getGenericIngestion().isStoreOriginalBinaryInDb()
                && binaryContent != null
-                && binaryContent.length <= properties.getMaxBinaryBytesInDb();
+                && binaryContent.length <= properties.getGenericIngestion().getMaxBinaryBytesInDb();
    }

    private Map<ContentRole, DocumentContent> persistDerivedContent(Document document,
@ -373,33 +390,32 @@ public class GenericDocumentImportService {
    private void persistRepresentationsAndEmbeddings(Document document,
                                                     DocumentContent originalContent,
                                                     Map<ContentRole, DocumentContent> derivedContent,
-                                                     List<TextRepresentationDraft> drafts,
-                                                     SourceDescriptor sourceDescriptor) {
+                                                     List<TextRepresentationDraft> drafts) {
        if (drafts == null || drafts.isEmpty()) {
            return;
        }

-        EmbeddingPolicy embeddingPolicy = null;
-        EmbeddingProfile embeddingProfile = null;
-        if (embeddingProperties.isEnabled()) {
-            embeddingPolicy = embeddingPolicyResolver.resolve(document, sourceDescriptor);
-            if (embeddingPolicy != null && embeddingPolicy.enabled()) {
-                embeddingModelRegistry.getRequired(embeddingPolicy.modelKey());
-                embeddingModelCatalogService.ensureRegistered(embeddingPolicy.modelKey());
-                embeddingProfile = embeddingProfileResolver.resolve(embeddingPolicy.profileKey());
-                log.debug("Resolved embedding policy {} for document {} -> model={}, profile={}",
-                        embeddingPolicy.policyKey(), document.getId(), embeddingPolicy.modelKey(), embeddingPolicy.profileKey());
-            } else if (embeddingPolicy != null) {
-                log.debug("Resolved disabled embedding policy {} for document {}", embeddingPolicy.policyKey(), document.getId());
-            }
+        DocumentEmbeddingModel model = null;
+        if (properties.getVectorization().isEnabled() && properties.getVectorization().isGenericPipelineEnabled()) {
+            model = documentEmbeddingService.registerModel(new RegisterEmbeddingModelCommand(
+                    properties.getVectorization().getModelName(),
+                    properties.getVectorization().getEmbeddingProvider(),
+                    properties.getVectorization().getModelName(),
+                    properties.getVectorization().getDimensions(),
+                    null,
+                    false,
+                    true
+            ));
        }

        for (TextRepresentationDraft draft : drafts) {
            if (!StringUtils.hasText(draft.textBody())) {
                continue;
            }
-
-            DocumentContent linkedContent = resolveLinkedContent(draft, originalContent, derivedContent);
+            DocumentContent linkedContent = switch (draft.representationType()) {
+                case FULLTEXT, SEMANTIC_TEXT, SUMMARY, TITLE_ABSTRACT, METADATA_ENRICHED, CHUNK ->
+                        derivedContent.getOrDefault(ContentRole.NORMALIZED_TEXT, originalContent);
+            };

            var representation = documentRepresentationService.addRepresentation(new AddDocumentTextRepresentationCommand(
                    document.getId(),
@ -415,12 +431,8 @@ public class GenericDocumentImportService {
                    draft.textBody()
            ));

-            if (shouldQueueEmbedding(draft, embeddingPolicy, embeddingProfile)) {
-                representationEmbeddingOrchestrator.enqueueRepresentation(
-                        document.getId(),
-                        representation.getId(),
-                        embeddingPolicy.modelKey()
-                );
+            if (model != null && shouldQueueEmbedding(draft)) {
+                documentEmbeddingService.ensurePendingEmbedding(document.getId(), representation.getId(), model.getId());
            }
        }
        documentService.updateStatus(document.getId(), DocumentStatus.REPRESENTED);
@ -435,19 +447,11 @@ public class GenericDocumentImportService {
        return derivedContent.getOrDefault(ContentRole.NORMALIZED_TEXT, originalContent);
    }

-    private boolean shouldQueueEmbedding(TextRepresentationDraft draft,
-                                         EmbeddingPolicy embeddingPolicy,
-                                         EmbeddingProfile embeddingProfile) {
-        if (embeddingPolicy == null || !embeddingPolicy.enabled() || embeddingProfile == null) {
-            return false;
-        }
-        if (!embeddingProfile.includes(draft.representationType())) {
-            return false;
-        }
+    private boolean shouldQueueEmbedding(TextRepresentationDraft draft) {
        if (draft.queueForEmbedding() != null) {
            return draft.queueForEmbedding();
        }
-        return properties.isVectorizePrimaryRepresentationOnly() ? draft.primary() : true;
+        return properties.getGenericIngestion().isVectorizePrimaryRepresentationOnly() ? draft.primary() : true;
    }

    private ExtractionResult mergeExtractionResults(ExtractionResult base, ExtractionResult override) {
@ -500,31 +504,6 @@ public class GenericDocumentImportService {
        return java.util.Objects.equals(left, right);
    }

-    private Optional<Document> resolveDeduplicatedDocument(String dedupHash, DocumentAccessContext accessContext) {
-        return documentRepository.findByDedupHash(dedupHash).stream()
-                .filter(document -> matchesAccessContext(document, accessContext))
-                .findFirst();
-    }
-
-    private boolean matchesAccessContext(Document document, DocumentAccessContext accessContext) {
-        String expectedTenantKey = accessContext.ownerTenant() == null ? null : accessContext.ownerTenant().tenantKey();
-        if (!equalsNullable(document.getOwnerTenant() != null ? document.getOwnerTenant().getTenantKey() : null, expectedTenantKey)) {
-            return false;
-        }
-        return document.getVisibility() == accessContext.visibility();
-    }
-
-    private ExtractionResult emptyExtractionResult() {
-        return new ExtractionResult(Map.of(), List.of(), List.of());
-    }
-
-    private CanonicalDocumentMetadata buildCanonicalMetadata( Document document,
-                                                             DetectionResult detection,
-                                                             SourceDescriptor sourceDescriptor,
-                                                             ExtractionResult extractionResult) {
-        return document.toCanonicalMetadata();
-    }
-
    private record ResolvedPayload(byte[] binaryContent, String textContent, String mediaType) {
    }
 }
--- a/src/main/java/at/procon/dip/ingestion/service/TedPackageChildImportProcessor.java
+++ b/src/main/java/at/procon/dip/ingestion/service/TedPackageChildImportProcessor.java
@ -10,9 +10,7 @@ import at.procon.dip.ingestion.dto.ImportedDocumentResult;
 import at.procon.dip.ingestion.service.TedPackageExpansionService.TedPackageEntry;
 import at.procon.dip.ingestion.spi.OriginalContentStoragePolicy;
 import at.procon.dip.ingestion.spi.SourceDescriptor;
-import at.procon.dip.ingestion.config.DipIngestionProperties;
-import at.procon.dip.runtime.condition.ConditionalOnRuntimeMode;
-import at.procon.dip.runtime.config.RuntimeMode;
+import at.procon.ted.config.TedProcessorProperties;
 import java.time.OffsetDateTime;
 import java.util.LinkedHashMap;
 import java.util.Map;
@ -23,13 +21,12 @@ import org.springframework.transaction.annotation.Propagation;
 import org.springframework.transaction.annotation.Transactional;

@Service
-@ConditionalOnRuntimeMode(RuntimeMode.NEW)
@RequiredArgsConstructor
 public class TedPackageChildImportProcessor {

    private final GenericDocumentImportService importService;
    private final DocumentRelationService relationService;
-    private final DipIngestionProperties properties;
+    private final TedProcessorProperties properties;

    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public ChildImportResult processChild(UUID packageDocumentId,
@ -49,7 +46,7 @@ public class TedPackageChildImportProcessor {
        childAttributes.put("packageId", packageSourceIdentifier);
        childAttributes.put("archivePath", entry.archivePath());
        childAttributes.put("title", entry.fileName());
-        childAttributes.put("importBatchId", properties.getTedPackageImportBatchId());
+        childAttributes.put("importBatchId", properties.getGenericIngestion().getTedPackageImportBatchId());

        ImportedDocumentResult childResult = importService.importDocument(new SourceDescriptor(
                accessContext == null ? DocumentAccessContext.publicDocument() : accessContext,
--- a/src/main/java/at/procon/dip/migration/audit/config/LegacyTedAuditProperties.java
+++ b/src/main/java/at/procon/dip/migration/audit/config/LegacyTedAuditProperties.java
@ -1,47 +0,0 @@
-package at.procon.dip.migration.audit.config;
-
-import jakarta.validation.constraints.Min;
-import lombok.Data;
-import org.springframework.boot.context.properties.ConfigurationProperties;
-import org.springframework.context.annotation.Configuration;
-
-@Configuration
-@ConfigurationProperties(prefix = "dip.migration.legacy-audit")
-@Data
-public class LegacyTedAuditProperties {
-
-    /**
-     * Enables the Wave 1 / Milestone A legacy TED audit subsystem.
-     */
-    private boolean enabled = true;
-
-    /**
-     * Automatically runs the read-only audit on application startup.
-     */
-    private boolean startupRunEnabled = false;
-
-    /**
-     * Maximum number of legacy TED documents to scan during startup.
-     * 0 means no limit.
-     */
-    @Min(0)
-    private int startupRunLimit = 500;
-
-    /**
-     * Batch size for legacy TED document paging.
-     */
-    @Min(1)
-    private int pageSize = 100;
-
-    /**
-     * Hard cap for persisted findings in a single run to avoid runaway audit volume.
-     */
-    @Min(1)
-    private int maxFindingsPerRun = 10000;
-
-    /**
-     * Maximum number of duplicate/grouped samples recorded for global aggregate checks.
-     */
-    @Min(1)
-    private int maxDuplicateSamples = 100;
-}
--- a/src/main/java/at/procon/dip/migration/audit/entity/LegacyTedAuditFinding.java
+++ b/src/main/java/at/procon/dip/migration/audit/entity/LegacyTedAuditFinding.java
@ -1,87 +0,0 @@
-package at.procon.dip.migration.audit.entity;
-
-import at.procon.dip.architecture.SchemaNames;
-import jakarta.persistence.Column;
-import jakarta.persistence.Entity;
-import jakarta.persistence.EnumType;
-import jakarta.persistence.Enumerated;
-import jakarta.persistence.FetchType;
-import jakarta.persistence.GeneratedValue;
-import jakarta.persistence.GenerationType;
-import jakarta.persistence.Id;
-import jakarta.persistence.Index;
-import jakarta.persistence.JoinColumn;
-import jakarta.persistence.ManyToOne;
-import jakarta.persistence.PrePersist;
-import jakarta.persistence.Table;
-import java.time.OffsetDateTime;
-import java.util.UUID;
-import lombok.AllArgsConstructor;
-import lombok.Builder;
-import lombok.Getter;
-import lombok.NoArgsConstructor;
-import lombok.Setter;
-
-@Entity
-@Table(schema = SchemaNames.DOC, name = "doc_legacy_audit_finding", indexes = {
-        @Index(name = "idx_doc_legacy_audit_find_run", columnList = "run_id"),
-        @Index(name = "idx_doc_legacy_audit_find_type", columnList = "finding_type"),
-        @Index(name = "idx_doc_legacy_audit_find_severity", columnList = "severity"),
-        @Index(name = "idx_doc_legacy_audit_find_legacy_doc", columnList = "legacy_procurement_document_id"),
-        @Index(name = "idx_doc_legacy_audit_find_document", columnList = "document_id")
-})
-@Getter
-@Setter
-@NoArgsConstructor
-@AllArgsConstructor
-@Builder
-public class LegacyTedAuditFinding {
-
-    @Id
-    @GeneratedValue(strategy = GenerationType.UUID)
-    private UUID id;
-
-    @ManyToOne(fetch = FetchType.LAZY, optional = false)
-    @JoinColumn(name = "run_id", nullable = false)
-    private LegacyTedAuditRun run;
-
-    @Enumerated(EnumType.STRING)
-    @Column(name = "severity", nullable = false, length = 16)
-    private LegacyTedAuditSeverity severity;
-
-    @Enumerated(EnumType.STRING)
-    @Column(name = "finding_type", nullable = false, length = 64)
-    private LegacyTedAuditFindingType findingType;
-
-    @Column(name = "package_identifier", length = 20)
-    private String packageIdentifier;
-
-    @Column(name = "legacy_procurement_document_id")
-    private UUID legacyProcurementDocumentId;
-
-    @Column(name = "document_id")
-    private UUID documentId;
-
-    @Column(name = "ted_notice_projection_id")
-    private UUID tedNoticeProjectionId;
-
-    @Column(name = "reference_key", length = 255)
-    private String referenceKey;
-
-    @Column(name = "message", nullable = false, columnDefinition = "TEXT")
-    private String message;
-
-    @Column(name = "details_text", columnDefinition = "TEXT")
-    private String detailsText;
-
-    @Builder.Default
-    @Column(name = "created_at", nullable = false, updatable = false)
-    private OffsetDateTime createdAt = OffsetDateTime.now();
-
-    @PrePersist
-    protected void onCreate() {
-        if (createdAt == null) {
-            createdAt = OffsetDateTime.now();
-        }
-    }
-}
--- a/src/main/java/at/procon/dip/migration/audit/entity/LegacyTedAuditFindingType.java
+++ b/src/main/java/at/procon/dip/migration/audit/entity/LegacyTedAuditFindingType.java
@ -1,28 +0,0 @@
-package at.procon.dip.migration.audit.entity;
-
-public enum LegacyTedAuditFindingType {
-    PACKAGE_SEQUENCE_GAP,
-    PACKAGE_INCOMPLETE,
-    PACKAGE_COMPLETED_WITHOUT_PROCESSED_AT,
-    PACKAGE_COMPLETED_COUNT_MISMATCH,
-    PACKAGE_MISSING_XML_FILE_COUNT,
-    PACKAGE_MISSING_FILE_HASH,
-    PACKAGE_FAILED_WITHOUT_ERROR_MESSAGE,
-    LEGACY_PUBLICATION_ID_DUPLICATE,
-    DOC_DEDUP_HASH_DUPLICATE,
-    LEGACY_DOCUMENT_MISSING_HASH,
-    LEGACY_DOCUMENT_MISSING_XML,
-    LEGACY_DOCUMENT_MISSING_TEXT,
-    LEGACY_DOCUMENT_MISSING_PUBLICATION_ID,
-    DOC_DOCUMENT_MISSING,
-    DOC_DOCUMENT_DUPLICATE,
-    DOC_SOURCE_MISSING,
-    DOC_ORIGINAL_CONTENT_MISSING,
-    DOC_ORIGINAL_CONTENT_DUPLICATE,
-    DOC_PRIMARY_REPRESENTATION_MISSING,
-    DOC_PRIMARY_REPRESENTATION_DUPLICATE,
-    TED_PROJECTION_MISSING,
-    TED_PROJECTION_MISSING_LEGACY_LINK,
-    TED_PROJECTION_DOCUMENT_MISMATCH,
-    FINDINGS_TRUNCATED
-}
--- a/src/main/java/at/procon/dip/migration/audit/entity/LegacyTedAuditRun.java
+++ b/src/main/java/at/procon/dip/migration/audit/entity/LegacyTedAuditRun.java
@ -1,110 +0,0 @@
-package at.procon.dip.migration.audit.entity;
-
-import at.procon.dip.architecture.SchemaNames;
-import jakarta.persistence.Column;
-import jakarta.persistence.Entity;
-import jakarta.persistence.EnumType;
-import jakarta.persistence.Enumerated;
-import jakarta.persistence.GeneratedValue;
-import jakarta.persistence.GenerationType;
-import jakarta.persistence.Id;
-import jakarta.persistence.Index;
-import jakarta.persistence.PrePersist;
-import jakarta.persistence.PreUpdate;
-import jakarta.persistence.Table;
-import java.time.OffsetDateTime;
-import java.util.UUID;
-import lombok.AllArgsConstructor;
-import lombok.Builder;
-import lombok.Getter;
-import lombok.NoArgsConstructor;
-import lombok.Setter;
-
-@Entity
-@Table(schema = SchemaNames.DOC, name = "doc_legacy_audit_run", indexes = {
-        @Index(name = "idx_doc_legacy_audit_run_status", columnList = "status"),
-        @Index(name = "idx_doc_legacy_audit_run_started", columnList = "started_at")
-})
-@Getter
-@Setter
-@NoArgsConstructor
-@AllArgsConstructor
-@Builder
-public class LegacyTedAuditRun {
-
-    @Id
-    @GeneratedValue(strategy = GenerationType.UUID)
-    private UUID id;
-
-    @Enumerated(EnumType.STRING)
-    @Column(name = "status", nullable = false, length = 32)
-    private LegacyTedAuditRunStatus status;
-
-    @Column(name = "requested_limit")
-    private Integer requestedLimit;
-
-    @Column(name = "page_size", nullable = false)
-    private Integer pageSize;
-
-    @Column(name = "scanned_packages", nullable = false)
-    @Builder.Default
-    private Integer scannedPackages = 0;
-
-    @Column(name = "scanned_legacy_documents", nullable = false)
-    @Builder.Default
-    private Integer scannedLegacyDocuments = 0;
-
-    @Column(name = "finding_count", nullable = false)
-    @Builder.Default
-    private Integer findingCount = 0;
-
-    @Column(name = "info_count", nullable = false)
-    @Builder.Default
-    private Integer infoCount = 0;
-
-    @Column(name = "warning_count", nullable = false)
-    @Builder.Default
-    private Integer warningCount = 0;
-
-    @Column(name = "error_count", nullable = false)
-    @Builder.Default
-    private Integer errorCount = 0;
-
-    @Column(name = "started_at", nullable = false)
-    private OffsetDateTime startedAt;
-
-    @Column(name = "completed_at")
-    private OffsetDateTime completedAt;
-
-    @Column(name = "summary_text", columnDefinition = "TEXT")
-    private String summaryText;
-
-    @Column(name = "failure_message", columnDefinition = "TEXT")
-    private String failureMessage;
-
-    @Builder.Default
-    @Column(name = "created_at", nullable = false, updatable = false)
-    private OffsetDateTime createdAt = OffsetDateTime.now();
-
-    @Builder.Default
-    @Column(name = "updated_at", nullable = false)
-    private OffsetDateTime updatedAt = OffsetDateTime.now();
-
-    @PrePersist
-    protected void onCreate() {
-        if (startedAt == null) {
-            startedAt = OffsetDateTime.now();
-        }
-        if (createdAt == null) {
-            createdAt = OffsetDateTime.now();
-        }
-        if (updatedAt == null) {
-            updatedAt = OffsetDateTime.now();
-        }
-    }
-
-    @PreUpdate
-    protected void onUpdate() {
-        updatedAt = OffsetDateTime.now();
-    }
-}
--- a/src/main/java/at/procon/dip/migration/audit/entity/LegacyTedAuditRunStatus.java
+++ b/src/main/java/at/procon/dip/migration/audit/entity/LegacyTedAuditRunStatus.java
@ -1,7 +0,0 @@
-package at.procon.dip.migration.audit.entity;
-
-public enum LegacyTedAuditRunStatus {
-    RUNNING,
-    COMPLETED,
-    FAILED
-}
--- a/src/main/java/at/procon/dip/migration/audit/entity/LegacyTedAuditSeverity.java
+++ b/src/main/java/at/procon/dip/migration/audit/entity/LegacyTedAuditSeverity.java
@ -1,7 +0,0 @@
-package at.procon.dip.migration.audit.entity;
-
-public enum LegacyTedAuditSeverity {
-    INFO,
-    WARNING,
-    ERROR
-}
--- a/src/main/java/at/procon/dip/migration/audit/repository/LegacyTedAuditFindingRepository.java
+++ b/src/main/java/at/procon/dip/migration/audit/repository/LegacyTedAuditFindingRepository.java
@ -1,8 +0,0 @@
-package at.procon.dip.migration.audit.repository;
-
-import at.procon.dip.migration.audit.entity.LegacyTedAuditFinding;
-import java.util.UUID;
-import org.springframework.data.jpa.repository.JpaRepository;
-
-public interface LegacyTedAuditFindingRepository extends JpaRepository<LegacyTedAuditFinding, UUID> {
-}
--- a/src/main/java/at/procon/dip/migration/audit/repository/LegacyTedAuditRunRepository.java
+++ b/src/main/java/at/procon/dip/migration/audit/repository/LegacyTedAuditRunRepository.java
@ -1,8 +0,0 @@
-package at.procon.dip.migration.audit.repository;
-
-import at.procon.dip.migration.audit.entity.LegacyTedAuditRun;
-import java.util.UUID;
-import org.springframework.data.jpa.repository.JpaRepository;
-
-public interface LegacyTedAuditRunRepository extends JpaRepository<LegacyTedAuditRun, UUID> {
-}
--- a/src/main/java/at/procon/dip/migration/audit/service/LegacyTedAuditService.java
+++ b/src/main/java/at/procon/dip/migration/audit/service/LegacyTedAuditService.java
@ -1,610 +0,0 @@
-package at.procon.dip.migration.audit.service;
-
-import at.procon.dip.migration.audit.config.LegacyTedAuditProperties;
-import at.procon.dip.migration.audit.entity.LegacyTedAuditFinding;
-import at.procon.dip.migration.audit.entity.LegacyTedAuditFindingType;
-import at.procon.dip.migration.audit.entity.LegacyTedAuditRun;
-import at.procon.dip.migration.audit.entity.LegacyTedAuditRunStatus;
-import at.procon.dip.migration.audit.entity.LegacyTedAuditSeverity;
-import at.procon.dip.migration.audit.repository.LegacyTedAuditFindingRepository;
-import at.procon.dip.migration.audit.repository.LegacyTedAuditRunRepository;
-import at.procon.dip.runtime.condition.ConditionalOnRuntimeMode;
-import at.procon.dip.runtime.config.RuntimeMode;
-import at.procon.ted.model.entity.ProcurementDocument;
-import at.procon.ted.model.entity.TedDailyPackage;
-import at.procon.ted.repository.ProcurementDocumentRepository;
-import at.procon.ted.repository.TedDailyPackageRepository;
-import java.time.OffsetDateTime;
-import java.time.Year;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Map;
-import java.util.TreeMap;
-import java.util.UUID;
-import lombok.RequiredArgsConstructor;
-import lombok.extern.slf4j.Slf4j;
-import org.springframework.data.domain.Page;
-import org.springframework.data.domain.PageRequest;
-import org.springframework.data.domain.Sort;
-import org.springframework.jdbc.core.JdbcTemplate;
-import org.springframework.stereotype.Service;
-import org.springframework.util.StringUtils;
-
-@Service
-@ConditionalOnRuntimeMode(RuntimeMode.NEW)
-@RequiredArgsConstructor
-@Slf4j
-public class LegacyTedAuditService {
-
-    private final LegacyTedAuditProperties properties;
-    private final TedDailyPackageRepository tedDailyPackageRepository;
-    private final ProcurementDocumentRepository procurementDocumentRepository;
-    private final LegacyTedAuditRunRepository runRepository;
-    private final LegacyTedAuditFindingRepository findingRepository;
-    private final JdbcTemplate jdbcTemplate;
-
-    public LegacyTedAuditRun executeAudit() {
-        return executeAudit(properties.getStartupRunLimit());
-    }
-
-    public LegacyTedAuditRun executeAudit(int requestedLimit) {
-        if (!properties.isEnabled()) {
-            throw new IllegalStateException("Legacy TED audit is disabled by configuration");
-        }
-
-        Integer effectiveLimit = requestedLimit > 0 ? requestedLimit : null;
-        int pageSize = properties.getPageSize();
-        AuditAccumulator accumulator = new AuditAccumulator();
-
-        LegacyTedAuditRun run = LegacyTedAuditRun.builder()
-                .status(LegacyTedAuditRunStatus.RUNNING)
-                .requestedLimit(effectiveLimit)
-                .pageSize(pageSize)
-                .startedAt(OffsetDateTime.now())
-                .build();
-        run = runRepository.save(run);
-
-        try {
-            int scannedPackages = auditPackages(run, accumulator);
-            auditGlobalDuplicates(run, accumulator);
-            int scannedLegacyDocuments = 0;//auditLegacyDocuments(run, accumulator, effectiveLimit, pageSize);
-
-            run.setStatus(LegacyTedAuditRunStatus.COMPLETED);
-            run.setCompletedAt(OffsetDateTime.now());
-            run.setScannedPackages(scannedPackages);
-            run.setScannedLegacyDocuments(scannedLegacyDocuments);
-            run.setFindingCount(accumulator.totalFindings());
-            run.setInfoCount(accumulator.infoCount());
-            run.setWarningCount(accumulator.warningCount());
-            run.setErrorCount(accumulator.errorCount());
-            run.setSummaryText(buildSummary(scannedPackages, scannedLegacyDocuments, accumulator));
-            run.setFailureMessage(null);
-            run = runRepository.save(run);
-
-            log.info("Wave 1 / Milestone A legacy-only audit completed: runId={}, packages={}, documents={}, findings={}, warnings={}, errors={}",
-                    run.getId(), scannedPackages, scannedLegacyDocuments, accumulator.totalFindings(),
-                    accumulator.warningCount(), accumulator.errorCount());
-            return run;
-        } catch (RuntimeException ex) {
-            run.setStatus(LegacyTedAuditRunStatus.FAILED);
-            run.setCompletedAt(OffsetDateTime.now());
-            run.setScannedPackages(accumulator.scannedPackages());
-            run.setScannedLegacyDocuments(accumulator.scannedLegacyDocuments());
-            run.setFindingCount(accumulator.totalFindings());
-            run.setInfoCount(accumulator.infoCount());
-            run.setWarningCount(accumulator.warningCount());
-            run.setErrorCount(accumulator.errorCount());
-            run.setFailureMessage(ex.getMessage());
-            run.setSummaryText(buildSummary(accumulator.scannedPackages(), accumulator.scannedLegacyDocuments(), accumulator));
-            runRepository.save(run);
-            log.error("Wave 1 / Milestone A legacy-only audit failed: runId={}", run.getId(), ex);
-            throw ex;
-        }
-    }
-
-    private int auditPackages(LegacyTedAuditRun run, AuditAccumulator accumulator) {
-        List<TedDailyPackage> packages = tedDailyPackageRepository.findAll(Sort.by(Sort.Direction.ASC, "year", "serialNumber"));
-        if (packages.isEmpty()) {
-            return 0;
-        }
-
-        Map<Integer, List<TedDailyPackage>> packagesByYear = new TreeMap<>();
-        for (TedDailyPackage dailyPackage : packages) {
-            packagesByYear.computeIfAbsent(dailyPackage.getYear(), ignored -> new ArrayList<>()).add(dailyPackage);
-        }
-
-        int firstYear = packagesByYear.keySet().iterator().next();
-        int currentYear = Year.now().getValue();
-
-        for (int year = firstYear; year <= currentYear; year++) {
-            List<TedDailyPackage> yearPackages = packagesByYear.get(year);
-            if (yearPackages == null || yearPackages.isEmpty()) {
-                recordFinding(run, accumulator,
-                        LegacyTedAuditSeverity.WARNING,
-                        LegacyTedAuditFindingType.PACKAGE_SEQUENCE_GAP,
-                        null,
-                        null,
-                        null,
-                        null,
-                        "year:" + year,
-                        "No TED package rows exist for this year inside the audited interval",
-                        "year=" + year + ", intervalStartYear=" + firstYear + ", intervalEndYear=" + currentYear);
-                continue;
-            }
-
-            auditYearPackageSequence(run, accumulator, year, yearPackages);
-
-            for (TedDailyPackage dailyPackage : yearPackages) {
-                accumulator.incrementScannedPackages();
-                auditSinglePackage(run, accumulator, dailyPackage);
-            }
-        }
-
-        return packages.size();
-    }
-
-    private void auditYearPackageSequence(LegacyTedAuditRun run,
-                                          AuditAccumulator accumulator,
-                                          int year,
-                                          List<TedDailyPackage> yearPackages) {
-        yearPackages.sort((left, right) -> Integer.compare(safeInt(left.getSerialNumber()), safeInt(right.getSerialNumber())));
-
-        int firstSerial = safeInt(yearPackages.getFirst().getSerialNumber());
-        if (firstSerial > 1) {
-            recordMissingPackageRange(run, accumulator, year, 1, firstSerial - 1,
-                    "TED package year starts after serial 1");
-        }
-
-        for (int i = 1; i < yearPackages.size(); i++) {
-            int previousSerial = safeInt(yearPackages.get(i - 1).getSerialNumber());
-            int currentSerial = safeInt(yearPackages.get(i).getSerialNumber());
-            if (currentSerial > previousSerial + 1) {
-                recordMissingPackageRange(run, accumulator, year, previousSerial + 1, currentSerial - 1,
-                        "TED package sequence gap detected");
-            }
-        }
-    }
-
-    private void recordMissingPackageRange(LegacyTedAuditRun run,
-                                           AuditAccumulator accumulator,
-                                           int year,
-                                           int startSerial,
-                                           int endSerial,
-                                           String message) {
-        String startPackageId = formatPackageIdentifier(year, startSerial);
-        String endPackageId = formatPackageIdentifier(year, endSerial);
-        String referenceKey = startSerial == endSerial ? startPackageId : startPackageId + "-" + endPackageId;
-
-        recordFinding(run, accumulator,
-                LegacyTedAuditSeverity.WARNING,
-                LegacyTedAuditFindingType.PACKAGE_SEQUENCE_GAP,
-                startSerial == endSerial ? startPackageId : null,
-                null,
-                null,
-                null,
-                referenceKey,
-                message,
-                "year=" + year + ", missingStartSerial=" + startSerial + ", missingEndSerial=" + endSerial);
-    }
-
-    private void auditSinglePackage(LegacyTedAuditRun run,
-                                    AuditAccumulator accumulator,
-                                    TedDailyPackage dailyPackage) {
-        String packageIdentifier = dailyPackage.getPackageIdentifier();
-        int processedCount = safeInt(dailyPackage.getProcessedCount());
-        int failedCount = safeInt(dailyPackage.getFailedCount());
-        int accountedDocuments = processedCount + failedCount;
-
-        if (dailyPackage.getDownloadStatus() == TedDailyPackage.DownloadStatus.COMPLETED
-                && dailyPackage.getProcessedAt() == null) {
-            recordFinding(run, accumulator,
-                    LegacyTedAuditSeverity.WARNING,
-                    LegacyTedAuditFindingType.PACKAGE_COMPLETED_WITHOUT_PROCESSED_AT,
-                    packageIdentifier,
-                    null,
-                    null,
-                    null,
-                    packageIdentifier,
-                    "TED package is marked COMPLETED but processedAt is null",
-                    null);
-        }
-
-        if (dailyPackage.getDownloadStatus() == TedDailyPackage.DownloadStatus.COMPLETED
-                && dailyPackage.getXmlFileCount() == null) {
-            recordFinding(run, accumulator,
-                    LegacyTedAuditSeverity.WARNING,
-                    LegacyTedAuditFindingType.PACKAGE_MISSING_XML_FILE_COUNT,
-                    packageIdentifier,
-                    null,
-                    null,
-                    null,
-                    packageIdentifier,
-                    "TED package is marked COMPLETED but xmlFileCount is null",
-                    null);
-        }
-
-        if ((dailyPackage.getDownloadStatus() == TedDailyPackage.DownloadStatus.DOWNLOADED
-                || dailyPackage.getDownloadStatus() == TedDailyPackage.DownloadStatus.PROCESSING
-                || dailyPackage.getDownloadStatus() == TedDailyPackage.DownloadStatus.COMPLETED)
-                && !StringUtils.hasText(dailyPackage.getFileHash())) {
-            recordFinding(run, accumulator,
-                    LegacyTedAuditSeverity.WARNING,
-                    LegacyTedAuditFindingType.PACKAGE_MISSING_FILE_HASH,
-                    packageIdentifier,
-                    null,
-                    null,
-                    null,
-                    packageIdentifier,
-                    "TED package has no file hash recorded",
-                    "downloadStatus=" + dailyPackage.getDownloadStatus());
-        }
-
-        if (dailyPackage.getDownloadStatus() == TedDailyPackage.DownloadStatus.FAILED
-                && !StringUtils.hasText(dailyPackage.getErrorMessage())) {
-            recordFinding(run, accumulator,
-                    LegacyTedAuditSeverity.WARNING,
-                    LegacyTedAuditFindingType.PACKAGE_FAILED_WITHOUT_ERROR_MESSAGE,
-                    packageIdentifier,
-                    null,
-                    null,
-                    null,
-                    packageIdentifier,
-                    "TED package is marked FAILED but has no error message",
-                    null);
-        }
-
-        if (dailyPackage.getXmlFileCount() != null) {
-            if (accountedDocuments > dailyPackage.getXmlFileCount()) {
-                recordFinding(run, accumulator,
-                        LegacyTedAuditSeverity.ERROR,
-                        LegacyTedAuditFindingType.PACKAGE_COMPLETED_COUNT_MISMATCH,
-                        packageIdentifier,
-                        null,
-                        null,
-                        null,
-                        packageIdentifier,
-                        "TED package accounting exceeds xmlFileCount",
-                        "xmlFileCount=" + dailyPackage.getXmlFileCount()
-                                + ", processedCount=" + processedCount
-                                + ", failedCount=" + failedCount);
-            } else if (dailyPackage.getDownloadStatus() == TedDailyPackage.DownloadStatus.COMPLETED
-                    && accountedDocuments < dailyPackage.getXmlFileCount()) {
-                recordFinding(run, accumulator,
-                        LegacyTedAuditSeverity.WARNING,
-                        LegacyTedAuditFindingType.PACKAGE_COMPLETED_COUNT_MISMATCH,
-                        packageIdentifier,
-                        null,
-                        null,
-                        null,
-                        packageIdentifier,
-                        "TED package accounting is below xmlFileCount",
-                        "xmlFileCount=" + dailyPackage.getXmlFileCount()
-                                + ", processedCount=" + processedCount
-                                + ", failedCount=" + failedCount);
-            }
-        }
-
-        if (isPackageIncompleteForReimport(dailyPackage, processedCount, failedCount, accountedDocuments)) {
-            recordFinding(run, accumulator,
-                    dailyPackage.getDownloadStatus() == TedDailyPackage.DownloadStatus.FAILED
-                            ? LegacyTedAuditSeverity.ERROR
-                            : LegacyTedAuditSeverity.WARNING,
-                    LegacyTedAuditFindingType.PACKAGE_INCOMPLETE,
-                    packageIdentifier,
-                    null,
-                    null,
-                    null,
-                    packageIdentifier,
-                    "TED package is not fully imported and should be considered for re-import",
-                    buildIncompletePackageDetails(dailyPackage, processedCount, failedCount, accountedDocuments));
-        }
-    }
-
-    private boolean isPackageIncompleteForReimport(TedDailyPackage dailyPackage,
-                                                   int processedCount,
-                                                   int failedCount,
-                                                   int accountedDocuments) {
-        TedDailyPackage.DownloadStatus status = dailyPackage.getDownloadStatus();
-        if (status == null) {
-            return true;
-        }
-        if (status == TedDailyPackage.DownloadStatus.NOT_FOUND) {
-            return false;
-        }
-        if (status == TedDailyPackage.DownloadStatus.PENDING
-                || status == TedDailyPackage.DownloadStatus.DOWNLOADING
-                || status == TedDailyPackage.DownloadStatus.DOWNLOADED
-                || status == TedDailyPackage.DownloadStatus.PROCESSING
-                || status == TedDailyPackage.DownloadStatus.FAILED) {
-            return true;
-        }
-        if (status != TedDailyPackage.DownloadStatus.COMPLETED) {
-            return true;
-        }
-        if (dailyPackage.getXmlFileCount() == null) {
-            return true;
-        }
-        if (failedCount > 0) {
-            return true;
-        }
-        return processedCount < dailyPackage.getXmlFileCount()
-                || accountedDocuments != dailyPackage.getXmlFileCount();
-    }
-
-    private String buildIncompletePackageDetails(TedDailyPackage dailyPackage,
-                                                 int processedCount,
-                                                 int failedCount,
-                                                 int accountedDocuments) {
-        return "status=" + dailyPackage.getDownloadStatus()
-                + ", xmlFileCount=" + dailyPackage.getXmlFileCount()
-                + ", processedCount=" + processedCount
-                + ", failedCount=" + failedCount
-                + ", accountedDocuments=" + accountedDocuments;
-    }
-
-    private void auditGlobalDuplicates(LegacyTedAuditRun run, AuditAccumulator accumulator) {
-        int limit = properties.getMaxDuplicateSamples();
-
-        jdbcTemplate.query(
-                """
-                SELECT publication_id, COUNT(*) AS duplicate_count
-                FROM ted.procurement_document
-                WHERE publication_id IS NOT NULL AND publication_id <> ''
-                GROUP BY publication_id
-                HAVING COUNT(*) > 1
-                ORDER BY duplicate_count DESC, publication_id ASC
-                LIMIT ?
-                """,
-                ps -> ps.setInt(1, limit),
-                (rs, rowNum) -> {
-                    String publicationId = rs.getString("publication_id");
-                    long duplicateCount = rs.getLong("duplicate_count");
-                    recordFinding(run, accumulator,
-                            LegacyTedAuditSeverity.ERROR,
-                            LegacyTedAuditFindingType.LEGACY_PUBLICATION_ID_DUPLICATE,
-                            null,
-                            null,
-                            null,
-                            null,
-                            publicationId,
-                            "Legacy TED publicationId appears multiple times",
-                            "publicationId=" + publicationId + ", duplicateCount=" + duplicateCount);
-                    return null;
-                });
-    }
-
-    private int auditLegacyDocuments(LegacyTedAuditRun run,
-                                     AuditAccumulator accumulator,
-                                     Integer requestedLimit,
-                                     int pageSize) {
-        int processed = 0;
-        int pageNumber = 0;
-
-        while (requestedLimit == null || processed < requestedLimit) {
-            Page<ProcurementDocument> page = procurementDocumentRepository.findAll(
-                    PageRequest.of(pageNumber, pageSize, Sort.by(Sort.Direction.ASC, "createdAt", "id")));
-
-            if (page.isEmpty()) {
-                break;
-            }
-
-            for (ProcurementDocument legacyDocument : page.getContent()) {
-                auditSingleLegacyDocument(run, accumulator, legacyDocument);
-                accumulator.incrementScannedLegacyDocuments();
-                processed++;
-                if (requestedLimit != null && processed >= requestedLimit) {
-                    return processed;
-                }
-            }
-
-            if (!page.hasNext()) {
-                break;
-            }
-            pageNumber++;
-        }
-
-        return processed;
-    }
-
-    private void auditSingleLegacyDocument(LegacyTedAuditRun run,
-                                           AuditAccumulator accumulator,
-                                           ProcurementDocument legacyDocument) {
-        UUID legacyDocumentId = legacyDocument.getId();
-        String referenceKey = buildReferenceKey(legacyDocument);
-        String documentHash = legacyDocument.getDocumentHash();
-
-        if (!StringUtils.hasText(documentHash)) {
-            recordFinding(run, accumulator,
-                    LegacyTedAuditSeverity.ERROR,
-                    LegacyTedAuditFindingType.LEGACY_DOCUMENT_MISSING_HASH,
-                    null,
-                    legacyDocumentId,
-                    null,
-                    null,
-                    referenceKey,
-                    "Legacy TED document has no documentHash",
-                    null);
-            return;
-        }
-
-        if (!StringUtils.hasText(legacyDocument.getXmlDocument())) {
-            recordFinding(run, accumulator,
-                    LegacyTedAuditSeverity.ERROR,
-                    LegacyTedAuditFindingType.LEGACY_DOCUMENT_MISSING_XML,
-                    null,
-                    legacyDocumentId,
-                    null,
-                    null,
-                    referenceKey,
-                    "Legacy TED document has no xmlDocument payload",
-                    "documentHash=" + documentHash);
-        }
-
-        if (!StringUtils.hasText(legacyDocument.getTextContent())) {
-            recordFinding(run, accumulator,
-                    LegacyTedAuditSeverity.WARNING,
-                    LegacyTedAuditFindingType.LEGACY_DOCUMENT_MISSING_TEXT,
-                    null,
-                    legacyDocumentId,
-                    null,
-                    null,
-                    referenceKey,
-                    "Legacy TED document has no normalized textContent",
-                    "documentHash=" + documentHash);
-        }
-
-        if (!StringUtils.hasText(legacyDocument.getPublicationId())) {
-            recordFinding(run, accumulator,
-                    LegacyTedAuditSeverity.WARNING,
-                    LegacyTedAuditFindingType.LEGACY_DOCUMENT_MISSING_PUBLICATION_ID,
-                    null,
-                    legacyDocumentId,
-                    null,
-                    null,
-                    referenceKey,
-                    "Legacy TED document has no publicationId",
-                    "documentHash=" + documentHash);
-        }
-    }
-
-    private void recordFinding(LegacyTedAuditRun run,
-                               AuditAccumulator accumulator,
-                               LegacyTedAuditSeverity severity,
-                               LegacyTedAuditFindingType findingType,
-                               String packageIdentifier,
-                               UUID legacyProcurementDocumentId,
-                               UUID genericDocumentId,
-                               UUID tedProjectionId,
-                               String referenceKey,
-                               String message,
-                               String detailsText) {
-        if (accumulator.totalFindings() >= properties.getMaxFindingsPerRun()) {
-            accumulator.markTruncated();
-            if (!accumulator.truncationRecorded()) {
-                LegacyTedAuditFinding truncatedFinding = LegacyTedAuditFinding.builder()
-                        .run(run)
-                        .severity(LegacyTedAuditSeverity.INFO)
-                        .findingType(LegacyTedAuditFindingType.FINDINGS_TRUNCATED)
-                        .referenceKey(referenceKey != null ? referenceKey : "max-findings-per-run")
-                        .message("Legacy TED audit finding limit reached; additional findings were suppressed")
-                        .detailsText("maxFindingsPerRun=" + properties.getMaxFindingsPerRun())
-                        .build();
-                findingRepository.save(truncatedFinding);
-                accumulator.recordFinding(LegacyTedAuditSeverity.INFO, true);
-            }
-            return;
-        }
-
-        LegacyTedAuditFinding finding = LegacyTedAuditFinding.builder()
-                .run(run)
-                .severity(severity)
-                .findingType(findingType)
-                .packageIdentifier(packageIdentifier)
-                .legacyProcurementDocumentId(legacyProcurementDocumentId)
-                .documentId(genericDocumentId)
-                .tedNoticeProjectionId(tedProjectionId)
-                .referenceKey(referenceKey)
-                .message(message)
-                .detailsText(detailsText)
-                .build();
-        findingRepository.save(finding);
-        accumulator.recordFinding(severity, false);
-    }
-
-    private String buildReferenceKey(ProcurementDocument legacyDocument) {
-        if (StringUtils.hasText(legacyDocument.getPublicationId())) {
-            return legacyDocument.getPublicationId();
-        }
-        if (StringUtils.hasText(legacyDocument.getNoticeId())) {
-            return legacyDocument.getNoticeId();
-        }
-        if (StringUtils.hasText(legacyDocument.getSourceFilename())) {
-            return legacyDocument.getSourceFilename();
-        }
-        return String.valueOf(legacyDocument.getId());
-    }
-
-    private int safeInt(Integer value) {
-        return value != null ? value : 0;
-    }
-
-    private String formatPackageIdentifier(int year, int serialNumber) {
-        return "%04d%05d".formatted(year, serialNumber);
-    }
-
-    private String buildSummary(int scannedPackages,
-                                int scannedLegacyDocuments,
-                                AuditAccumulator accumulator) {
-        return "packages=" + scannedPackages
-                + ", legacyDocuments=" + scannedLegacyDocuments
-                + ", findings=" + accumulator.totalFindings()
-                + ", warnings=" + accumulator.warningCount()
-                + ", errors=" + accumulator.errorCount()
-                + (accumulator.truncated() ? ", truncated=true" : "");
-    }
-
-    private static final class AuditAccumulator {
-        private int scannedPackages;
-        private int scannedLegacyDocuments;
-        private int infoCount;
-        private int warningCount;
-        private int errorCount;
-        private boolean truncated;
-        private boolean truncationRecorded;
-
-        void incrementScannedPackages() {
-            scannedPackages++;
-        }
-
-        void incrementScannedLegacyDocuments() {
-            scannedLegacyDocuments++;
-        }
-
-        void recordFinding(LegacyTedAuditSeverity severity, boolean truncationFindingRecordedNow) {
-            switch (severity) {
-                case INFO -> infoCount++;
-                case WARNING -> warningCount++;
-                case ERROR -> errorCount++;
-            }
-            if (truncationFindingRecordedNow) {
-                truncationRecorded = true;
-            }
-        }
-
-        void markTruncated() {
-            truncated = true;
-        }
-
-        int totalFindings() {
-            return infoCount + warningCount + errorCount;
-        }
-
-        int infoCount() {
-            return infoCount;
-        }
-
-        int warningCount() {
-            return warningCount;
-        }
-
-        int errorCount() {
-            return errorCount;
-        }
-
-        int scannedPackages() {
-            return scannedPackages;
-        }
-
-        int scannedLegacyDocuments() {
-            return scannedLegacyDocuments;
-        }
-
-        boolean truncated() {
-            return truncated;
-        }
-
-        boolean truncationRecorded() {
-            return truncationRecorded;
-        }
-    }
-}
--- a/src/main/java/at/procon/dip/migration/audit/startup/LegacyTedAuditStartupRunner.java
+++ b/src/main/java/at/procon/dip/migration/audit/startup/LegacyTedAuditStartupRunner.java
@ -1,33 +0,0 @@
-package at.procon.dip.migration.audit.startup;
-
-import at.procon.dip.migration.audit.config.LegacyTedAuditProperties;
-import at.procon.dip.migration.audit.service.LegacyTedAuditService;
-import at.procon.dip.runtime.condition.ConditionalOnRuntimeMode;
-import at.procon.dip.runtime.config.RuntimeMode;
-import lombok.RequiredArgsConstructor;
-import lombok.extern.slf4j.Slf4j;
-import org.springframework.boot.ApplicationArguments;
-import org.springframework.boot.ApplicationRunner;
-import org.springframework.stereotype.Component;
-
-@Component
-@ConditionalOnRuntimeMode(RuntimeMode.NEW)
-@RequiredArgsConstructor
-@Slf4j
-public class LegacyTedAuditStartupRunner implements ApplicationRunner {
-
-    private final LegacyTedAuditProperties properties;
-    private final LegacyTedAuditService legacyTedAuditService;
-
-    @Override
-    public void run(ApplicationArguments args) {
-        if (!properties.isEnabled() || !properties.isStartupRunEnabled()) {
-            return;
-        }
-
-        int requestedLimit = properties.getStartupRunLimit();
-        log.info("Wave 1 / Milestone A startup audit enabled - scanning legacy TED data with limit {}",
-                requestedLimit > 0 ? requestedLimit : "unbounded");
-        legacyTedAuditService.executeAudit(requestedLimit);
-    }
-}
--- a/src/main/java/at/procon/dip/normalization/impl/ChunkedLongTextRepresentationBuilder.java
+++ b/src/main/java/at/procon/dip/normalization/impl/ChunkedLongTextRepresentationBuilder.java
@ -6,9 +6,7 @@ import at.procon.dip.domain.document.RepresentationType;
 import at.procon.dip.normalization.spi.RepresentationBuildRequest;
 import at.procon.dip.normalization.spi.TextRepresentationBuilder;
 import at.procon.dip.normalization.spi.TextRepresentationDraft;
-import at.procon.dip.search.config.DipSearchProperties;
-import at.procon.dip.runtime.condition.ConditionalOnRuntimeMode;
-import at.procon.dip.runtime.config.RuntimeMode;
+import at.procon.ted.config.TedProcessorProperties;
 import java.util.ArrayList;
 import java.util.List;
 import lombok.RequiredArgsConstructor;
@ -23,7 +21,7 @@ public class ChunkedLongTextRepresentationBuilder implements TextRepresentationB

    public static final String BUILDER_KEY = "long-text-chunker";

-    private final DipSearchProperties properties;
+    private final TedProcessorProperties properties;

    @Override
    public boolean supports(DocumentType documentType) {
@ -32,7 +30,7 @@ public class ChunkedLongTextRepresentationBuilder implements TextRepresentationB

    @Override
    public List<TextRepresentationDraft> build(RepresentationBuildRequest request) {
-        if (!properties.isChunkingEnabled()) {
+        if (!properties.getSearch().isChunkingEnabled()) {
            return List.of();
        }

@ -44,8 +42,8 @@ public class ChunkedLongTextRepresentationBuilder implements TextRepresentationB
            return List.of();
        }

-        int target = Math.max(400, properties.getChunkTargetChars());
-        int overlap = Math.max(0, Math.min(target / 3, properties.getChunkOverlapChars()));
+        int target = Math.max(400, properties.getSearch().getChunkTargetChars());
+        int overlap = Math.max(0, Math.min(target / 3, properties.getSearch().getChunkOverlapChars()));
        if (baseText.length() <= target + overlap) {
            return List.of();
        }
@ -53,7 +51,7 @@ public class ChunkedLongTextRepresentationBuilder implements TextRepresentationB
        List<TextRepresentationDraft> drafts = new ArrayList<>();
        int start = 0;
        int chunkIndex = 0;
-        while (start < baseText.length() && chunkIndex < properties.getMaxChunksPerDocument()) {
+        while (start < baseText.length() && chunkIndex < properties.getSearch().getMaxChunksPerDocument()) {
            int end = Math.min(baseText.length(), start + target);
            if (end < baseText.length()) {
                int boundary = findBoundary(baseText, end, Math.min(baseText.length(), end + 160));
--- a/src/main/java/at/procon/dip/processing/impl/TedStructuredDocumentProcessor.java
+++ b/src/main/java/at/procon/dip/processing/impl/TedStructuredDocumentProcessor.java
@ -13,8 +13,6 @@ import at.procon.dip.ingestion.spi.SourceDescriptor;
 import at.procon.dip.processing.spi.DocumentProcessingPolicy;
 import at.procon.dip.processing.spi.StructuredDocumentProcessor;
 import at.procon.dip.processing.spi.StructuredProcessingRequest;
-import at.procon.dip.runtime.condition.ConditionalOnRuntimeMode;
-import at.procon.dip.runtime.config.RuntimeMode;
 import at.procon.ted.model.entity.ProcurementDocument;
 import at.procon.ted.service.XmlParserService;
 import java.nio.charset.StandardCharsets;
@ -27,7 +25,6 @@ import org.springframework.stereotype.Component;
 import org.springframework.util.StringUtils;

@Component
-@ConditionalOnRuntimeMode(RuntimeMode.NEW)
@RequiredArgsConstructor
@Slf4j
 public class TedStructuredDocumentProcessor implements StructuredDocumentProcessor {
--- a/src/main/java/at/procon/dip/runtime/condition/RuntimeModeCondition.java
+++ b/src/main/java/at/procon/dip/runtime/condition/RuntimeModeCondition.java
@ -1,18 +1,12 @@
 package at.procon.dip.runtime.condition;

 import at.procon.dip.runtime.config.RuntimeMode;
-import org.springframework.boot.context.properties.bind.Binder;
-import org.springframework.context.EnvironmentAware;
+import java.util.Map;
 import org.springframework.context.annotation.Condition;
 import org.springframework.context.annotation.ConditionContext;
-import org.springframework.core.env.Environment;
 import org.springframework.core.type.AnnotatedTypeMetadata;

-import java.util.Map;
-
-public class RuntimeModeCondition implements Condition, EnvironmentAware {
-
-    private Environment environment;
+public class RuntimeModeCondition implements Condition {

    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
@ -31,9 +25,4 @@ public class RuntimeModeCondition implements Condition, EnvironmentAware {
        }
        return actual == expected;
    }
-
-    @Override
-    public void setEnvironment(Environment environment) {
-        this.environment = environment;
-    }
 }
--- a/src/main/java/at/procon/dip/search/config/DipSearchProperties.java
+++ b/src/main/java/at/procon/dip/search/config/DipSearchProperties.java
@ -1,81 +1,49 @@
 package at.procon.dip.search.config;

-import jakarta.validation.constraints.Min;
-import jakarta.validation.constraints.Positive;
 import lombok.Data;
 import org.springframework.boot.context.properties.ConfigurationProperties;
 import org.springframework.context.annotation.Configuration;
-import org.springframework.validation.annotation.Validated;

-/**
- * New-runtime generic search configuration.
- *
- * <p>This property tree is intentionally separated from the legacy
- * {@code ted.search.*} settings. NEW-mode search/semantic/lexical code should
- * depend on {@code dip.search.*} only.</p>
- */
@Configuration
@ConfigurationProperties(prefix = "dip.search")
@Data
-@Validated
 public class DipSearchProperties {

-    /** Default page size for search results. */
-    @Positive
-    private int defaultPageSize = 20;
-
-    /** Maximum allowed page size. */
-    @Positive
-    private int maxPageSize = 100;
-
-    /** Semantic similarity threshold (normalized score). */
-    private double similarityThreshold = 0.7d;
-
-    /** Minimum trigram similarity for fuzzy lexical matches. */
-    private double trigramSimilarityThreshold = 0.12d;
-
-    /** Candidate limits per search engine before fusion/collapse. */
-    @Positive
-    private int fulltextCandidateLimit = 120;
-
-    @Positive
-    private int trigramCandidateLimit = 120;
-
-    @Positive
-    private int semanticCandidateLimit = 120;
-
-    /** Hybrid fusion weights. */
-    private double fulltextWeight = 0.35d;
-    private double trigramWeight = 0.20d;
-    private double semanticWeight = 0.45d;
-
-    /** Enable chunk representations for long documents. */
-    private boolean chunkingEnabled = true;
-
-    /** Target chunk size in characters for CHUNK representations. */
-    @Positive
-    private int chunkTargetChars = 1800;
-
-    /** Overlap between consecutive chunks in characters. */
-    @Min(0)
-    private int chunkOverlapChars = 200;
-
-    /** Maximum CHUNK representations generated per document. */
-    @Positive
-    private int maxChunksPerDocument = 12;
-
-    /** Additional score weight for recency. */
-    private double recencyBoostWeight = 0.05d;
-
-    /** Half-life in days used for recency decay. */
-    @Positive
-    private int recencyHalfLifeDays = 30;
-
-    /** Startup backfill limit for missing DOC lexical vectors. */
-    @Positive
-    private int startupLexicalBackfillLimit = 500;
-
-    /** Number of hits per engine returned by the debug endpoint. */
-    @Positive
-    private int debugTopHitsPerEngine = 10;
+    private Lexical lexical = new Lexical();
+    private Semantic semantic = new Semantic();
+    private Fusion fusion = new Fusion();
+    private Chunking chunking = new Chunking();
+
+    @Data
+    public static class Lexical {
+        private double trigramSimilarityThreshold = 0.12;
+        private int fulltextCandidateLimit = 120;
+        private int trigramCandidateLimit = 120;
+    }
+
+    @Data
+    public static class Semantic {
+        private double similarityThreshold = 0.7;
+        private int semanticCandidateLimit = 120;
+        private String defaultModelKey;
+    }
+
+    @Data
+    public static class Fusion {
+        private double fulltextWeight = 0.35;
+        private double trigramWeight = 0.20;
+        private double semanticWeight = 0.45;
+        private double recencyBoostWeight = 0.05;
+        private int recencyHalfLifeDays = 30;
+        private int debugTopHitsPerEngine = 10;
+    }
+
+    @Data
+    public static class Chunking {
+        private boolean enabled = true;
+        private int targetChars = 1800;
+        private int overlapChars = 200;
+        private int maxChunksPerDocument = 12;
+        private int startupLexicalBackfillLimit = 500;
+    }
 }
--- a/src/main/java/at/procon/dip/search/engine/fulltext/PostgresFullTextSearchEngine.java
+++ b/src/main/java/at/procon/dip/search/engine/fulltext/PostgresFullTextSearchEngine.java
@ -5,20 +5,17 @@ import at.procon.dip.search.dto.SearchEngineType;
 import at.procon.dip.search.dto.SearchHit;
 import at.procon.dip.search.engine.SearchEngine;
 import at.procon.dip.search.repository.DocumentFullTextSearchRepository;
-import at.procon.dip.search.config.DipSearchProperties;
-import at.procon.dip.runtime.condition.ConditionalOnRuntimeMode;
-import at.procon.dip.runtime.config.RuntimeMode;
+import at.procon.ted.config.TedProcessorProperties;
 import java.util.List;
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Component;

@Component
-@ConditionalOnRuntimeMode(RuntimeMode.NEW)
@RequiredArgsConstructor
 public class PostgresFullTextSearchEngine implements SearchEngine {

    private final DocumentFullTextSearchRepository repository;
-    private final DipSearchProperties properties;
+    private final TedProcessorProperties properties;

    @Override
    public SearchEngineType type() {
@ -32,6 +29,6 @@ public class PostgresFullTextSearchEngine implements SearchEngine {

    @Override
    public List<SearchHit> execute(SearchExecutionContext context) {
-        return repository.search(context, properties.getFulltextCandidateLimit());
+        return repository.search(context, properties.getSearch().getFulltextCandidateLimit());
    }
 }
--- a/src/main/java/at/procon/dip/search/engine/semantic/PgVectorSemanticSearchEngine.java
+++ b/src/main/java/at/procon/dip/search/engine/semantic/PgVectorSemanticSearchEngine.java
@ -9,23 +9,23 @@ import at.procon.dip.search.dto.SearchHit;
 import at.procon.dip.search.engine.SearchEngine;
 import at.procon.dip.search.repository.DocumentSemanticSearchRepository;
 import at.procon.dip.search.service.SemanticQueryEmbeddingService;
-import at.procon.dip.search.config.DipSearchProperties;
-import at.procon.dip.runtime.condition.ConditionalOnRuntimeMode;
-import at.procon.dip.runtime.config.RuntimeMode;
+import at.procon.ted.config.TedProcessorProperties;
 import java.util.List;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Component;
+import at.procon.dip.runtime.condition.ConditionalOnRuntimeMode;
+import at.procon.dip.runtime.config.RuntimeMode;

@Component
-@ConditionalOnRuntimeMode(RuntimeMode.NEW)
@RequiredArgsConstructor
@Slf4j
+@ConditionalOnRuntimeMode(RuntimeMode.NEW)
 public class PgVectorSemanticSearchEngine implements SearchEngine {

    private final EmbeddingProperties embeddingProperties;
    private final EmbeddingModelRegistry embeddingModelRegistry;
-    private final DipSearchProperties properties;
+    private final TedProcessorProperties properties;
    private final SemanticQueryEmbeddingService queryEmbeddingService;
    private final DocumentSemanticSearchRepository repository;

@ -56,8 +56,8 @@ public class PgVectorSemanticSearchEngine implements SearchEngine {
                        model.dimensions(),
                        model.distanceMetric(),
                        query.vectorString(),
-                        properties.getSemanticCandidateLimit(),
-                        properties.getSimilarityThreshold()))
+                        properties.getSearch().getSemanticCandidateLimit(),
+                        properties.getSearch().getSimilarityThreshold()))
                .orElseGet(() -> {
                    log.debug("Semantic search skipped because query embedding could not be generated for model {}", model.modelKey());
                    return List.of();
--- a/src/main/java/at/procon/dip/search/engine/trigram/PostgresTrigramSearchEngine.java
+++ b/src/main/java/at/procon/dip/search/engine/trigram/PostgresTrigramSearchEngine.java
@ -5,20 +5,17 @@ import at.procon.dip.search.dto.SearchEngineType;
 import at.procon.dip.search.dto.SearchHit;
 import at.procon.dip.search.engine.SearchEngine;
 import at.procon.dip.search.repository.DocumentTrigramSearchRepository;
-import at.procon.dip.search.config.DipSearchProperties;
-import at.procon.dip.runtime.condition.ConditionalOnRuntimeMode;
-import at.procon.dip.runtime.config.RuntimeMode;
+import at.procon.ted.config.TedProcessorProperties;
 import java.util.List;
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Component;

@Component
-@ConditionalOnRuntimeMode(RuntimeMode.NEW)
@RequiredArgsConstructor
 public class PostgresTrigramSearchEngine implements SearchEngine {

    private final DocumentTrigramSearchRepository repository;
-    private final DipSearchProperties properties;
+    private final TedProcessorProperties properties;

    @Override
    public SearchEngineType type() {
@ -34,7 +31,7 @@ public class PostgresTrigramSearchEngine implements SearchEngine {
    public List<SearchHit> execute(SearchExecutionContext context) {
        return repository.search(
                context,
-                properties.getTrigramCandidateLimit(),
-                properties.getTrigramSimilarityThreshold());
+                properties.getSearch().getTrigramCandidateLimit(),
+                properties.getSearch().getTrigramSimilarityThreshold());
    }
 }
--- a/src/main/java/at/procon/dip/search/rank/DefaultSearchResultFusionService.java
+++ b/src/main/java/at/procon/dip/search/rank/DefaultSearchResultFusionService.java
@ -7,9 +7,7 @@ import at.procon.dip.search.dto.SearchEngineType;
 import at.procon.dip.search.dto.SearchHit;
 import at.procon.dip.search.dto.SearchResponse;
 import at.procon.dip.search.dto.SearchSortMode;
-import at.procon.dip.search.config.DipSearchProperties;
-import at.procon.dip.runtime.condition.ConditionalOnRuntimeMode;
-import at.procon.dip.runtime.config.RuntimeMode;
+import at.procon.ted.config.TedProcessorProperties;
 import java.util.ArrayList;
 import java.util.Comparator;
 import java.util.EnumMap;
@ -22,12 +20,11 @@ import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Component;

@Component
-@ConditionalOnRuntimeMode(RuntimeMode.NEW)
@RequiredArgsConstructor
 public class DefaultSearchResultFusionService implements SearchResultFusionService {

    private final SearchScoreNormalizer normalizer;
-    private final DipSearchProperties properties;
+    private final TedProcessorProperties properties;

    @Override
    public SearchResponse fuse(SearchExecutionContext context,
@ -100,7 +97,7 @@ public class DefaultSearchResultFusionService implements SearchResultFusionServi
        if (hit == null) {
            return 0.0d;
        }
-        DipSearchProperties search = properties;
+        TedProcessorProperties.SearchProperties search = properties.getSearch();
        return switch (engineType) {
            case POSTGRES_FULLTEXT -> hit.getNormalizedScore() * search.getFulltextWeight();
            case POSTGRES_TRIGRAM -> hit.getNormalizedScore() * search.getTrigramWeight();
@ -113,9 +110,9 @@ public class DefaultSearchResultFusionService implements SearchResultFusionServi
        normalized.forEach((engine, hits) -> {
            for (SearchHit hit : hits) {
                double finalScore = switch (engine) {
-                    case POSTGRES_FULLTEXT -> hit.getNormalizedScore() * properties.getFulltextWeight();
-                    case POSTGRES_TRIGRAM -> hit.getNormalizedScore() * properties.getTrigramWeight();
-                    case PGVECTOR_SEMANTIC -> hit.getNormalizedScore() * properties.getSemanticWeight();
+                    case POSTGRES_FULLTEXT -> hit.getNormalizedScore() * properties.getSearch().getFulltextWeight();
+                    case POSTGRES_TRIGRAM -> hit.getNormalizedScore() * properties.getSearch().getTrigramWeight();
+                    case PGVECTOR_SEMANTIC -> hit.getNormalizedScore() * properties.getSearch().getSemanticWeight();
                };
                merged.add(hit.toBuilder()
                        .finalScore(finalScore + recencyBoost(hit))
@ -141,13 +138,13 @@ public class DefaultSearchResultFusionService implements SearchResultFusionServi
    }

    private double recencyBoost(SearchHit hit) {
-        if (properties.getRecencyBoostWeight() <= 0.0d || hit.getCreatedAt() == null) {
+        if (properties.getSearch().getRecencyBoostWeight() <= 0.0d || hit.getCreatedAt() == null) {
            return 0.0d;
        }
-        double halfLifeDays = Math.max(1.0d, properties.getRecencyHalfLifeDays());
+        double halfLifeDays = Math.max(1.0d, properties.getSearch().getRecencyHalfLifeDays());
        double ageDays = Math.max(0.0d, java.time.Duration.between(hit.getCreatedAt(), java.time.OffsetDateTime.now()).toSeconds() / 86400.0d);
        double normalized = Math.exp(-Math.log(2.0d) * (ageDays / halfLifeDays));
-        return normalized * properties.getRecencyBoostWeight();
+        return normalized * properties.getSearch().getRecencyBoostWeight();
    }

    private int representationPriority(SearchHit hit) {
--- a/src/main/java/at/procon/dip/search/repository/DocumentSemanticSearchRepository.java
+++ b/src/main/java/at/procon/dip/search/repository/DocumentSemanticSearchRepository.java
@ -33,7 +33,7 @@ public class DocumentSemanticSearchRepository {
            throw new IllegalArgumentException("Semantic search requires a distance metric");
        }

-        String vectorType = "vector(" + modelDimensions + ")";
+        String vectorType = "public.vector(" + modelDimensions + ")";
        String similarityExpr = buildSimilarityExpression(distanceMetric, vectorType);

        StringBuilder sql = new StringBuilder("""
--- a/src/main/java/at/procon/dip/search/service/DefaultSearchOrchestrator.java
+++ b/src/main/java/at/procon/dip/search/service/DefaultSearchOrchestrator.java
@ -12,9 +12,7 @@ import at.procon.dip.search.engine.SearchEngine;
 import at.procon.dip.search.plan.SearchPlanner;
 import at.procon.dip.search.rank.SearchResultFusionService;
 import at.procon.dip.search.spi.SearchDocumentScope;
-import at.procon.dip.search.config.DipSearchProperties;
-import at.procon.dip.runtime.condition.ConditionalOnRuntimeMode;
-import at.procon.dip.runtime.config.RuntimeMode;
+import at.procon.ted.config.TedProcessorProperties;
 import java.util.ArrayList;
 import java.util.LinkedHashMap;
 import java.util.List;
@ -23,11 +21,10 @@ import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Service;

@Service
-@ConditionalOnRuntimeMode(RuntimeMode.NEW)
@RequiredArgsConstructor
 public class DefaultSearchOrchestrator implements SearchOrchestrator {

-    private final DipSearchProperties properties;
+    private final TedProcessorProperties properties;
    private final SearchPlanner planner;
    private final List<SearchEngine> engines;
    private final SearchResultFusionService fusionService;
@ -48,7 +45,7 @@ public class DefaultSearchOrchestrator implements SearchOrchestrator {
        metricsService.recordSearch(execution.engineResults(), fused.getHits().size(), true);

        List<SearchEngineDebugResult> debugResults = new ArrayList<>();
-        int topLimit = properties.getDebugTopHitsPerEngine();
+        int topLimit = properties.getSearch().getDebugTopHitsPerEngine();
        execution.engineResults().forEach((engine, hits) -> debugResults.add(SearchEngineDebugResult.builder()
                .engineType(engine)
                .hitCount(hits.size())
@ -71,9 +68,9 @@ public class DefaultSearchOrchestrator implements SearchOrchestrator {
    private SearchExecution executeInternal(SearchRequest request, SearchDocumentScope scope) {
        int page = request.getPage() == null || request.getPage() < 0 ? 0 : request.getPage();
        int requestedSize = request.getSize() == null || request.getSize() <= 0
-                ? properties.getDefaultPageSize()
+                ? properties.getSearch().getDefaultPageSize()
                : request.getSize();
-        int size = Math.min(requestedSize, properties.getMaxPageSize());
+        int size = Math.min(requestedSize, properties.getSearch().getMaxPageSize());

        SearchExecutionContext context = SearchExecutionContext.builder()
                .request(request)
--- a/src/main/java/at/procon/dip/search/service/SearchLexicalIndexStartupRunner.java
+++ b/src/main/java/at/procon/dip/search/service/SearchLexicalIndexStartupRunner.java
@ -1,8 +1,6 @@
 package at.procon.dip.search.service;

-import at.procon.dip.search.config.DipSearchProperties;
-import at.procon.dip.runtime.condition.ConditionalOnRuntimeMode;
-import at.procon.dip.runtime.config.RuntimeMode;
+import at.procon.ted.config.TedProcessorProperties;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.boot.ApplicationArguments;
@ -10,17 +8,16 @@ import org.springframework.boot.ApplicationRunner;
 import org.springframework.stereotype.Component;

@Component
-@ConditionalOnRuntimeMode(RuntimeMode.NEW)
@RequiredArgsConstructor
@Slf4j
 public class SearchLexicalIndexStartupRunner implements ApplicationRunner {

-    private final DipSearchProperties properties;
+    private final TedProcessorProperties properties;
    private final DocumentLexicalIndexService lexicalIndexService;

    @Override
    public void run(ApplicationArguments args) {
-        int updated = lexicalIndexService.backfillMissingVectors(properties.getStartupLexicalBackfillLimit());
+        int updated = lexicalIndexService.backfillMissingVectors(properties.getSearch().getStartupLexicalBackfillLimit());
        if (updated > 0) {
            log.info("Search lexical index startup backfill updated {} representations", updated);
        }
--- a/src/main/java/at/procon/dip/vectorization/camel/GenericVectorizationRoute.java
+++ b/src/main/java/at/procon/dip/vectorization/camel/GenericVectorizationRoute.java
@ -2,13 +2,8 @@ package at.procon.dip.vectorization.camel;

 import at.procon.dip.domain.document.EmbeddingStatus;
 import at.procon.dip.domain.document.repository.DocumentEmbeddingRepository;
-import at.procon.dip.runtime.condition.ConditionalOnRuntimeMode;
-import at.procon.dip.runtime.config.RuntimeMode;
 import at.procon.dip.vectorization.service.DocumentEmbeddingProcessingService;
-import at.procon.ted.config.LegacyVectorizationProperties;
 import com.fasterxml.jackson.annotation.JsonProperty;
-import java.util.List;
-import java.util.UUID;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.camel.Exchange;
@ -18,22 +13,27 @@ import org.apache.camel.model.dataformat.JsonLibrary;
 import org.springframework.data.domain.PageRequest;
 import org.springframework.stereotype.Component;

+import at.procon.ted.config.TedProcessorProperties;
+import at.procon.dip.runtime.condition.ConditionalOnRuntimeMode;
+import at.procon.dip.runtime.config.RuntimeMode;
+import java.util.List;
+import java.util.UUID;
+
 /**
- * Legacy generic vectorization route.
- * Uses DOC.doc_text_representation as the source text and DOC.doc_embedding as the write target
- * but belongs to the old runtime graph and is therefore activated only in LEGACY mode.
+ * Phase 2 generic vectorization route.
+ * Uses DOC.doc_text_representation as the source text and DOC.doc_embedding as the write target.
 */
@Component
-@ConditionalOnRuntimeMode(RuntimeMode.LEGACY)
@RequiredArgsConstructor
@Slf4j
+@ConditionalOnRuntimeMode(RuntimeMode.LEGACY)
 public class GenericVectorizationRoute extends RouteBuilder {

    private static final String ROUTE_ID_TRIGGER = "generic-vectorization-trigger";
    private static final String ROUTE_ID_PROCESSOR = "generic-vectorization-processor";
    private static final String ROUTE_ID_SCHEDULER = "generic-vectorization-scheduler";

-    private final LegacyVectorizationProperties properties;
+    private final TedProcessorProperties properties;
    private final DocumentEmbeddingRepository embeddingRepository;
    private final DocumentEmbeddingProcessingService processingService;

@ -52,95 +52,163 @@ public class GenericVectorizationRoute extends RouteBuilder {

    @Override
    public void configure() {
-        if (!properties.isEnabled() || !properties.isGenericPipelineEnabled()) {
+        if (!properties.getVectorization().isEnabled() || !properties.getVectorization().isGenericPipelineEnabled()) {
            log.info("Phase 2 generic vectorization route disabled");
            return;
        }

-        log.info("Configuring generic vectorization routes (legacy mode, apiUrl={}, scheduler={}ms)",
-                properties.getApiUrl(),
-                properties.getGenericSchedulerPeriodMs());
+        log.info("Configuring generic vectorization routes (phase2=true, apiUrl={}, scheduler={}ms)",
+                properties.getVectorization().getApiUrl(),
+                properties.getVectorization().getGenericSchedulerPeriodMs());

        onException(Exception.class)
                .handled(true)
                .process(exchange -> {
                    UUID embeddingId = exchange.getIn().getHeader("embeddingId", UUID.class);
                    Exception exception = exchange.getProperty(Exchange.EXCEPTION_CAUGHT, Exception.class);
-                    log.error("Generic vectorization failed for embedding {}: {}", embeddingId,
-                            exception != null ? exception.getMessage() : "unknown error", exception);
+                    String error = exception != null ? exception.getMessage() : "Unknown vectorization error";
                    if (embeddingId != null) {
-                        processingService.markAsFailed(embeddingId,
-                                exception != null ? exception.getMessage() : "Unknown vectorization error");
+                        try {
+                            processingService.markAsFailed(embeddingId, error);
+                        } catch (Exception nested) {
+                            log.warn("Failed to mark embedding {} as failed: {}", embeddingId, nested.getMessage());
+                        }
                    }
                })
-                .log(LoggingLevel.WARN, "Generic vectorization exception handled for ${header.embeddingId}");
+                .to("log:generic-vectorization-error?level=WARN");

        from("direct:vectorize-embedding")
                .routeId(ROUTE_ID_TRIGGER)
-                .setHeader("embeddingId", header("embeddingId"))
-                .to("seda:vectorize-embedding-async");
+                .doTry()
+                    .to("seda:vectorize-embedding-async?waitForTaskToComplete=Never&size=1000&blockWhenFull=true&timeout=5000")
+                .doCatch(Exception.class)
+                    .log(LoggingLevel.WARN, "Failed to queue embedding ${header.embeddingId}: ${exception.message}")
+                .end();

-        from("seda:vectorize-embedding-async?concurrentConsumers=1&blockWhenFull=true&size=1000")
+        from("seda:vectorize-embedding-async?size=1000")
                .routeId(ROUTE_ID_PROCESSOR)
                .threads().executorService(executorService())
                .process(exchange -> {
                    UUID embeddingId = exchange.getIn().getHeader("embeddingId", UUID.class);
-                    if (embeddingId == null) {
-                        exchange.setProperty(Exchange.ROUTE_STOP, Boolean.TRUE);
-                        return;
-                    }
-
                    DocumentEmbeddingProcessingService.EmbeddingPayload payload =
                            processingService.prepareEmbeddingForVectorization(embeddingId);
                    if (payload == null) {
-                        exchange.setProperty(Exchange.ROUTE_STOP, Boolean.TRUE);
+                        exchange.setProperty("skipVectorization", true);
                        return;
                    }
-                    exchange.getIn().setBody(payload);
-                })
-                .filter(exchangeProperty(Exchange.ROUTE_STOP).isNull())
-                .process(exchange -> {
-                    DocumentEmbeddingProcessingService.EmbeddingPayload payload =
-                            exchange.getIn().getBody(DocumentEmbeddingProcessingService.EmbeddingPayload.class);
-                    VectorizationRequest request = new VectorizationRequest(payload.textContent(), false);
+
+                    EmbedRequest request = new EmbedRequest();
+                    request.text = payload.textContent();
+                    request.isQuery = false;
+
+                    exchange.getIn().setHeader("embeddingId", payload.embeddingId());
+                    exchange.getIn().setHeader("documentId", payload.documentId());
+                    exchange.getIn().setHeader(Exchange.HTTP_METHOD, "POST");
+                    exchange.getIn().setHeader(Exchange.CONTENT_TYPE, "application/json");
                    exchange.getIn().setBody(request);
                })
-                .marshal().json(JsonLibrary.Jackson)
-                .removeHeaders("CamelHttp*")
-                .setHeader(Exchange.HTTP_METHOD, constant("POST"))
-                .setHeader(Exchange.CONTENT_TYPE, constant("application/json"))
-                .toD(properties.getApiUrl() + "/embed?bridgeEndpoint=true&throwExceptionOnFailure=true")
-                .unmarshal().json(JsonLibrary.Jackson, VectorizationResponse.class)
-                .process(exchange -> {
-                    UUID embeddingId = exchange.getIn().getHeader("embeddingId", UUID.class);
-                    VectorizationResponse response = exchange.getIn().getBody(VectorizationResponse.class);
-                    if (response == null || response.embedding() == null) {
-                        throw new IllegalStateException("Embedding service returned empty response");
-                    }
-                    processingService.saveEmbedding(embeddingId, response.embedding(), response.tokenCount());
-                });
+                .choice()
+                    .when(exchangeProperty("skipVectorization").isEqualTo(true))
+                        .log(LoggingLevel.DEBUG, "Skipping generic vectorization for ${header.embeddingId}")
+                    .otherwise()
+                        .marshal().json(JsonLibrary.Jackson)
+                        .setProperty("retryCount", constant(0))
+                        .setProperty("maxRetries", constant(properties.getVectorization().getMaxRetries()))
+                        .setProperty("vectorizationSuccess", constant(false))
+                        .loopDoWhile(simple("${exchangeProperty.vectorizationSuccess} == false && ${exchangeProperty.retryCount} < ${exchangeProperty.maxRetries}"))
+                            .process(exchange -> {
+                                Integer retryCount = exchange.getProperty("retryCount", Integer.class);
+                                exchange.setProperty("retryCount", retryCount + 1);
+                                if (retryCount > 0) {
+                                    long backoffMs = (long) Math.pow(2, retryCount) * 1000L;
+                                    Thread.sleep(backoffMs);
+                                }
+                            })
+                            .doTry()
+                                .toD(properties.getVectorization().getApiUrl() + "/embed?bridgeEndpoint=true&throwExceptionOnFailure=false&connectTimeout=" +
+                                        properties.getVectorization().getConnectTimeout() + "&socketTimeout=" +
+                                        properties.getVectorization().getSocketTimeout())
+                                .process(exchange -> {
+                                    Integer statusCode = exchange.getIn().getHeader(Exchange.HTTP_RESPONSE_CODE, Integer.class);
+                                    if (statusCode == null || statusCode != 200) {
+                                        String body = exchange.getIn().getBody(String.class);
+                                        throw new RuntimeException("Embedding service returned HTTP " + statusCode + ": " + body);
+                                    }
+                                })
+                                .unmarshal().json(JsonLibrary.Jackson, EmbedResponse.class)
+                                .process(exchange -> {
+                                    UUID embeddingId = exchange.getIn().getHeader("embeddingId", UUID.class);
+                                    EmbedResponse response = exchange.getIn().getBody(EmbedResponse.class);
+                                    if (response == null || response.embedding == null) {
+                                        throw new RuntimeException("Embedding service returned null embedding response");
+                                    }
+                                    processingService.saveEmbedding(embeddingId, response.embedding, response.tokenCount);
+                                    exchange.setProperty("vectorizationSuccess", true);
+                                })
+                            .doCatch(Exception.class)
+                                .process(exchange -> {
+                                    UUID embeddingId = exchange.getIn().getHeader("embeddingId", UUID.class);
+                                    Integer retryCount = exchange.getProperty("retryCount", Integer.class);
+                                    Integer maxRetries = exchange.getProperty("maxRetries", Integer.class);
+                                    Exception exception = exchange.getProperty(Exchange.EXCEPTION_CAUGHT, Exception.class);
+                                    String errorMsg = exception != null ? exception.getMessage() : "Unknown error";
+                                    if (errorMsg != null && errorMsg.contains("Connection pool shut down")) {
+                                        log.warn("Generic vectorization aborted for {} because the application is shutting down", embeddingId);
+                                        exchange.setProperty("vectorizationSuccess", true);
+                                        return;
+                                    }
+                                    if (retryCount >= maxRetries) {
+                                        processingService.markAsFailed(embeddingId, errorMsg);
+                                    } else {
+                                        log.warn("Generic vectorization attempt #{} failed for {}: {}", retryCount, embeddingId, errorMsg);
+                                    }
+                                })
+                            .end()
+                        .end()
+                .end();

-        from("timer:generic-vectorization-poller?period=" + properties.getGenericSchedulerPeriodMs())
+        from("timer:generic-vectorization-scheduler?period=" + properties.getVectorization().getGenericSchedulerPeriodMs() + "&delay=500")
                .routeId(ROUTE_ID_SCHEDULER)
                .process(exchange -> {
-                    List<UUID> ids = embeddingRepository.findIdsByEmbeddingStatus(
-                            EmbeddingStatus.PENDING, PageRequest.of(0, properties.getBatchSize()));
-                    exchange.getIn().setBody(ids);
+                    int batchSize = properties.getVectorization().getBatchSize();
+                    List<UUID> pending = embeddingRepository.findIdsByEmbeddingStatus(EmbeddingStatus.PENDING, PageRequest.of(0, batchSize));
+                    List<UUID> failed = List.of();
+                    if (pending.isEmpty()) {
+                        failed = embeddingRepository.findIdsByEmbeddingStatus(EmbeddingStatus.FAILED, PageRequest.of(0, batchSize));
+                    }
+                    List<UUID> toProcess = !pending.isEmpty() ? pending : failed;
+                    if (toProcess.isEmpty()) {
+                        exchange.setProperty("noPendingEmbeddings", true);
+                    } else {
+                        exchange.getIn().setBody(toProcess);
+                    }
                })
-                .split(body())
-                .setHeader("embeddingId", body())
-                .to("direct:vectorize-embedding");
+                .choice()
+                    .when(exchangeProperty("noPendingEmbeddings").isEqualTo(true))
+                        .log(LoggingLevel.DEBUG, "Generic vectorization scheduler: nothing pending")
+                    .otherwise()
+                        .split(body())
+                            .process(exchange -> {
+                                UUID embeddingId = exchange.getIn().getBody(UUID.class);
+                                exchange.getIn().setHeader("embeddingId", embeddingId);
+                            })
+                            .to("direct:vectorize-embedding")
+                        .end()
+                .end();
    }

-    public record VectorizationRequest(
-            @JsonProperty("text") String text,
-            @JsonProperty("isQuery") boolean isQuery
-    ) {
+    public static class EmbedRequest {
+        @JsonProperty("text")
+        public String text;
+
+        @JsonProperty("is_query")
+        public boolean isQuery;
    }

-    public record VectorizationResponse(
-            @JsonProperty("embedding") float[] embedding,
-            @JsonProperty("token_count") Integer tokenCount
-    ) {
+    public static class EmbedResponse {
+        public float[] embedding;
+        public int dimensions;
+        @JsonProperty("token_count")
+        public int tokenCount;
    }
 }
--- a/src/main/java/at/procon/dip/vectorization/service/DocumentEmbeddingProcessingService.java
+++ b/src/main/java/at/procon/dip/vectorization/service/DocumentEmbeddingProcessingService.java
@ -1,20 +1,16 @@
 package at.procon.dip.vectorization.service;

-
 import at.procon.dip.domain.document.DocumentStatus;
 import at.procon.dip.domain.document.EmbeddingStatus;
 import at.procon.dip.domain.document.entity.DocumentEmbedding;
 import at.procon.dip.domain.document.repository.DocumentEmbeddingRepository;
 import at.procon.dip.domain.document.service.DocumentService;
-
-import at.procon.dip.runtime.condition.ConditionalOnRuntimeMode;
-import at.procon.dip.runtime.config.RuntimeMode;
-import at.procon.ted.config.LegacyVectorizationProperties;
-
+import at.procon.ted.config.TedProcessorProperties;
 import at.procon.ted.model.entity.VectorizationStatus;
 import at.procon.ted.repository.ProcurementDocumentRepository;
 import at.procon.ted.service.VectorizationService;
-
+import at.procon.dip.runtime.condition.ConditionalOnRuntimeMode;
+import at.procon.dip.runtime.config.RuntimeMode;
 import java.time.OffsetDateTime;
 import java.util.UUID;
 import lombok.RequiredArgsConstructor;
@ -24,21 +20,21 @@ import org.springframework.transaction.annotation.Propagation;
 import org.springframework.transaction.annotation.Transactional;

 /**
- * Legacy generic vectorization processor that works on DOC text representations and DOC embeddings.
+ * Phase 2 generic vectorization processor that works on DOC text representations and DOC embeddings.
 * <p>
 * The service keeps the existing TED semantic search operational by optionally dual-writing completed
 * embeddings back into the legacy TED procurement_document vector columns, resolved by document hash.
 */
@Service
-@ConditionalOnRuntimeMode(RuntimeMode.LEGACY)
@RequiredArgsConstructor
@Slf4j
+@ConditionalOnRuntimeMode(RuntimeMode.LEGACY)
 public class DocumentEmbeddingProcessingService {

    private final DocumentEmbeddingRepository embeddingRepository;
    private final DocumentService documentService;
    private final VectorizationService vectorizationService;
-    private final LegacyVectorizationProperties properties;
+    private final TedProcessorProperties properties;
    private final ProcurementDocumentRepository procurementDocumentRepository;

    @Transactional(propagation = Propagation.REQUIRES_NEW)
@ -65,7 +61,7 @@ public class DocumentEmbeddingProcessingService {
            return null;
        }

-        int maxLength = properties.getMaxTextLength();
+        int maxLength = properties.getVectorization().getMaxTextLength();
        if (textBody.length() > maxLength) {
            log.debug("Truncating representation {} for embedding {} from {} to {} chars",
                    embedding.getRepresentation().getId(), embeddingId, textBody.length(), maxLength);
@ -95,10 +91,10 @@ public class DocumentEmbeddingProcessingService {
        }

        String vectorString = vectorizationService.floatArrayToVectorString(embedding);
-        embeddingRepository.updateEmbeddingVector(embeddingId, embedding, tokenCount, embedding.length);
+        embeddingRepository.updateEmbeddingVector(embeddingId, vectorString, tokenCount, embedding.length);
        documentService.updateStatus(loaded.getDocument().getId(), DocumentStatus.INDEXED);

-        if (properties.isDualWriteLegacyTedVectors()) {
+        if (properties.getVectorization().isDualWriteLegacyTedVectors()) {
            dualWriteLegacyTedVector(loaded, vectorString, tokenCount);
        }
    }
@ -111,7 +107,8 @@ public class DocumentEmbeddingProcessingService {
        embeddingRepository.updateEmbeddingStatus(embeddingId, EmbeddingStatus.FAILED, errorMessage, null);
        documentService.updateStatus(loaded.getDocument().getId(), DocumentStatus.FAILED);

-        if (properties.isDualWriteLegacyTedVectors()) {
+        if (properties.getVectorization().isDualWriteLegacyTedVectors()) {
+            loaded.getDocument().getDedupHash();
            procurementDocumentRepository.findByDocumentHash(loaded.getDocument().getDedupHash())
                    .ifPresent(doc -> procurementDocumentRepository.updateVectorizationStatus(
                            doc.getId(), VectorizationStatus.FAILED, errorMessage, null));
--- a/src/main/java/at/procon/dip/vectorization/startup/ConfiguredEmbeddingModelStartupRunner.java
+++ b/src/main/java/at/procon/dip/vectorization/startup/ConfiguredEmbeddingModelStartupRunner.java
@ -2,9 +2,9 @@ package at.procon.dip.vectorization.startup;

 import at.procon.dip.domain.document.service.DocumentEmbeddingService;
 import at.procon.dip.domain.document.service.command.RegisterEmbeddingModelCommand;
+import at.procon.ted.config.TedProcessorProperties;
 import at.procon.dip.runtime.condition.ConditionalOnRuntimeMode;
 import at.procon.dip.runtime.config.RuntimeMode;
-import at.procon.ted.config.LegacyVectorizationProperties;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.boot.ApplicationArguments;
@ -12,33 +12,33 @@ import org.springframework.boot.ApplicationRunner;
 import org.springframework.stereotype.Component;

 /**
- * Ensures the configured embedding model exists in DOC.doc_embedding_model for the legacy runtime path.
+ * Ensures the configured embedding model exists in DOC.doc_embedding_model.
 */
@Component
-@ConditionalOnRuntimeMode(RuntimeMode.LEGACY)
@RequiredArgsConstructor
@Slf4j
+@ConditionalOnRuntimeMode(RuntimeMode.LEGACY)
 public class ConfiguredEmbeddingModelStartupRunner implements ApplicationRunner {

-    private final LegacyVectorizationProperties properties;
+    private final TedProcessorProperties properties;
    private final DocumentEmbeddingService embeddingService;

    @Override
    public void run(ApplicationArguments args) {
-        if (!properties.isEnabled() || !properties.isGenericPipelineEnabled()) {
+        if (!properties.getVectorization().isEnabled() || !properties.getVectorization().isGenericPipelineEnabled()) {
            return;
        }

        embeddingService.registerModel(new RegisterEmbeddingModelCommand(
-                properties.getModelName(),
-                properties.getEmbeddingProvider(),
-                properties.getModelName(),
-                properties.getDimensions(),
+                properties.getVectorization().getModelName(),
+                properties.getVectorization().getEmbeddingProvider(),
+                properties.getVectorization().getModelName(),
+                properties.getVectorization().getDimensions(),
                null,
                false,
                true
        ));

-        log.info("Legacy embedding model ensured: {}", properties.getModelName());
+        log.info("Phase 2 embedding model ensured: {}", properties.getVectorization().getModelName());
    }
 }
--- a/src/main/java/at/procon/dip/vectorization/startup/GenericVectorizationStartupRunner.java
+++ b/src/main/java/at/procon/dip/vectorization/startup/GenericVectorizationStartupRunner.java
@ -2,9 +2,9 @@ package at.procon.dip.vectorization.startup;

 import at.procon.dip.domain.document.EmbeddingStatus;
 import at.procon.dip.domain.document.repository.DocumentEmbeddingRepository;
+import at.procon.ted.config.TedProcessorProperties;
 import at.procon.dip.runtime.condition.ConditionalOnRuntimeMode;
 import at.procon.dip.runtime.config.RuntimeMode;
-import at.procon.ted.config.LegacyVectorizationProperties;
 import java.util.List;
 import java.util.UUID;
 import lombok.RequiredArgsConstructor;
@ -16,30 +16,30 @@ import org.springframework.data.domain.PageRequest;
 import org.springframework.stereotype.Component;

 /**
- * Queues pending and failed DOC embeddings immediately on startup for the legacy runtime graph.
+ * Queues pending and failed DOC embeddings immediately on startup.
 */
@Component
-@ConditionalOnRuntimeMode(RuntimeMode.LEGACY)
@RequiredArgsConstructor
@Slf4j
+@ConditionalOnRuntimeMode(RuntimeMode.LEGACY)
 public class GenericVectorizationStartupRunner implements ApplicationRunner {

    private static final int BATCH_SIZE = 1000;

-    private final LegacyVectorizationProperties properties;
+    private final TedProcessorProperties properties;
    private final DocumentEmbeddingRepository embeddingRepository;
    private final ProducerTemplate producerTemplate;

    @Override
    public void run(ApplicationArguments args) {
-        if (!properties.isEnabled() || !properties.isGenericPipelineEnabled()) {
+        if (!properties.getVectorization().isEnabled() || !properties.getVectorization().isGenericPipelineEnabled()) {
            return;
        }

        int queued = 0;
        queued += queueByStatus(EmbeddingStatus.PENDING, "PENDING");
        queued += queueByStatus(EmbeddingStatus.FAILED, "FAILED");
-        log.info("Legacy generic vectorization startup runner queued {} embedding jobs", queued);
+        log.info("Generic vectorization startup runner queued {} embedding jobs", queued);
    }

    private int queueByStatus(EmbeddingStatus status, String label) {
--- a/src/main/java/at/procon/ted/camel/MailRoute.java
+++ b/src/main/java/at/procon/ted/camel/MailRoute.java
@ -13,8 +13,6 @@ import jakarta.mail.Multipart;
 import jakarta.mail.Part;
 import jakarta.mail.Session;
 import jakarta.mail.internet.MimeMessage;
-import at.procon.dip.runtime.condition.ConditionalOnRuntimeMode;
-import at.procon.dip.runtime.config.RuntimeMode;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.camel.Exchange;
@ -47,7 +45,6 @@ import java.util.*;
 * @author Martin.Schweitzer@procon.co.at and claude.ai
 */
@Component
-@ConditionalOnRuntimeMode(RuntimeMode.LEGACY)
@RequiredArgsConstructor
@Slf4j
 public class MailRoute extends RouteBuilder {
--- a/src/main/java/at/procon/ted/camel/SolutionBriefRoute.java
+++ b/src/main/java/at/procon/ted/camel/SolutionBriefRoute.java
@ -4,8 +4,6 @@ import at.procon.ted.config.TedProcessorProperties;
 import at.procon.ted.service.ExcelExportService;
 import at.procon.ted.service.SimilaritySearchService;
 import at.procon.ted.service.SimilaritySearchService.SimilaritySearchResponse;
-import at.procon.dip.runtime.condition.ConditionalOnRuntimeMode;
-import at.procon.dip.runtime.config.RuntimeMode;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.camel.Exchange;
@ -29,7 +27,6 @@ import java.nio.file.Paths;
 * @author Martin.Schweitzer@procon.co.at and claude.ai
 */
@Component
-@ConditionalOnRuntimeMode(RuntimeMode.LEGACY)
@RequiredArgsConstructor
@Slf4j
 public class SolutionBriefRoute extends RouteBuilder {
--- a/src/main/java/at/procon/ted/camel/TedDocumentRoute.java
+++ b/src/main/java/at/procon/ted/camel/TedDocumentRoute.java
@ -2,8 +2,6 @@ package at.procon.ted.camel;

 import at.procon.ted.config.TedProcessorProperties;
 import at.procon.ted.service.DocumentProcessingService;
-import at.procon.dip.runtime.condition.ConditionalOnRuntimeMode;
-import at.procon.dip.runtime.config.RuntimeMode;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.camel.Exchange;
@ -26,7 +24,6 @@ import java.nio.file.Path;
 * @author Martin.Schweitzer@procon.co.at and claude.ai
 */
@Component
-@ConditionalOnRuntimeMode(RuntimeMode.LEGACY)
@RequiredArgsConstructor
@Slf4j
 public class TedDocumentRoute extends RouteBuilder {
--- a/src/main/java/at/procon/ted/camel/TedPackageDownloadCamelRoute.java
+++ b/src/main/java/at/procon/ted/camel/TedPackageDownloadCamelRoute.java
@ -9,8 +9,6 @@ import at.procon.ted.model.entity.TedDailyPackage;
 import at.procon.ted.repository.TedDailyPackageRepository;
 import at.procon.ted.service.BatchDocumentProcessingService;
 import at.procon.ted.service.TedPackageDownloadService;
-import at.procon.dip.runtime.condition.ConditionalOnRuntimeMode;
-import at.procon.dip.runtime.config.RuntimeMode;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.camel.Exchange;
@ -49,7 +47,6 @@ import java.util.Optional;
@ConditionalOnProperty(name = "ted.download.enabled", havingValue = "true")
@RequiredArgsConstructor
@Slf4j
-@ConditionalOnRuntimeMode(RuntimeMode.LEGACY)
 public class TedPackageDownloadCamelRoute extends RouteBuilder {

    private static final String ROUTE_ID_SCHEDULER = "ted-package-scheduler";
--- a/src/main/java/at/procon/ted/camel/TedPackageDownloadRoute.java
+++ b/src/main/java/at/procon/ted/camel/TedPackageDownloadRoute.java
@ -2,8 +2,6 @@ package at.procon.ted.camel;

 import at.procon.ted.config.TedProcessorProperties;
 import at.procon.ted.service.TedPackageDownloadService;
-import at.procon.dip.runtime.condition.ConditionalOnRuntimeMode;
-import at.procon.dip.runtime.config.RuntimeMode;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.camel.Exchange;
@ -32,7 +30,6 @@ import java.util.List;
@ConditionalOnProperty(name = "ted.download.use-service-based", havingValue = "true")
@RequiredArgsConstructor
@Slf4j
-@ConditionalOnRuntimeMode(RuntimeMode.LEGACY)
 public class TedPackageDownloadRoute extends RouteBuilder {

    private static final String ROUTE_ID_SCHEDULER = "ted-package-download-scheduler";
--- a/src/main/java/at/procon/ted/camel/VectorizationRoute.java
+++ b/src/main/java/at/procon/ted/camel/VectorizationRoute.java
@ -7,8 +7,6 @@ import at.procon.ted.repository.ProcurementDocumentRepository;
 import at.procon.ted.service.VectorizationProcessorService;
 import com.fasterxml.jackson.annotation.JsonProperty;
 import com.fasterxml.jackson.databind.ObjectMapper;
-import at.procon.dip.runtime.condition.ConditionalOnRuntimeMode;
-import at.procon.dip.runtime.config.RuntimeMode;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.camel.Exchange;
@ -33,7 +31,6 @@ import java.util.UUID;
 * @author Martin.Schweitzer@procon.co.at and claude.ai
 */
@Component
-@ConditionalOnRuntimeMode(RuntimeMode.LEGACY)
@RequiredArgsConstructor
@Slf4j
 public class VectorizationRoute extends RouteBuilder {
@ -71,6 +68,10 @@ public class VectorizationRoute extends RouteBuilder {
            log.info("Vectorization is disabled, skipping route configuration");
            return;
        }
+        if (properties.getVectorization().isGenericPipelineEnabled()) {
+            log.info("Legacy vectorization route disabled because Phase 2 generic pipeline is enabled");
+            return;
+        }

        log.info("Configuring vectorization routes (enabled=true, apiUrl={}, connectTimeout={}ms, socketTimeout={}ms, maxRetries={}, scheduler every 6s)",
                properties.getVectorization().getApiUrl(),
--- a/src/main/java/at/procon/ted/config/AsyncConfig.java
+++ b/src/main/java/at/procon/ted/config/AsyncConfig.java
@ -1,7 +1,5 @@
 package at.procon.ted.config;

-import at.procon.dip.runtime.condition.ConditionalOnRuntimeMode;
-import at.procon.dip.runtime.config.RuntimeMode;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.aop.interceptor.AsyncUncaughtExceptionHandler;
@ -21,7 +19,6 @@ import java.util.concurrent.Executor;
 * @author Martin.Schweitzer@procon.co.at and claude.ai
 */
@Configuration
-@ConditionalOnRuntimeMode(RuntimeMode.LEGACY)
@EnableAsync
@RequiredArgsConstructor
@Slf4j
--- a/src/main/java/at/procon/ted/config/LegacyTedProperties.java
+++ b/src/main/java/at/procon/ted/config/LegacyTedProperties.java
@ -0,0 +1,16 @@
+package at.procon.ted.config;
+
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.context.annotation.Configuration;
+
+/**
+ * Patch A scaffold for the legacy runtime configuration tree.
+ *
+ * The legacy runtime still uses {@link TedProcessorProperties} today. This class is
+ * introduced so the old configuration can be moved gradually from `ted.*` to
+ * `legacy.ted.*` without blocking the runtime split.
+ */
+@Configuration
+@ConfigurationProperties(prefix = "legacy.ted")
+public class LegacyTedProperties extends TedProcessorProperties {
+}
--- a/src/main/java/at/procon/ted/config/LegacyVectorizationProperties.java
+++ b/src/main/java/at/procon/ted/config/LegacyVectorizationProperties.java
@ -1,115 +0,0 @@
-package at.procon.ted.config;
-
-import jakarta.validation.constraints.Min;
-import jakarta.validation.constraints.NotBlank;
-import jakarta.validation.constraints.Positive;
-import lombok.Data;
-import org.springframework.boot.context.properties.ConfigurationProperties;
-import org.springframework.context.annotation.Configuration;
-import org.springframework.validation.annotation.Validated;
-
-/**
- * Legacy vectorization configuration used only by the old runtime path.
- * <p>
- * This extracts the former ted.vectorization.* subtree away from TedProcessorProperties
- * so that legacy vectorization beans no longer depend on the shared monolithic config.
- */
-@Configuration
-@ConfigurationProperties(prefix = "legacy.ted.vectorization")
-@Data
-@Validated
-public class LegacyVectorizationProperties {
-
-    /**
-     * Enable/disable legacy async vectorization.
-     */
-    private boolean enabled = true;
-
-    /**
-     * Use external HTTP API instead of Python subprocess.
-     */
-    private boolean useHttpApi = false;
-
-    /**
-     * Embedding service HTTP API URL.
-     */
-    private String apiUrl = "http://localhost:8001";
-
-    /**
-     * Sentence transformer model name.
-     */
-    private String modelName = "intfloat/multilingual-e5-large";
-
-    /**
-     * Vector dimensions (must match model output).
-     */
-    @Positive
-    private int dimensions = 1024;
-
-    /**
-     * Batch size for vectorization processing.
-     */
-    @Min(1)
-    private int batchSize = 16;
-
-    /**
-     * Thread pool size for async vectorization.
-     */
-    @Min(1)
-    private int threadPoolSize = 4;
-
-    /**
-     * Maximum text length for vectorization (characters).
-     */
-    @Positive
-    private int maxTextLength = 8192;
-
-    /**
-     * HTTP connection timeout in milliseconds.
-     */
-    @Positive
-    private int connectTimeout = 10000;
-
-    /**
-     * HTTP socket/read timeout in milliseconds.
-     */
-    @Positive
-    private int socketTimeout = 60000;
-
-    /**
-     * Maximum retries on connection failure.
-     */
-    @Min(0)
-    private int maxRetries = 5;
-
-    /**
-     * Enable the former Phase 2 generic pipeline in the legacy runtime.
-     * In the split runtime design this should normally stay false in NEW mode
-     * because legacy beans are not instantiated there.
-     */
-    private boolean genericPipelineEnabled = true;
-
-    /**
-     * Keep writing completed TED embeddings back to the legacy ted.procurement_document
-     * vector columns so the existing semantic search stays operational during migration.
-     */
-    private boolean dualWriteLegacyTedVectors = true;
-
-    /**
-     * Scheduler interval for generic embedding polling (milliseconds).
-     */
-    @Positive
-    private long genericSchedulerPeriodMs = 6000;
-
-    /**
-     * Builder key for the primary TED semantic representation created during transitional dual-write.
-     */
-    @NotBlank
-    private String primaryRepresentationBuilderKey = "ted-phase2-primary-representation";
-
-    /**
-     * Provider key used when registering the configured embedding model in DOC.doc_embedding_model.
-     */
-    @NotBlank
-    private String embeddingProvider = "http-embedding-service";
-}
--- a/src/main/java/at/procon/ted/config/TedProcessorProperties.java
+++ b/src/main/java/at/procon/ted/config/TedProcessorProperties.java
@ -1,11 +1,8 @@
 package at.procon.ted.config;

-import at.procon.dip.runtime.condition.ConditionalOnRuntimeMode;
-import at.procon.dip.runtime.config.RuntimeMode;
 import lombok.Data;
 import org.springframework.boot.context.properties.ConfigurationProperties;
 import org.springframework.context.annotation.Configuration;
-import org.springframework.context.annotation.Primary;
 import org.springframework.validation.annotation.Validated;

 import jakarta.validation.constraints.Min;
@ -18,11 +15,9 @@ import jakarta.validation.constraints.Positive;
 * @author Martin.Schweitzer@procon.co.at and claude.ai
 */
@Configuration
-@ConditionalOnRuntimeMode(RuntimeMode.LEGACY)
@ConfigurationProperties(prefix = "ted")
@Data
@Validated
-@Primary
 public class TedProcessorProperties {

    private InputProperties input = new InputProperties();
@ -34,7 +29,6 @@ public class TedProcessorProperties {
    private SolutionBriefProperties solutionBrief = new SolutionBriefProperties();
    private ProjectionProperties projection = new ProjectionProperties();
    private GenericIngestionProperties genericIngestion = new GenericIngestionProperties();
-    private RepairProperties repair = new RepairProperties();

    /**
     * Input directory configuration for Apache Camel file consumer.
@ -160,9 +154,37 @@ public class TedProcessorProperties {
         */
        @Min(0)
        private int maxRetries = 5;
-       @Positive
-        private long genericSchedulerPeriodMs = 30000;
-        private String primaryRepresentationBuilderKey = "default-generic";
+
+        /**
+         * Enable the Phase 2 generic vectorization pipeline based on DOC text representations
+         * and DOC embeddings instead of the legacy TED document vector columns as the primary
+         * write target.
+         */
+        private boolean genericPipelineEnabled = true;
+
+        /**
+         * Keep writing completed TED embeddings back to the legacy ted.procurement_document
+         * vector columns so the existing semantic search stays operational during migration.
+         */
+        private boolean dualWriteLegacyTedVectors = true;
+
+        /**
+         * Scheduler interval for generic embedding polling (milliseconds).
+         */
+        @Positive
+        private long genericSchedulerPeriodMs = 6000;
+
+        /**
+         * Builder key for the primary TED semantic representation created during Phase 2 dual-write.
+         */
+        @NotBlank
+        private String primaryRepresentationBuilderKey = "ted-phase2-primary-representation";
+
+        /**
+         * Provider key used when registering the configured embedding model in DOC.doc_embedding_model.
+         */
+        @NotBlank
+        private String embeddingProvider = "http-embedding-service";
    }

    /**
@ -357,64 +379,6 @@ public class TedProcessorProperties {
        private boolean prioritizeCurrentYear = true;
    }

-    /**
-     * Legacy TED package repair / re-import configuration.
-     */
-    @Data
-    public static class RepairProperties {
-
-        /**
-         * Enable startup repair of incomplete or missing TED packages.
-         */
-        private boolean enabled = false;
-
-        /**
-         * If true, only logs the selected package candidates without modifying data.
-         */
-        private boolean dryRun = false;
-
-        /**
-         * Maximum number of packages to process in one startup run.
-         */
-        @Positive
-        private int maxPackages = 100;
-
-        /**
-         * Optional explicit package identifiers (YYYYSSSSS) to repair.
-         */
-        private java.util.List<String> packageIdentifiers = new java.util.ArrayList<>();
-
-        /**
-         * Optional lower bound package identifier (inclusive).
-         */
-        private String fromPackageIdentifier;
-
-        /**
-         * Optional upper bound package identifier (inclusive).
-         */
-        private String toPackageIdentifier;
-
-        /**
-         * Include missing package sequence numbers inside the selected range.
-         */
-        private boolean includeMissingSequenceGaps = true;
-
-        /**
-         * Re-download the package archive when it is missing locally.
-         */
-        private boolean redownloadMissingArchives = true;
-
-        /**
-         * Always re-download the package archive even when a local archive already exists.
-         */
-        private boolean forceRedownload = false;
-
-        /**
-         * Refuse startup repair while the automatic legacy package download scheduler is enabled.
-         */
-        private boolean allowWhileDownloadEnabled = false;
-    }
-
    /**
     * IMAP Mail configuration for email processing.
     */
--- a/src/main/java/at/procon/ted/controller/AdminController.java
+++ b/src/main/java/at/procon/ted/controller/AdminController.java
@ -10,8 +10,6 @@ import at.procon.ted.service.DocumentProcessingService;
 import at.procon.ted.service.VectorizationService;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.tags.Tag;
-import at.procon.dip.runtime.condition.ConditionalOnRuntimeMode;
-import at.procon.dip.runtime.config.RuntimeMode;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.camel.ProducerTemplate;
@ -37,7 +35,6 @@ import java.util.UUID;
 * @author Martin.Schweitzer@procon.co.at and claude.ai
 */
@RestController
-@ConditionalOnRuntimeMode(RuntimeMode.LEGACY)
@RequestMapping("/v1/admin")
@RequiredArgsConstructor
@Slf4j
@ -78,12 +75,18 @@ public class AdminController {
        Map<String, Object> status = new HashMap<>();
        
        Map<String, Long> statusCounts = new HashMap<>();
-        List<Object[]> counts = documentRepository.countByVectorizationStatus();
-        for (Object[] row : counts) {
-            statusCounts.put(((VectorizationStatus) row[0]).name(), (Long) row[1]);
+        if (properties.getVectorization().isGenericPipelineEnabled()) {
+            List<Object[]> counts = documentEmbeddingRepository.countByEmbeddingStatus();
+            for (Object[] row : counts) {
+                statusCounts.put(((EmbeddingStatus) row[0]).name(), (Long) row[1]);
+            }
+        } else {
+            List<Object[]> counts = documentRepository.countByVectorizationStatus();
+            for (Object[] row : counts) {
+                statusCounts.put(((VectorizationStatus) row[0]).name(), (Long) row[1]);
+            }
        }
        
-        
        status.put("counts", statusCounts);
        status.put("serviceAvailable", vectorizationService.isAvailable());
        status.put("timestamp", OffsetDateTime.now());
@ -112,7 +115,14 @@ public class AdminController {
            return ResponseEntity.badRequest().body(result);
        }

-        producerTemplate.sendBodyAndHeader("direct:vectorize", null, "documentId", documentId);
+        if (properties.getVectorization().isGenericPipelineEnabled()) {
+            var document = documentRepository.findById(documentId).orElseThrow();
+            UUID embeddingId = tedPhase2GenericDocumentService.registerOrRefreshTedDocument(document);
+            producerTemplate.sendBodyAndHeader("direct:vectorize-embedding", null, "embeddingId", embeddingId);
+            result.put("embeddingId", embeddingId);
+        } else {
+            producerTemplate.sendBodyAndHeader("direct:vectorize", null, "documentId", documentId);
+        }

        result.put("success", true);
        result.put("message", "Vectorization triggered for document " + documentId);
@ -137,13 +147,23 @@ public class AdminController {
        }

        int count = 0;
-        var pending = documentRepository.findByVectorizationStatus(
-                VectorizationStatus.PENDING,
-                PageRequest.of(0, Math.min(batchSize, 500)));
-
-        for (var doc : pending) {
-            producerTemplate.sendBodyAndHeader("direct:vectorize", null, "documentId", doc.getId());
-            count++;
+        if (properties.getVectorization().isGenericPipelineEnabled()) {
+            var pending = documentEmbeddingRepository.findIdsByEmbeddingStatus(
+                    EmbeddingStatus.PENDING,
+                    PageRequest.of(0, Math.min(batchSize, 500)));
+            for (UUID embeddingId : pending) {
+                producerTemplate.sendBodyAndHeader("direct:vectorize-embedding", null, "embeddingId", embeddingId);
+                count++;
+            }
+        } else {
+            var pending = documentRepository.findByVectorizationStatus(
+                    VectorizationStatus.PENDING,
+                    PageRequest.of(0, Math.min(batchSize, 500)));
+
+            for (var doc : pending) {
+                producerTemplate.sendBodyAndHeader("direct:vectorize", null, "documentId", doc.getId());
+                count++;
+            }
        }

        result.put("success", true);
--- a/src/main/java/at/procon/ted/controller/DocumentController.java
+++ b/src/main/java/at/procon/ted/controller/DocumentController.java
@ -1,7 +1,5 @@
 package at.procon.ted.controller;

-import at.procon.dip.runtime.condition.ConditionalOnRuntimeMode;
-import at.procon.dip.runtime.config.RuntimeMode;
 import at.procon.ted.model.dto.DocumentDtos.*;
 import at.procon.ted.model.entity.ContractNature;
 import at.procon.ted.model.entity.NoticeType;
@ -40,7 +38,6 @@ import java.util.UUID;
@RequestMapping("/v1/documents")
@RequiredArgsConstructor
@Slf4j
-@ConditionalOnRuntimeMode(RuntimeMode.LEGACY)
@Tag(name = "Documents", description = "TED Procurement Document Search API")
 public class DocumentController {

--- a/src/main/java/at/procon/ted/controller/SimilaritySearchController.java
+++ b/src/main/java/at/procon/ted/controller/SimilaritySearchController.java
@ -1,7 +1,5 @@
 package at.procon.ted.controller;

-import at.procon.dip.runtime.condition.ConditionalOnRuntimeMode;
-import at.procon.dip.runtime.config.RuntimeMode;
 import at.procon.ted.service.SimilaritySearchService;
 import at.procon.ted.service.SimilaritySearchService.SimilaritySearchResponse;
 import io.swagger.v3.oas.annotations.Operation;
@ -30,7 +28,6 @@ import java.io.IOException;
@RequestMapping("/similarity")
@RequiredArgsConstructor
@Slf4j
-@ConditionalOnRuntimeMode(RuntimeMode.LEGACY)
@Tag(name = "Similarity Search", description = "Vector-based semantic similarity search on TED procurement documents")
 public class SimilaritySearchController {

--- a/src/main/java/at/procon/ted/event/VectorizationEventListener.java
+++ b/src/main/java/at/procon/ted/event/VectorizationEventListener.java
@ -1,8 +1,6 @@
 package at.procon.ted.event;

 import at.procon.ted.config.TedProcessorProperties;
-import at.procon.dip.runtime.condition.ConditionalOnRuntimeMode;
-import at.procon.dip.runtime.config.RuntimeMode;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.camel.ProducerTemplate;
@ -17,7 +15,6 @@ import org.springframework.transaction.event.TransactionalEventListener;
 * @author Martin.Schweitzer@procon.co.at and claude.ai
 */
@Component
-@ConditionalOnRuntimeMode(RuntimeMode.LEGACY)
@RequiredArgsConstructor
@Slf4j
 public class VectorizationEventListener {
@ -31,7 +28,7 @@ public class VectorizationEventListener {
     */
    @TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
    public void onDocumentSaved(DocumentSavedEvent event) {
-        if (!properties.getVectorization().isEnabled()) {
+        if (!properties.getVectorization().isEnabled() || properties.getVectorization().isGenericPipelineEnabled()) {
            return;
        }

--- a/src/main/java/at/procon/ted/model/entity/Organization.java
+++ b/src/main/java/at/procon/ted/model/entity/Organization.java
@ -58,7 +58,7 @@ public class Organization {
    @Column(name = "country_code", length = 10)
    private String countryCode;

-    @Column(name = "city", columnDefinition = "TEXT")
+    @Column(name = "city", length = 255)
    private String city;

    @Column(name = "postal_code", length = 255)
--- a/src/main/java/at/procon/ted/model/entity/ProcurementDocument.java
+++ b/src/main/java/at/procon/ted/model/entity/ProcurementDocument.java
@ -102,7 +102,7 @@ public class ProcurementDocument {
    @Column(name = "buyer_country_code", length = 10)
    private String buyerCountryCode;

-    @Column(name = "buyer_city", columnDefinition = "TEXT")
+    @Column(name = "buyer_city", length = 255)
    private String buyerCity;

    @Column(name = "buyer_postal_code", length = 100)
@ -124,7 +124,7 @@ public class ProcurementDocument {
    @Column(name = "project_description", columnDefinition = "TEXT")
    private String projectDescription;

-    @Column(name = "internal_reference", columnDefinition = "TEXT")
+    @Column(name = "internal_reference", length = 500)
    private String internalReference;

    @Enumerated(EnumType.STRING)
--- a/Show More
+++ b/Show More