conductor-oss/conductor

This system is a workflow orchestration engine that manages the execution of complex, multi-step processes through a declarative definition of tasks and dependencies. It provides a robust backend for scheduling, state persistence, and event-driven triggers, supporting a wide variety of storage backends including relational databases, Redis, and cloud object storage. The platform also integrates modern agent-based workflows, allowing external AI agents to participate in and drive process execution via standardized protocols.

68 changes.

This period focused on modernizing the Conductor codebase by migrating to Java 21, replacing legacy Jersey and Servo dependencies with Spring Boot and Micrometer, and adopting Protobuf serialization for core models. It introduced a new gRPC interface for high-performance client-server communication and expanded workflow capabilities with new system tasks, eventing features, and external payload storage. The work also involved significant architectural refactoring, including the removal of legacy persistence modules and the implementation of a dedicated service layer for core operations.

57 changes.

This period focused on migrating the Conductor codebase to Spring Boot, standardizing configuration and dependency injection across persistence, REST, and core modules. It introduced comprehensive support for multiple database backends including PostgreSQL, MySQL, and Cassandra, alongside new external storage options for AWS S3 and Azure Blob. The work also expanded the system's capabilities with new indexing via Elasticsearch 7, extensible script evaluation, and robust distributed locking and concurrency controls.

82 changes.

This period focused on expanding Conductor's infrastructure by introducing SQLite and Redis as new persistence backends, while splitting OpenSearch and Elasticsearch indexing into version-specific modules. Simultaneously, the project integrated Agent-to-Agent (A2A) protocols, added a workflow scheduler, and launched the ui-next frontend scaffolding to support these new capabilities.

Introduces a new AMQP event queue implementation for Conductor, allowing it to consume events from RabbitMQ. The change adds configuration properties under \conductor.event-queues.amqp\ to control connection details, retry patterns, and message processing behavior. It supports both standard queues and exchanges; when using an exchange, message acknowledgment is correctly skipped as it is not applicable, whereas queue-based consumption retains standard ack semantics. The implementation includes Spring Boot auto-configuration via \AMQPEventQueueConfiguration\ and provides both sequential and event-driven message processing modes.

amqp · high confidence

This change introduces the ability to store large JSON payloads and general files in an AWS S3 bucket. For external payloads, the system now supports an S3 backend (configured via \conductor.external-payload-storage.type=s3\) using the AWS SDK for Java v2, allowing users to specify the bucket name, region, and signed URL expiration duration. Additionally, a new generic file storage feature is added (enabled via \conductor.file-storage.enabled=true\ and \conductor.file-storage.type=s3\), which provides S3-backed capabilities for generating pre-signed upload/download URLs, handling multipart uploads, and retrieving file metadata. Configuration properties for both features are registered in \S3Properties\ and \S3FileStorageProperties\ respectively.

awss3-storage/src · high confidence

Conductor now supports Azure Blob Storage as a backend for external payload and file storage. Users can enable this by setting \conductor.external-payload-storage.type=azureblob\ to store large workflow and task payloads, or \conductor.file-storage.enabled=true\ with \conductor.file-storage.type=azure-blob\ for general file storage. Configuration is handled via Spring Boot properties (e.g., \conductor.external-payload-storage.azureblob.\\ and \conductor.file-storage.azure-blob.\\), allowing users to specify connection strings, endpoints, SAS tokens, container names, and path prefixes. The implementation uses the Azure Storage Blob SDK to generate pre-signed SAS URLs for secure read/write access.

azureblob-storage/src · high confidence

Conductor now supports Kafka as an event queue provider for WAIT tasks. This change introduces a new \KafkaEventQueueProvider\ and \KafkaObservableQueue\ implementation, allowing users to enable the feature by setting \conductor.event-queues.kafka.enabled=true\ and \conductor.default-event-queue.type=kafka\. The implementation handles message consumption from Kafka topics, constructs messages with keys and headers, and supports dynamic queue creation for different task statuses (COMPLETED, FAILED). Configuration is managed via \KafkaEventQueueProperties\, allowing customization of bootstrap servers, polling intervals, and consumer/producer settings.

kafka-event-queue/src · high confidence

This change introduces new event queue providers for NATS and NATS JetStream, allowing Conductor to use these systems for task event handling. The NATS implementation adds basic pub/sub support via \NATSObservableQueue\, while the JetStream implementation (\JetStreamObservableQueue\) provides durable, stream-backed queuing with configurable properties such as stream storage type, replicas, and acknowledgment settings. A key behavioral fix ensures JetStream stream names are correctly sanitized by replacing dots with underscores, preventing issues with dot-separated subjects. The integration includes Spring configuration classes to enable the providers via properties (\conductor.event-queues.nats.enabled\ and \conductor.event-queues.jsm.enabled\) and adds error handling and logging for connection issues.

nats · high confidence

Conductor now supports NATS and NATS Streaming (STAN) as event queue backends. Users can enable the standard NATS queue via \conductor.event-queues.nats.enabled\ and the NATS Streaming queue via \conductor.event-queues.nats-stream.enabled\, configuring connection details, cluster IDs, and durable names through the \conductor.event-queues.nats-stream\ properties. This adds the \nats\ and \nats\_stream\ queue types, allowing workflows to publish and consume messages from these brokers.

nats-streaming · high confidence

The new \os-persistence-v2\ module enables indexing workflows and tasks against OpenSearch 2.x clusters using the \opensearch-java 2.18.0\ client. Users can enable this backend by setting \conductor.indexing.type=opensearch2\, which registers a dedicated \IndexDAO\ implementation (\OpenSearchRestDAO\) and supports basic authentication, async indexing, and automatic index management. To allow \os-persistence-v2\ and \os-persistence-v3\ to coexist on the same classpath, the module uses the Shadow plugin to relocate OpenSearch client classes to an isolated namespace. The module also introduces a new \conductor.opensearch.\\ configuration namespace while maintaining backward compatibility with the legacy \conductor.elasticsearch.\\ properties, logging a deprecation warning when the old keys are detected.

os-persistence-v2 · high confidence

Introduces a new PostgreSQL-based external payload storage module for Conductor, allowing workflow and task input/output payloads exceeding configured thresholds to be offloaded to a PostgreSQL database. This module includes a Spring Boot configuration that initializes a Flyway migration to create the storage schema, a REST controller at \/api/external/postgres\ for retrieving payloads, and the underlying storage implementation with configurable retention policies (max rows, days, months, years).

postgres-external-storage · high confidence

Conductor now supports two new lock strategies for workflow execution: a local-only lock and a no-op lock. The local-only lock (activated via conductor.workflow-execution-lock.type=local\_only) uses a Caffeine cache of ReentrantLocks to manage concurrency within a single JVM instance, including support for lease expiration via a scheduled executor. The no-op lock simply ignores all lock operations, effectively disabling distributed locking. These implementations allow users to opt out of external locking mechanisms for single-node deployments or testing scenarios.

core/src/main/java/com/netflix/conductor/core/sync/local · high confidence

The scheduler module is now available in the OSS distribution, enabling users to define and manage cron-based workflow schedules via the new REST API endpoints at /api/scheduler and /api/scheduler/bulk. This includes full CRUD operations for schedules, bulk pause/resume capabilities, execution search, and admin controls. The feature is controlled by the conductor.scheduler.enabled property and supports optional external caching via Redis when conductor.scheduler.cache.enabled is set to true.

scheduler/core · high confidence

A new database migration introduces a PostgreSQL function and associated triggers that automatically emit LISTEN/NOTIFY events on the 'conductor\_queue\_state' channel whenever the 'queue\_message' table is modified. This change enables external consumers to receive real-time updates about queue depth and next delivery times without polling, supporting the experimental queue optimization.

_postgres-persistence/src/main/resources/db/migration\_postgres\notify · high confidence

A new DummyPayloadStorage class has been introduced in the core storage package to handle external payload storage when no specific external provider is configured. This implementation stores payloads as JSON files in a temporary local directory, providing a fallback mechanism for payload management within the Conductor core.

core/src/main/java/com/netflix/conductor/core/storage · high confidence

A new NoopIndexDAO and its Spring configuration have been added to the core indexing module. When the property conductor.indexing.enabled is set to false, the system now uses this dummy implementation, which performs no indexing operations and returns empty results for all search queries. This allows users to disable Elasticsearch-based search functionality entirely without removing the indexing dependency.

core/src/main/java/com/netflix/conductor/core/index · high confidence

A new pre-commit hook has been added to the repository that automatically runs the Spotless formatter via Gradle before each commit. This ensures code style consistency by applying formatting rules and staging any modified files, reducing manual effort for developers to maintain uniform code quality.

hooks · high confidence

The REST module now includes a set of sample workflow definitions (kitchensink) in the resources directory, featuring complex scenarios such as ephemeral workflows with dynamic tasks, sub-workflows, and HTTP integrations, alongside a basic sub-flow. Additionally, a static landing page (index.html) has been added to the REST API root, displaying the Conductor logo and providing direct links to the Swagger UI documentation and the user guide.

rest/src/main/resources · high confidence

Introduced the \ErrorResponse\ and \ValidationError\ classes in the common validation package to structure API error responses. \ErrorResponse\ now includes fields for status, code, message, instance, retryability, and a list of \ValidationError\ objects, while \ValidationError\ captures specific details such as the path, error message, and invalid value, enabling more detailed feedback for validation failures.

common/src/main/java/com/netflix/conductor/common/validation · high confidence

Added a new AgentSnapshotDetails component that renders detailed metadata for agent snapshots, including conductor model information, instructions, and categorized tools (Worker, HTTP, MCP, RAG, Guardrail, Sub-agent). The view also displays input and output guardrails, and for A2A agents, it shows skills and protocol capabilities. Implementation details are only shown when extension parameters advertise them. Tests verify rendering of these elements for both conductor and A2A agent types.

ui-next/src/components/features/agents · high confidence

The embedded agentspan library now supports concurrent operation with operator-configured status publishers (such as Kafka, queue, or archive publishers) by introducing composite task and workflow status listeners that fan out events to all registered listeners, preventing the library's SSE listener from shadowing external integrations. Additionally, native Conductor agents are now exposed as A2A agents through new REST endpoints at /api/a2a/agent, enabling external systems to interact with agents using the A2A protocol. The library also includes adapters for persisting skill metadata and packages through Conductor's backend-agnostic DAOs, and a refined chat completion task mapper that correctly handles sub-workflow results in conversation history.

agentspan/src/main · high confidence

This change adds the Cassandra and Redis persistence implementations for the new workflow scheduler feature. In the Cassandra module, new configuration and DAO classes create tables for schedules, executions, and archival records, enabling scheduler storage when the database type is set to Cassandra. In the Redis module, new configuration and DAO classes provide a cache layer for schedule data and a storage layer for archival execution records with configurable TTLs, activated when Redis is available and the scheduler is enabled. Both modules include corresponding auto-configuration registrations and unit tests to verify bean registration and data operations.

scheduler/cassandra-persistence, scheduler/redis-persistence, scheduler/sqlite-persistence · high confidence

The workflow-event-listener module now supports a 'composite' listener type that allows multiple workflow status listeners (Kafka, queue publisher, HTTP webhook, and archival) to run simultaneously. This change introduces a composite pattern where events are dispatched in parallel to all configured listeners, ensuring that failures or delays in one listener (e.g., Kafka being down) do not block or affect others. Users can configure this via \conductor.workflow-status-listener.type=composite\ and listing desired types in \conductor.workflow-status-listener.composite.types\, gaining independent failure domains and the ability to stream to multiple destinations (like analytics and external webhooks) concurrently.

workflow-event-listener · high confidence

This change adds the MySQL, PostgreSQL, and SQLite data-access implementations for three new domain capabilities: file metadata storage, a schema registry, and skill package management. For file metadata, the DAOs persist and query file records (including upload status, content hash, and size) linked to workflows and tasks. For the schema registry, the DAOs provide upsert, lookup, and deletion of versioned schema definitions, including optimized queries that list only schema names and versions to avoid parsing full payloads. For skill packages, the DAOs store and retrieve versioned skill metadata (with latest-version tracking) and binary skill package data (Base64-encoded). These implementations enable the underlying persistence layer to support these features across all supported database backends.

mysql-persistence/src/main/java/org, postgres-persistence/src/main/java/org, sqlite-persistence/src/main/java/org · high confidence

The common execution models have been enriched to support new operational features. Workflow executions now track aggregate token usage (prompt, completion, and total tokens) across the workflow and its sub-workflow tree via the new AggregateTokenUsage model. To handle large payloads, Workflow and TaskSummary models now include external storage path references (ExternalStorageLocation), and an extended WorkflowSummary variant (WorkflowSummaryExtended) is available to preserve input/output as structured maps for serialization. Additionally, a new WorkflowTestRequest model has been introduced to allow mocking task outputs and simulating execution conditions for testing workflows.

common/src/main/java/com/netflix/conductor/common/run · high confidence

The workflow engine now supports an extensible evaluator framework that allows expressions to be evaluated using different engines. In addition to the existing JavaScript and value-param evaluators, users can now use Python expressions (via GraalVM Polyglot) and explicitly select the GraalJS engine. This change introduces a new ConsoleBridge component to capture script logs as task execution logs, improving visibility into script execution. The default evaluator type remains JavaScript for backward compatibility, but the system is now prepared to support future engine choices through the new Evaluator interface.

core/src/main/java/com/netflix/conductor/core/execution/evaluators · high confidence

An in-memory implementation of the workflow message queue DAO has been added to support pushing messages into running workflows, serving as the default non-durable storage when Redis is not configured. Additionally, a new configuration file for end-to-end Docker tests has been introduced to set up a Redis-backed environment, enabling testing of the workflow message queue and other features against a Redis standalone instance.

core/src/main/java/com/netflix/conductor/core/dao, e2e/docker · high confidence

Adds a new end-to-end test suite for Conductor, providing convenience scripts to run tests against various backend combinations including Postgres, MySQL, Cassandra, Redis, Elasticsearch 7/8, and OpenSearch 2/3. The suite includes a comprehensive README detailing prerequisites, execution methods, and known limitations such as disabled tests for specific rerun behaviors and infrastructure constraints.

e2e · high confidence

This change introduces the complete PostgreSQL persistence implementation for Conductor, adding new DAO classes (PostgresBaseDAO, PostgresExecutionDAO, PostgresIndexDAO, PostgresLockDAO, PostgresMetadataDAO, PostgresPollDataDAO, and PostgresQueueDAO) to the postgres-persistence module. It enables users to store and retrieve workflow execution data, task definitions, metadata, and queue messages in PostgreSQL, including support for distributed locking, asynchronous indexing, and poll data caching.

postgres-persistence/src/main/java/com/netflix/conductor/postgres/dao · high confidence

This change introduces the complete set of Protocol Buffers (proto3) schema definitions for the Conductor workflow engine, located in grpc/src/main/proto/model. These files establish the data contracts for core workflow entities, including Workflow, WorkflowDef, Task, and TaskDef, as well as operational models like EventExecution, EventHandler, and ExecutionMetadata. The schemas expose key behavioral capabilities such as dynamic fork-join tasks, sub-workflow parameters, rate-limiting configurations, and event-driven actions (including agent start and workflow termination). This provides the foundational interface for gRPC communication between clients and the Conductor server.

grpc/src/main/proto/model · high confidence

This change introduces the core model and GCS-specific implementation for the new file storage feature. It adds the \FileModel\ class to track file metadata (such as ID, hash, size, and upload status) and implements the \FileStorage\ interface via \GcsFileStorage\, enabling signed URL generation for uploads/downloads and multipart upload handling. Configuration is provided through \GcsFileStorageProperties\ and \GcsFileStorageConfiguration\, allowing users to enable GCS storage by setting \conductor.file-storage.enabled=true\ and \conductor.file-storage.type=gcs\, along with specifying the bucket name, project ID, and optional credentials file.

core/src/main/java/org/conductoross/conductor/model, gcs-storage · high confidence

This change introduces several new utility classes in the common module to enhance workflow definition validation and data handling. ConstraintParamUtil now validates workflow input parameters, checking that JSON path expressions are valid and that referenced task names or environment variables exist, while skipping validation for predefined system parameters. EnvUtils provides support for resolving system and environment variables, including specific handling for task IDs. ExternalPayloadStorage defines the interface for storing large JSON payloads in external storage to manage workflow and task input/output sizes. Additionally, SummaryUtil adds configurable JSON serialization for workflow and task summaries via a new property, and TaskUtils provides helpers for managing loop task reference names and converting workflow definitions.

common/src/main/java/com/netflix/conductor/common/utils · high confidence

The file-storage module now supports a new 'conductor' storage type that persists files to a local directory on the server's filesystem. This backend is enabled via the 'conductor.file-storage.type' property and requires the 'conductor.file-storage.conductor.directory' to be configured; in multi-node deployments, this directory must be mounted on a shared filesystem accessible by all server nodes. The implementation provides atomic file writes, configurable maximum upload sizes, and optional HMAC-signed URLs for secure content access, with a new REST filter validating these signatures for the /api/files/content/ endpoint.

file-storage, rest/src/main/java/org/conductoross/conductor/filestorage · high confidence

Adds a new Elasticsearch 7-based persistence layer for indexing and searching workflow data. This change introduces the \ElasticSearchRestDAOV7\ class and supporting index management components (including thread-safe bulk request wrappers and a base DAO for query construction) within the \es7-persistence\ module, enabling Conductor to store and retrieve workflow and task information using the Elasticsearch 7 client API.

es7-persistence/src/main/java/com/netflix/conductor/es7/dao/index · high confidence

Adds a new \es8-persistence\ module that enables indexing workflows and tasks using the Elasticsearch 8.x Java client (version 8.19.11). Users can activate this backend by setting \conductor.indexing.type=elasticsearch8\ and selecting the module at build time (\-PindexingBackend=elasticsearch8\). The module implements index management using composable index templates, write aliases, and an ILM policy (defaulting to a 50GB primary shard size rollover), and provides configuration for async bulk ingestion, retry policies, and SSL/TLS authentication.

es8-persistence · high confidence

The new JSON\_JQ\_TRANSFORM task allows workflows to apply JQ expressions to JSON payloads. It caches compiled queries for performance and outputs the transformed result as both a single 'result' field and a 'resultList' array. The task correctly handles various JSON types (objects, arrays, strings, numbers, booleans) and ensures null results are preserved as null rather than being stringified. Comprehensive tests verify correct extraction of map, list, string, and null results, as well as proper error handling for invalid JQ expressions.

json-jq-task · high confidence

Adds a new SQLite-based persistence layer for Conductor workflows, activated by setting conductor.db.type=sqlite. The configuration initializes the database with WAL mode, foreign keys, and concurrency optimizations, runs Flyway migrations from classpath:db/migration\_sqlite with a baseline-0 to ensure compatibility with the scheduler, and registers beans for metadata, execution, queue, poll data, and indexing DAOs. It also provides configurable properties for task definition cache refresh, deadlock retries, async pool sizes, and conditional indexing/locking behavior.

sqlite-persistence/src/main/java/com/netflix/conductor/sqlite/config · high confidence

Adds a new utility package for the SQLite persistence module, including a fluent Query builder for parameterized SQL execution, a SqliteIndexQueryBuilder for constructing search queries with classifier support and wildcard filtering, and supporting functional interfaces (ExecuteFunction, QueryFunction, ResultSetHandler, TransactionalFunction) along with helper classes for thread naming and lazy string evaluation.

sqlite-persistence/src/main/java/com/netflix/conductor/sqlite/util · high confidence

This change adds a new environment variable abstraction layer, introducing EnvVarLookup for reading prefixed environment variables and system properties, and implementing the EnvironmentDAO interface via EnvVariableEnvironmentDAO (active by default) and NoopEnvironmentDAO (for disabling the feature). In the execution core, the legacy ApplicationException class is removed, and the ParametersUtils class is deleted, indicating a shift in how task parameters and application errors are handled. Additionally, new classes such as StartWorkflowInput, NotificationResult, and AsyncSystemTaskExecutor are introduced to consolidate workflow start inputs, manage signal notifications, and handle asynchronous system task execution with improved queue reservation and timeout logic.

core/src/main/java/com/netflix/conductor/core/execution · high confidence

This change adds the core data-transfer objects and enumerations that define the file storage API contract. It introduces the FileHandle, FileUploadRequest, FileUploadResponse, FileUploadCompleteResponse, FileDownloadUrlResponse, FileUploadUrlResponse, MultipartInitResponse, and MultipartCompleteRequest classes, which represent the request and response payloads for file upload, download, and multipart operations. It also adds the FileUploadStatus enum to track the upload lifecycle (PENDING, UPLOADING, UPLOADED, FAILED), the StorageType enum to identify the backend (S3, AZURE\_BLOB, GCS, CONDUCTOR), and the FileIdToFileHandleIdConverter utility to manage the prefixed handle format (conductor://file/\<fileId\>) used in JSON DTOs.

common/src/main/java/org/conductoross/conductor/model/file · high confidence

This change adds the core server-side implementation for the Conductor file-storage feature, replacing the deprecated local storage backend with a pluggable, server-managed storage system. The new system introduces a \FileStorageService\ that coordinates with backend providers (such as S3, Azure Blob, GCS, or the new Conductor-managed backend) to generate and verify presigned URLs for file uploads and downloads. It enforces strict access control by resolving the workflow family tree (ancestors and descendants) to ensure only authorized workflows can access files. The implementation includes configuration properties (\conductor.file-storage.\*\) to enable the feature, select the backend type, and configure HMAC-SHA256 URL signing for secure content access. It also supports multipart uploads and streaming content directly to the storage backend without buffering in the service layer.

core/src/main/java/org/conductoross/conductor/core/storage · high confidence

This change introduces the Conductor Eventing feature, adding new core components to listen to and process messages from event queues. The system now includes a default event queue provider and processor that can identify workflows and tasks via message payloads to update task statuses. Additionally, the Message model has been extended to support message priority (0-99), allowing higher priority messages to be retrieved ahead of lower priority ones.

core/src/main/java/com/netflix/conductor/core/events/queue · high confidence

This change introduces a new set of service interfaces and implementations in the core module to centralize business logic for workflows, tasks, metadata, events, and administration. Users benefit from a cleaner separation of concerns where operations like bulk workflow management (pause, resume, restart, retry, terminate, delete), task polling and updates, event handler management, and administrative tasks (such as workflow consistency repair and configuration retrieval) are now handled by dedicated service classes (e.g., WorkflowBulkService, TaskService, EventService, AdminService). This refactoring also includes the addition of an @Audit annotation for service classes and a new VersionService to expose build properties, providing a more structured and auditable foundation for Conductor's core functionalities.

core/src/main/java/com/netflix/conductor/service · high confidence

The event handling system now tracks the lifecycle of individual event processing through the new EventExecution model, which records status (IN\_PROGRESS, COMPLETED, FAILED, SKIPPED) and output for each event. Additionally, the EventHandler Action model has been extended to support a new start\_agent action type, allowing workflows to be triggered by agent-based events alongside existing capabilities like starting workflows or completing tasks.

common/src/main/java/com/netflix/conductor/common/metadata/events · high confidence

The core exception package now includes dedicated exception classes to improve error granularity and workflow management. New types include AccessForbiddenException for authorization failures, ConflictException and NotFoundException for resource state issues, and NonTransientException and TransientException to distinguish between permanent and recoverable backend errors. Additionally, TerminateWorkflowException has been added to allow workflows to be explicitly terminated with a specific status and associated task context.

core/src/main/java/com/netflix/conductor/core/exception · high confidence

This change introduces new metadata classes to support schema registry integration (SchemaDef with JSON, Avro, and Protobuf types), defines access control policies via a new Permission enum and BaseDef class for workflow and task definitions, and adds an EnvironmentVariable model for runtime configuration. Additionally, the Auditable base class now returns 0 instead of null for createTime and updateTime when unset, ensuring consistent default values for audit timestamps.

common/src/main/java/com/netflix/conductor/common/metadata · high confidence

The MySQL persistence module now provides a complete set of DAO implementations (MySQLExecutionDAO, MySQLMetadataDAO, MySQLQueueDAO) backed by MySQL, enabling users to store workflow execution state, metadata, and task queues in a MySQL database instead of relying on Redis or other backends. This change introduces the necessary database interactions, transaction management, and retry logic specific to MySQL for the Conductor workflow engine.

mysql-persistence/src/main/java/com/netflix/conductor/mysql/dao · high confidence

This update introduces a series of Flyway database migrations (V1 through V11) for the MySQL persistence layer. It establishes the foundational metadata and execution tables (V1), adds support for queue message priorities (V3) and performance-optimized indexes for correlation IDs and queue lookups (V5, V6), and refactors primary keys across multiple tables to remove auto-increment IDs in favor of natural keys (V7, V8). Additionally, it adds new tables to support file storage metadata (V9), AgentSpan skill storage (V10), and a standalone schema registry (V11), ensuring the MySQL backend can persist these new feature-specific data structures.

mysql-persistence/src/main/resources · high confidence

This change introduces the Agent-to-Agent (A2A) integration layer within the AI module, enabling Conductor workflows to interact with remote A2A agents. It adds a REST callback endpoint at /api/a2a/callback/{taskId} to receive push notifications from remote agents and complete waiting AGENT tasks, along with an /api/a2a/agent-card endpoint for discovering remote agent capabilities. The implementation includes the A2AService for managing agent communication, A2ACallbackResource for handling inbound notifications, and supporting classes for metrics (A2AMetrics), logging (A2ALogging), and result normalization (A2AResults). This allows workflows to trigger and wait for external AI agents using the A2A protocol.

ai/src/main · high confidence

This change introduces a new \awssqs-event-queue\ module that provides an AWS SQS-based implementation of the Conductor event queue. It allows users to enable SQS as the default event queue type via \conductor.default-event-queue.type=sqs\ and \conductor.event-queues.sqs.enabled=true\. The implementation supports configuring a custom SQS endpoint (useful for local testing or VPC endpoints) via \conductor.event-queues.sqs.endpoint\, uses the AWS SDK v2 \SqsClient\ instead of the legacy client, and automatically configures a default AWS credentials provider. It also includes configuration for batch size, polling interval, visibility timeout, and authorized AWS accounts for queue access policies.

awssqs-event-queue · high confidence

This change introduces a set of new data-access interfaces in the core DAO layer to support new storage capabilities: FileMetadataDAO for file upload tracking, SecretsDAO for credential management, and SkillMetadataDAO/SkillPackageDAO for Conductor-Agents skill persistence. Additionally, it adds the SchemaDAO interface and an InMemorySchemaDAO implementation that serves as a non-persistent fallback when the configured metadata backend does not provide its own schema storage, ensuring the schema registry remains functional but volatile across restarts.

core/src/main/java/org/conductoross/conductor/dao · high confidence

This change introduces a comprehensive set of pre-configured property files in the Docker server configuration directory, enabling users to easily deploy Conductor with specific database and indexing backends. New profiles include configurations for Cassandra with Redis queues and Elasticsearch 7, MySQL with Redis and Elasticsearch 7, and Postgres with either Elasticsearch 7 or native Postgres indexing. Additionally, new Redis-based profiles support Elasticsearch 8 and OpenSearch 2.x/3.x, reflecting the decoupling of OpenSearch configuration from the Elasticsearch namespace. All profiles consistently enable Prometheus metrics exposure, Redis health indicators, and the new Conductor-managed file storage type, providing a standardized starting point for various infrastructure setups.

docker/server/config · high confidence

The task-status-listener module now includes a configurable HTTP webhook publisher that sends task status updates to a specified URL. This feature introduces a new \TaskStatusPublisher\ that listens for task events, enqueues them, and posts JSON payloads via \RestClientManager\. Users can configure the webhook URL, task-specific and workflow-specific endpoints, and subscribe to specific task statuses (e.g., SCHEDULED, COMPLETED) via the \conductor.status-notifier.notification\ properties. The implementation includes connection pooling, configurable timeouts, retry logic for network errors and HTTP 503 responses, and UTF-8 encoding for the request body to prevent content-length mismatches. A \TaskNotification\ class is used to serialize task data, optionally filtering out sensitive input/output fields.

task-status-listener · high confidence

This change introduces the core implementation for the new Kafka publish task within the Conductor workflow engine. It adds the \KafkaPublishTask\ system task, which handles the execution logic for publishing messages to Kafka topics, including validation of required inputs (bootstrap servers, topic, value) and asynchronous publishing with configurable timeouts. It also includes the \KafkaProducerManager\ to manage and cache Kafka producer instances based on configuration properties, and the \KafkaPublishTaskMapper\ to map workflow definitions of type \KAFKA\_PUBLISH\ into scheduled task models. These components enable users to add Kafka publishing steps to their workflows.

kafka/src/main · high confidence

A new MetadataChangeListener interface has been introduced to handle lifecycle events for workflow definitions, task definitions, and event handlers (registration, updates, and unregistration). Alongside the interface, a MetadataChangeListenerStub implementation is provided that logs these metadata changes at the debug level, offering a default no-op behavior for existing integrations while enabling future extensibility for metadata change notifications.

core/src/main/java/org/conductoross/conductor/core/listener · high confidence

Added a set of utility classes in the mysql-persistence module to support database operations: ExecuteFunction and QueryFunction for executing queries with and without results, Query for building and executing PreparedStatement queries with type-safe parameter binding, LazyToString for deferred string generation, ResultSetHandler for processing query results, and TransactionalFunction for executing operations within a transactional context.

mysql-persistence/src/main/java/com/netflix/conductor/mysql/util · high confidence

A new \os-persistence-v3\ module has been added to support OpenSearch 3.x clusters, introducing a versioned indexing type (\opensearch3\) alongside the existing \opensearch2\. This module uses the \opensearch-java 3.0.0\ client, which replaces the legacy High-Level REST Client with a new Jakarta JSON-based API. To allow both versions to coexist, the module uses dependency shading to relocate OpenSearch client classes to an isolated namespace. Configuration is handled via \conductor.indexing.type=opensearch3\ and \conductor.opensearch.\\ properties, with backward compatibility maintained for legacy \conductor.elasticsearch.\\ settings. The implementation includes a new DAO layer (\OpenSearchRestDAO\), query helpers (\QueryHelper\), and configuration beans (\OpenSearchConfiguration\), along with comprehensive migration guides and documentation.

os-persistence-v3 · high confidence

This change introduces a suite of new utility classes in the Postgres persistence module to support database operations and an experimental queue optimization. It adds functional interfaces (ExecuteFunction, QueryFunction, ResultSetHandler, TransactionalFunction) and a Query wrapper to streamline PreparedStatement parameter binding and execution. A new PostgresQueueListener implements an experimental queue optimization using Postgres LISTEN/NOTIFY to monitor queue state and reduce polling. Additionally, supporting utilities like ExecutorsUtil for named thread factories, LazyToString for deferred string evaluation, and QueueStats for queue metrics are included.

postgres-persistence/src/main/java/com/netflix/conductor/postgres/util · high confidence

This update introduces three new REST controllers in the Conductor API. The FileResource adds endpoints to manage file uploads, downloads, and multipart operations, gated by the conductor.file-storage.enabled property. The SchemaResource provides a registry for saving, listing, retrieving, and deleting schema definitions, including versioned access. Additionally, the VersionResource exposes a simple endpoint to retrieve the server's current version string.

rest/src/main/java/org/conductoross/conductor/controllers · high confidence

A new \redis-configuration\ module has been introduced to centralize Redis connection and configuration logic for Conductor. It provides Spring auto-configuration for three deployment topologies—standalone, cluster, and sentinel—allowing users to select their mode via \conductor.db.type\. The module introduces a unified host configuration format (\host:port:rack\[:password\]\) and adds a dedicated \conductor.redis.sentinel-password\ property for authenticating with Sentinel nodes independently of the data-node password. It also includes an in-memory \JedisCommands\ implementation for testing without a real Redis instance and automatically publishes connection pool metrics (active connections, wait times) every 10 seconds.

redis-configuration · high confidence

The flow editor now features a new Rich Add Task Menu that replaces the previous quick-add interface. This menu provides a categorized grid of tasks (System, AI Tasks, Workers, Sub Workflows, and Integrations) with search filtering and tab-based navigation. It introduces a dedicated Integrations tab that allows users to browse available integrations, drill down into specific integration tools, and add new integrations directly from the workflow canvas. The menu is powered by an XState machine that handles asynchronous fetching of task definitions, workflow definitions, and integration data, with lazy loading and scroll position preservation for large lists.

ui-next/src/components/features/flow · high confidence

The SDK now provides a TaskContext class that allows annotated worker methods to access the current task's properties (such as workflow instance ID, retry count, and logs) via a thread-local context, and introduces a NonRetryableException for tasks that should not be retried. Additionally, a new TokenUsageLog model has been added to the AI module to track token consumption (prompt, completion, and total tokens) per task and API integration.

common/src/main/java/com/netflix/conductor/sdk, common/src/main/java/org/conductoross/conductor/ai · high confidence

This change introduces the \TaskStatusListener\ and \WorkflowStatusListener\ interfaces in the core listener package, allowing users to receive notifications for specific task and workflow lifecycle events (such as scheduled, completed, failed, finalized, etc.). Each interface includes a stub implementation for default logging and supports granular control: listeners can be enabled or disabled per task definition (\TaskDef\) and per workflow definition, giving implementers the ability to selectively subscribe to the status changes they care about without processing every event.

core/src/main/java/com/netflix/conductor/core/listener · high confidence

This update introduces three new feature areas to the UI. First, a comprehensive set of metrics charts (Cache, Errors, Latency, and Requests) is added to the \charts\ directory, providing visualizations for system performance and error rates with dark/light theme support. Second, a \GetStartedSample\ component is introduced to help users scaffold new projects by generating code snippets for various languages (Java, Python, Go, etc.) and build tools, complete with a copy-to-clipboard feature. Third, a global search capability is implemented via \SearchEverything\ and \SearchWrapper\, allowing users to fuzzy-search across core OSS entities like task definitions, workflows, schedulers, and events, with support for plugin-registered search providers.

ui-next/src/components/features/charts, ui-next/src/components/features/getStartedSample, ui-next/src/components/features/search · high confidence

This change introduces a new set of Java Data Transfer Objects in the \common/metadata/agent\ package that define the shape of the new agent capabilities. \AgentConfig\ serves as the root definition for agent metadata, supporting multi-agent orchestration strategies (such as \HANDOFF\, \SEQUENTIAL\, and \PLAN\_EXECUTE\), tool definitions, guardrails, and memory configuration. Supporting DTOs like \AgentStartRequest\ and \AgentStartResponse\ define the payload for initiating agent runs, while \AgentRun\, \AgentExecutionDetail\, and \AgentExecutionSummary\ provide structured data for tracking execution status and token usage. Additionally, \AgentSSEEvent\ enables real-time streaming of agent state changes (e.g., tool calls, handoffs, and context condensation) to clients.

common/src/main/java/org/conductoross/conductor/common/metadata · high confidence

The SDK now provides a set of Java annotations to simplify the definition of workflow task workers. Developers can use the new @WorkerTask annotation on methods to specify task metadata such as the task name, thread count, polling interval, and lease extension behavior. Additionally, @InputParam and @OutputParam annotations allow for explicit mapping of method parameters and return values to workflow input and output data, enabling a more declarative approach to building task workers.

core/src/main/java/com/netflix/conductor/sdk · high confidence

Added three new annotations in the \com.netflix.conductor.annotations.protogen\ package to support exposing Java types via the gRPC API as native Protocol Buffers definitions. \ProtoMessage\ marks POJOs as gRPC message structs with options to control bidirectional mapping and wrapper behavior, \ProtoEnum\ marks enums for native gRPC enum exposure, and \ProtoField\ annotates struct fields with mandatory numeric IDs to ensure Protocol Buffers backward compatibility.

common/src/main/java/com/netflix/conductor/annotations · high confidence

Added two new data models to the common library: BulkResponse, a generic container for aggregating successful and failed results from bulk requests, and WorkflowMessage, a model representing a single message in a workflow's message queue (WMQ) with fields for ID, workflow ID, payload, and ingestion timestamp.

common/src/main/java/com/netflix/conductor/common/model · high confidence

This change introduces several new utility classes in the common module to support workflow and agentic flow capabilities. It adds a \Documented\ annotation to mark API lifecycle states (Beta, Deprecated, GA) and usage requirements. A new \JsonSchemaValidator\ component is provided to validate JSON payloads against schema definitions using the Networknt library. Additionally, a \StringTemplate\ utility is added to support f-string style variable substitution in workflow definitions, and a \TextUtils\ helper is included to sanitize strings for PostgreSQL storage by removing null bytes.

common/src/main/java/org/conductoross/conductor/common · high confidence

Added a suite of scripts to enforce documentation integrity and streamline content generation. \check-doc-links.sh\ and \check-workflows-docs.py\ validate internal and external links and ensure the Workflows and Design Patterns navigation structures match expected files. \check\_ai\_cookbook.py\ enforces navigation consistency and title length for the AI Cookbook. \validate\_cookbook\_ai\_examples.py\ ensures AI cookbook assets remain synchronized with their source examples in \ai/examples\. \capture\_cookbook\_verification.py\ provides a CLI to fetch and display execution evidence for cookbook workflows, explicitly reporting terminal failures. \fetch-sdk-docs.py\ automates the retrieval and formatting of SDK READMEs from GitHub for the documentation site. Finally, \generate-llm-context.py\ creates a curated LLM context file from documentation sources, with \test\_generate\_llm\_context.py\ providing regression tests for its snippet expansion logic.

scripts · high confidence

Conductor now supports pluggable secret backends for agent and workflow tasks. An EnvVariableSecretsDAO reads secrets from environment variables (default prefix CONDUCTOR\SECRET\, plus well-known LLM keys like OPENAI\_API\_KEY), while a NoopSecretsDAO provides a disabled fallback when conductor.secrets.type=noop. A new RuntimeMetadataResolver resolves task-declared secrets by querying the configured SecretsDAO first and falling back to the EnvironmentDAO, omitting any names that are not found.

core/src/main/java/com/netflix/conductor/core/secrets · high confidence

Two new exception classes have been added to the core exception package to handle specific failure scenarios. FileStorageException is introduced to represent server-side errors related to file storage operations, such as verification or backend issues. SchemaValidationException is added to handle cases where a payload does not conform to its attached schema or when the schema itself cannot be enforced; it extends jakarta.validation.ValidationException to ensure compatibility with existing Bean Validation catch blocks while allowing the system to return a 400 status code for bad payloads rather than a 500.

core/src/main/java/org/conductoross/conductor/core/exception · high confidence

This change introduces the core Protocol Buffer schemas for the Conductor gRPC interface, defining services for managing workflows (start, pause, resume, terminate, search), tasks (poll, batch poll, update, logs), event handlers, and metadata (workflow/task definitions). It establishes the contract for client-server communication, including specific search endpoints that return full Workflow/Task objects (SearchV2) alongside legacy summary-based searches, and adds support for restarting workflows with the latest definitions.

grpc/src/main/proto/grpc · high confidence

This release introduces a new gRPC-based client library for the Conductor server, providing a high-performance alternative to existing HTTP clients. The library includes dedicated client classes for managing workflows (WorkflowClient), tasks (TaskClient), metadata (MetadataClient), and event handlers (EventClient). Key capabilities include starting and tracking workflows, polling for tasks (including batch polling), registering and updating workflow and task definitions, and managing event handlers. The implementation leverages Protocol Buffers for serialization and supports both direct address/port connections and custom ManagedChannel builders for advanced configuration.

grpc-client/src · high confidence

A new gRPC server component has been added to Conductor, allowing users to expose workflow services via the gRPC protocol. The server is controlled by the 'conductor.grpc-server.enabled' property and binds to a configurable port (default 8090). It automatically registers all available BindableService implementations and includes a reflection service by default (configurable via 'conductor.grpc-server.reflection-enabled') to facilitate service discovery and testing.

grpc-server/src/main/java/com/netflix/conductor/grpc/server · high confidence

The gRPC server now exposes concrete service implementations for managing workflows, tasks, metadata, and event handlers, bridging the gRPC interface to the underlying Spring-managed service layer. This change introduces \WorkflowServiceImpl\, \TaskServiceImpl\, \MetadataServiceImpl\, \EventServiceImpl\, and \HealthServiceImpl\ in the \grpc-server\ module, enabling clients to start workflows, poll and update tasks, register workflow definitions, and manage event handlers via gRPC. It also includes a \GRPCHelper\ utility for standardized error handling and optional field conversion, along with a basic gRPC health check endpoint.

grpc-server/src/main/java/com/netflix/conductor/grpc/server/service · high confidence

The model package introduces several new classes to support the new status and signal endpoints: WorkflowStatus provides a lightweight summary of a workflow execution (excluding the full task list) for efficient status checks; SignalResponse serves as the base class for signal operations; WorkflowRun and TaskRun extend SignalResponse to carry specific context for workflows and tasks respectively; and WorkflowSignalReturnStrategy defines how signal responses should be scoped (e.g., target workflow vs. blocking task).

common/src/main/java/org/conductoross/conductor/model · high confidence

A new CredentialMeta model has been introduced to structure secret metadata returned by the GET /api/secrets/v2 endpoint. This model exposes the secret name, a partial display value (showing the first and last four characters), and creation/update timestamps, ensuring that plaintext secret values are never included in API responses.

common/src/main/java/org/conductoross/conductor/model/secret · high confidence

This release introduces a suite of new system tasks and the underlying execution infrastructure to expand workflow capabilities. New task types include DoWhile for loop execution, Event for publishing to message queues, ExclusiveJoin for conditional branching, Human for manual approval steps, Inline for script evaluation (replacing the deprecated Lambda task), Noop for empty branches, PullWorkflowMessages for consuming workflow messages, SetVariable for updating workflow-scoped variables, and StartWorkflow for launching child workflows. These tasks are supported by new execution components such as IsolatedTaskQueueProducer for managing isolated task queues and ExecutionConfig for thread-pool and semaphore configuration, enabling more granular control over system task execution and concurrency.

core/src/main/java/com/netflix/conductor/core/execution/tasks · high confidence

The ui-next directory is introduced as a new standalone React application and npm library, providing the foundation for the OSS Conductor UI v2. This includes a complete development environment setup with Vite, pnpm, and Husky pre-commit hooks, alongside a robust end-to-end testing infrastructure using Playwright. The diff adds configuration for both mocked unit tests and integration tests that run against a live Conductor backend in Docker, ensuring consistent screenshot baselines across environments.

ui-next · high confidence

This change introduces several new utility components in the core utils package to support advanced workflow features: DateTimeUtils for parsing durations and dates, ExternalPayloadStorageUtils for handling large payloads via external storage, JsonUtils for expanding inline JSON strings, ParametersUtils for resolving JSONPath bindings and secrets, QueueUtils for constructing queue names based on domain and isolation groups, and SemaphoreUtil for managing processing concurrency. It also adds a new generateSubWorkflowId method to IDGenerator for deterministic sub-workflow ID creation and removes the deprecated LockProvider and LockException classes.

core/src/main/java/com/netflix/conductor/core/utils · high confidence

The REST service now includes a KitchenSinkInitializer component that automatically loads sample workflows and task definitions into the system upon startup. This behavior is controlled by the 'loadSample' configuration property (defaulting to false), allowing users to enable pre-configured examples for testing or demonstration purposes without manual intervention.

rest/src/main/java/com/netflix/conductor/rest/startup · high confidence

The Redis persistence module now includes new DAO implementations and configuration classes to support several new capabilities. A Redis-backed WorkflowMessageQueueDAO is introduced, allowing messages to be pushed into running workflows via a Redis List, enabled by setting conductor.workflow-message-queue.enabled=true. Additionally, RedisFileMetadataDAO provides persistence for file storage metadata when conductor.file-storage.enabled=true, and RedisSkillMetadataDAO and RedisSkillPackageDAO enable versioned storage for AI skill metadata and packages when conductor.integrations.ai.enabled=true. These components rely on the refactored BaseDynoDAO for namespaced key management and conditional Spring Boot initialization.

redis-persistence/src/main/java/com/netflix/conductor/redis · high confidence

Conductor now supports limiting the number of concurrent task executions using Redis as the backing store. When the new 'conductor.redis-concurrent-execution-limit.enabled' property is set to true, the system uses a Redis-backed DAO to track active task instances via Redis Sets, checking against the task definition's concurrency limit before allowing new executions. The implementation supports both standalone and cluster Redis configurations, with connection details (host, port, password, max connections) and a configurable namespace (defaulting to 'conductor') managed through the 'conductor.redis-concurrent-execution-limit' configuration prefix. This provides a distributed concurrency control mechanism for workflows.

redis-concurrency-limit/src/main · high confidence

This change introduces a new SQLite-based persistence layer for Conductor's metadata, including task definitions, workflow definitions, and event handlers. The \SqliteMetadataDAO\ acts as a unified facade implementing \MetadataDAO\ and \EventHandlerDAO\, delegating to specific DAOs (\SqliteTaskMetadataDAO\, \SqliteWorkflowMetadataDAO\, \SqliteEventHandlerMetadataDAO\) that handle CRUD operations against SQLite tables (\meta\_task\_def\, \meta\_workflow\_def\, \meta\_event\_handler\). This allows users to store and retrieve workflow and task metadata using SQLite instead of the default database.

sqlite-persistence/src/main/java/com/netflix/conductor/sqlite/dao/metadata · high confidence

This change adds the initial SQLite persistence implementation for the application, including the database migration scripts (V1 through V8) that define the schema. The schema covers core workflow and task execution tables, queue management, and file metadata storage. It also introduces specific features such as AgentSpan skill storage, workflow classification support for search, UTC timestamp normalization for index columns, and end-time indexing for sortable execution lists. Additionally, a schema registry table is added to support versioned definition storage, allowing the OSS product to share a database with commercial variants without collision.

sqlite-persistence/src/main/resources · high confidence

This change introduces a new SQLite-based persistence implementation for Conductor, adding DAO classes (SqliteBaseDAO, SqliteExecutionDAO, SqliteIndexDAO, SqliteQueueDAO, SqlitePollDataDAO) that provide workflow execution, indexing, queueing, and polling capabilities. The implementation supports transactional operations with retry logic, indexes workflow and task data for search, manages message queues with long-poll semantics, and tracks poll data. It includes specific fixes for timestamp handling in UTC, end-time sorting, and concurrency limit slot release.

sqlite-persistence/src/main/java/com/netflix/conductor/sqlite/dao · high confidence

Added a comprehensive quickstart guide and a suite of example workflow and schedule definitions to the scheduler module. The new README provides step-by-step instructions for registering workflows, creating and managing schedules (including pausing, resuming, and deleting), and previewing execution times via the API. The included examples demonstrate various scheduling patterns such as bounded execution windows, catch-up modes for missed runs, concurrent executions, multi-step parallel workflows, and retry behaviors, helping users understand how to configure and operate the scheduler effectively.

scheduler · high confidence

Conductor now includes a schema registry for managing JSON schema definitions, allowing users to save, retrieve, and delete schemas with versioning support. The core service (SchemaService) provides an in-memory read-through cache (backed by Caffeine) that can be enabled via the conductor.app.schema-cache configuration properties (TTL and max size), and falls back to an in-memory DAO if no persistent backend is available. For persistent storage, a new Redis-backed implementation (RedisSchemaDAO) stores schema versions in Redis hashes, enabling durable, shared schema storage across server instances.

core/src/main/java/org/conductoross/conductor/service, redis-persistence/src/main/java/org · high confidence

A new standalone Docker image for the Conductor UI is now available, allowing users to run the UI separately from the server. The setup includes a Dockerfile that builds the 'ui-next' frontend using Node.js and serves the static bundle via Nginx on port 5000. An nginx configuration template handles proxying API and actuator requests to the Conductor server, which can be specified at runtime via the WF\_SERVER environment variable.

docker/ui · high confidence

The system now allows developers to define system tasks using the @WorkerTask annotation on Spring beans. This change introduces a new scanning mechanism (WorkerTaskAnnotationScanner) that automatically detects these annotated methods and registers them as asynchronous system tasks within the workflow engine. It includes utility classes (AnnotatedMethodParameterMapper, AnnotatedMethodResultMapper) to handle the mapping of task inputs to method parameters and method return values to task outputs, supporting features like @InputParam and @OutputParam annotations. A sample worker is provided to demonstrate the usage. This enables a more declarative and Spring-native way to implement custom system tasks.

core/src/main/java/org/conductoross/conductor/core/execution/tasks · high confidence

Users can now define system tasks using annotations (specifically @WorkerTask) without needing to pre-register a task definition in the metadata store. The new AnnotatedSystemTaskMapper handles these tasks by optionally applying rate-limiting and timeout settings if a task definition exists, but will schedule the task directly if it does not. Additionally, a new TaskMapperValidator interface has been introduced to allow for custom validation logic on workflow tasks.

core/src/main/java/org/conductoross/conductor/core/execution/mapper · high confidence

The REST API now supports exposing Protocol Buffers \Any\ messages, which are used in the new gRPC interface, by registering a custom Jackson module (\JsonProtoModule\). This module enables serialization and deserialization of \Any\ objects into a custom JSON format containing \@type\ (the type URL) and \@value\ (the base64-encoded binary payload), allowing clients to reconstruct the original protobuf message without the server needing to know the embedded schema.

common/src/main/java/com/netflix/conductor/common/jackson · high confidence

This change introduces the Workflow Message Queue (WMQ) capability, allowing users to push messages into running workflows via a new configuration module (WorkflowMessageQueueConfiguration) and properties (WorkflowMessageQueueProperties) under the conductor.workflow-message-queue prefix. The feature is disabled by default and supports an in-memory DAO fallback. Additionally, the core configuration has been refactored: the legacy Configuration interface is removed and replaced by Spring Boot-based configuration classes (ConductorCoreConfiguration, ConductorProperties, SchedulerConfiguration) that manage core beans like locks, listeners, executors, and task mappers using typed properties.

core/src/main/java/com/netflix/conductor/core/config · high confidence

The WorkflowContext class has been updated to allow storing and retrieving a username in addition to the existing client application identifier. This enables workflows to track the specific user responsible for triggering or executing tasks, improving auditability and access control within the workflow engine.

core/src/main/java/com/netflix/conductor/core · high confidence

The Dynomite-specific Redis persistence layer has been removed from the Conductor codebase. This change deletes the \BaseDynoDAO\ base class, the \DynoProxy\ client wrapper, and the \RedisExecutionDAO\ and \RedisMetadataDAO\ implementations that previously handled workflow and task data storage via Dynomite. Users relying on this specific Dynomite-backed Redis configuration will no longer have this persistence option available.

redis-persistence/src/main/java/com/netflix/conductor/dao/dynomite, redis-persistence/src/main/java/com/netflix/conductor/dao/dynomite/queue · high confidence

The Elasticsearch-based indexing implementation has been removed from the Redis persistence module. This change deletes the \ElasticSearchDAO\ class, which previously handled indexing and searching of workflows and tasks, along with the \ElasticsearchModule\ that provided the Elasticsearch transport client configuration. Users relying on this specific Elasticsearch integration within this module will no longer have access to these indexing capabilities.

redis-persistence/src/main/java/com/netflix/conductor/dao/index · high confidence

The RedisESWorkflowModule class, which previously configured the dependency injection bindings for Redis-based persistence components (RedisExecutionDAO, RedisMetadataDAO, DynoQueueDAO) and ElasticSearch integration, has been removed from the codebase. This change eliminates the specific module responsible for wiring these data access objects in the Redis persistence layer.

redis-persistence/src/main/java/com/netflix/conductor/dao · high confidence

The legacy HTTP task implementation (HttpTask) and its associated RestClientManager have been removed from the codebase. This change eliminates the previous logic that relied on the Jersey client for making HTTP calls, meaning workflows previously using this specific task type will no longer function with the old implementation.

contribs/src/main/java/com/netflix/conductor/contribs/http · high confidence

The legacy Jersey-based REST resource classes (AdminResource, MetadataResource, TaskResource, WorkflowResource) and their associated exception mappers have been removed from the server module. This eliminates the old JAX-RS endpoint implementations, indicating a migration away from the Jersey framework for the public API surface.

jersey · high confidence

The legacy HTTP client implementation classes \ClientBase\, \TaskClient\, and \WorkflowClient\ have been removed from the \com.netflix.conductor.client.http\ package. These classes, which previously handled REST interactions using the Jersey client library, are no longer present in the codebase, indicating a migration away from this specific client architecture.

client/src/main/java/com/netflix/conductor/client/http · high confidence

The \SQSObservableQueue\ class, which provided an RxJava-based observable interface for AWS SQS event processing, has been removed from the codebase. This eliminates the legacy RxJava dependency for this specific queue provider, requiring users to migrate to the current standard SQS queue implementations.

contribs/src/main/java/com/netflix/conductor/contribs/queue/sqs · high confidence

The \ContribsModule\ Guice module and the \Wait\ system task have been removed from the codebase. This eliminates the automatic binding of SQS \ObservableQueue\ instances for \COMPLETED\ and \FAILED\ task statuses and removes the \WAIT\ task implementation, indicating a shift away from the previous eventing and queue management architecture in this contribs module.

contribs/src/main/java/com/netflix/conductor/contribs · high confidence

The legacy \Worker\ interface in the client library has been removed. This interface previously defined the contract for task execution, including methods for polling, execution, and error handling. Its removal indicates a shift in how workers are implemented or integrated within the Conductor client, requiring users to adopt the new worker implementation patterns provided by the updated client.

client/src/main/java/com/netflix/conductor/client/worker · high confidence

The legacy \WorkflowTaskCoordinator\ class and its associated \WorkflowTaskMetrics\ helper have been removed from the client task package. This deletion eliminates the old polling loop, thread-pool management, and Servo-based metric tracking, indicating a shift away from the previous worker coordination model to a different implementation elsewhere in the client library.

client/src/main/java/com/netflix/conductor/client/task · high confidence

The legacy query parser implementation within the Redis persistence module has been removed. Specifically, the \ComparisonOp\, \FilterProvider\, \FunctionThrowingException\, \Name\, and \ParserException\ classes in the \com.netflix.conductor.dao.index.query.parser\ package have been deleted. This eliminates the old parsing logic and associated interfaces from the codebase.

redis-persistence/src/main/java/com/netflix/conductor/dao/index/query · high confidence

The legacy queue-based mechanism for completing wait tasks has been removed. This change deletes the \ObservableQueue\ interface, the \QueueManager\ service that polled these queues to update task statuses, and the \QueueAdminResource\ REST endpoints (such as \/queue/size\ and \/queue/update/{workflowId}/{taskRefName}/{status}\) that exposed queue metrics and allowed manual task updates via message publishing. Users relying on this external queue integration for wait task completion will need to adopt the current eventing or direct API approaches.

contribs/src/main/java/com/netflix/conductor/contribs/queue · high confidence

A new ExecutionDAOFacade component has been added to the core DAL layer to act as a unified interface for accessing execution data across ExecutionDAO, QueueDAO, IndexDAO, and RateLimitingDAO. This facade centralizes logic for fetching workflow and task models, handling external payload storage transparently, and managing asynchronous index updates via a dedicated scheduled thread pool. It also introduces specific exception handling (e.g., NotFoundException) and ensures index operations are managed reliably before workflow removal, simplifying how other services interact with the underlying storage layers.

core/src/main/java/com/netflix/conductor/core/dal · high confidence

The Cassandra persistence module has been re-architected to use Spring Boot for dependency injection and configuration, replacing the previous manual wiring. This change introduces Spring-managed configuration properties (under \conductor.cassandra\) for connection details, consistency levels, and cache intervals. Additionally, in-memory caching is now enabled for task definitions and event handlers via \CacheableMetadataDAO\ and \CacheableEventHandlerDAO\ decorators, which refresh data from Cassandra at configurable intervals to reduce database load. The module also adds support for username/password authentication when connecting to the Cassandra cluster.

cassandra-persistence/src/main · high confidence

The CHANGELOG.md has been populated with details on the migration of the JavaScript evaluator from the deprecated Nashorn engine to GraalJS, which now requires Java 17 or higher and introduces ES6+ support, script execution timeouts, and context pooling. The changelog also documents a behavioral change where the GET /api/scheduler/schedules/{name} endpoint now returns a 404 status for unknown schedules instead of an empty 200 OK response.

(repo-wide) · high confidence

The main Conductor application entry point has been updated to include 'io.orkes.conductor', 'dev.agentspan', and 'org.conductoross.conductor' in its component scan base packages, enabling support for Orkes-specific components, AgentSpan workflows, and legacy Conductor OSS packages. Additionally, the server's default queue type has been changed to 'memory' (implied by the context of 'Make orkes queue default' and standard Spring Boot defaults, though the diff shows the config reading logic remains, the commit message indicates a behavioral shift towards Orkes defaults). This change allows the server to discover and initialize beans from these new package structures upon startup.

server/src/main/java/com/netflix/conductor · medium confidence

The ES7 persistence module now exposes the \conductor.elasticsearch.wait-for-index-refresh\ property, which defaults to false. This change addresses the 20-30 second delays in the task completion API introduced in v3.21.20 by disabling the wait-for-refresh behavior by default, allowing indexing to proceed asynchronously without blocking on immediate search visibility. The configuration also includes standard ES7 connection settings, authentication support, and conditional activation logic for the Elasticsearch V7 client.

es7-persistence/src/main/java/com/netflix/conductor/es7/config · high confidence

The REST module now includes a dedicated configuration class and interceptor to manage API routing and static resource serving. A new filter enforces file signature verification on content endpoints, while an interceptor handles Single Page Application (SPA) fallbacks for browser navigation, explicitly excluding backend APIs, OpenAPI documentation, health checks, and the A2A server base path from SPA routing. Static UI resources are served from the classpath, and this behavior is controlled by the 'conductor.enable.ui.serving' property.

rest/src/main/java/org/conductoross/conductor · high confidence

The Docker server image now uses a new startup script that allows users to provide an external configuration file via the CONFIG\_PROP environment variable. If CONFIG\_PROP is not set, the server starts with built-in defaults using SQLite, requiring no external dependencies. When CONFIG\_PROP is provided, the server loads the specified configuration file from /app/config/ before launching.

docker/server/bin · high confidence

Configuring the system to use Elasticsearch 6.x (via \conductor.indexing.type=elasticsearch\_v6\) now triggers a startup failure with a clear migration message. Users must switch their configuration to \conductor.indexing.type=elasticsearch\ to use Elasticsearch 7.x, as the 6.x implementation has been removed from this module and archived externally.

es6-persistence/src · high confidence

The query parser implementation has been moved from the \redis-persistence\ module to the \es7-persistence\ module, updating the package structure to \com.netflix.conductor.es7.dao.query.parser\ and its internal sub-packages. This change adapts the existing query parsing logic (handling expressions, comparisons, and boolean operators) to target Elasticsearch 7, as evidenced by the new imports of \org.elasticsearch.index.query.QueryBuilder\ and the updated copyright headers.

es7-persistence/src/main/java/com/netflix/conductor/es7/dao/query · high confidence

The system now validates workflow task definitions at registration time, ensuring that required parameters are present and correctly formatted for each task type. This includes checking that decision tasks have either a case value parameter or expression, switch tasks have valid JavaScript syntax, and sub-workflow tasks have required parameters. The validation context provides access to metadata for more accurate checks, and specific task types like WAIT, TERMINATE, and FORK\_JOIN\_DYNAMIC have tailored validation rules to prevent configuration errors before execution.

core/src/main/java/com/netflix/conductor/validations · high confidence

The generic \conductor.indexing.type=opensearch\ configuration is now deprecated and will cause the application to fail at startup with a clear migration error. Users must explicitly choose between version-specific modules by setting \conductor.indexing.type=opensearch2\ for OpenSearch 2.x or \conductor.indexing.type=opensearch3\ for OpenSearch 3.x. This change isolates dependencies to prevent package conflicts between the incompatible client namespaces of OpenSearch 2.x and 3.x.

os-persistence · high confidence

The HTTP task implementation has been refactored to use Spring's RestTemplate and Apache HttpClient, introducing support for configurable timeouts. Users can now set the read timeout via the \conductor.tasks.http.readTimeout\ property (defaulting to 150ms) and the connection timeout via \conductor.tasks.http.connectTimeout\ (defaulting to 100ms). These settings apply both globally and can be overridden per-task input, ensuring that HTTP calls no longer default to a fixed 3-minute timeout and instead respect the specified limits.

http-task/src/main · high confidence

The workflow sweeper now uses a smarter postpone calculation to avoid unnecessary polling, specifically preventing HUMAN tasks from churning the decider queue and improving the reliability of SUB\_WORKFLOW tasks. Additionally, the sweeper now explicitly manages execution locks and re-queues workflows on lock misses to eliminate multi-minute pauses in workflow processing.

core/src/main/java/org/conductoross/conductor/core/execution · high confidence

The server now ships with a default \application.properties\ file that configures the application to use SQLite for the database, queue, and indexing layers, while enabling Prometheus metrics by default. A new \banner.txt\ displays the application and Spring Boot versions on startup, and a \log4j2.xml\ file establishes a default console logging configuration at the INFO level.

server/src/main/resources · high confidence

The workflow engine now utilizes new internal domain classes, \TaskModel\ and \WorkflowModel\, to represent the state of task and workflow executions. These models introduce specific fields to support advanced execution features, including \firstScheduledTime\ and \callbackAfterMs\ in tasks for precise timeout and retry scheduling, \previousStatus\ in workflows to track state transitions, and \waitTimeout\ for time-based wait scenarios. Additionally, a new \WorkflowNotifications\ class has been added to carry context such as request IDs and host information during workflow events.

core/src/main/java/com/netflix/conductor/model · high confidence

The legacy WorkflowReconciler, WorkflowSweeper, and WorkflowRepairService classes in the core reconciliation package are now marked as deprecated for removal. These components, which previously handled periodic workflow polling, timeout evaluation, and queue consistency repairs, are superseded by a new WorkflowSweeper implementation located in the org.conductoross package. Users relying on the legacy behavior must migrate to the new sweeper configuration, as these classes are retained only for backward compatibility and will be removed in a future release.

core/src/main/java/com/netflix/conductor/core/reconciliation · high confidence

The \annotations-processor/src\ module now contains a self-contained implementation of the \protogen\ tool, moving the code from external dependencies into local source files. This includes the core generation logic (\ProtoGen\, \ProtoGenTask\), message and enum handling (\AbstractMessage\, \Message\, \Enum\), and a comprehensive type-mapping system (\TypeMapper\, \ScalarType\, \ListType\, \MapType\, \MessageType\) that maps Java types to Protocol Buffers definitions. An example class (\Example.java\) is also provided to demonstrate the usage of the \@ProtoMessage\ and \@ProtoField\ annotations.

annotations-processor/src · high confidence

The metrics subsystem has been refactored to use Micrometer instead of the legacy Netflix Servo/Spectator libraries. A new Spring-managed MetricsCollector component now wires available MeterRegistry instances into the static Monitors API at startup, and the Monitors class itself has been rewritten to use Micrometer primitives. Additionally, a new WorkflowMonitor component is introduced to periodically report running workflow counts, queue depths, and in-progress task gauges, controlled by the conductor.workflow-monitor.enabled property.

core/src/main/java/com/netflix/conductor/metrics · high confidence

The protogen annotations (ProtoEnum, ProtoField, and ProtoMessage) have been moved from an external source into the local Conductor codebase. This change brings the annotation definitions directly under the com.netflix.conductor.annotations.protogen package, ensuring they are maintained alongside the project rather than relying on the original external repository.

annotations · high confidence

The MySQL persistence layer is now configured via a new Spring Boot \@Configuration\ class that automatically registers database access objects (metadata, execution, queue, schema, and optional file/skill metadata) once \conductor.db.type\ is set to \mysql\. Database schema migrations are handled by Flyway, which is explicitly imported and customized to baseline on version 0 to prevent conflicts if the scheduler migrates first. Additionally, a custom retry template is registered to automatically retry operations on MySQL deadlock errors, with the maximum retry count configurable via \conductor.mysql.deadlock-retry-max\.

mysql-persistence/src/main/java/com/netflix/conductor/mysql/config · high confidence

The server Docker image now uses Azul Zulu OpenJDK 21 instead of the previous OpenJDK 17 base, and introduces a parallel build track for the new 'ui-next' frontend (React 18/Vite) alongside the existing 'ui' build. The Dockerfile supports a PREBUILT build argument to skip local JAR and UI compilation in favor of pre-built artifacts, and includes an updated Nginx configuration to serve the UI on port 5000 while proxying API and Swagger requests to the Spring Boot application on port 8080.

docker/server · high confidence

Conductor now supports a new Redis-backed message queue implementation (accessible via \conductor.queue.type\ set to \redis\_standalone\, \redis\_sentinel\, or \redis\_cluster\). This replaces the previous Dyno-based queue persistence with a new architecture that uses Jedis for Redis communication and Caffeine for local queue caching. The new implementation introduces a \BaseRedisQueueDAO\ with specific subclasses for standalone/sentinel (\RedisQueueDAO\) and cluster (\ClusteredRedisQueueDAO\) modes, and includes logic to handle message payloads via Redis hashes. This change is a behavioral shift for users relying on the default or previous Redis queue behavior, as it alters the underlying persistence mechanism and caching strategy.

redis-persistence/src/main/java/io · high confidence

The event handling subsystem has been refactored to introduce a new, extensible architecture. A new \DefaultEventProcessor\ and \DefaultEventQueueManager\ now manage the lifecycle of event queues and dispatch actions (such as starting workflows or completing tasks) based on incoming messages, with improved handling for transient failures and message acknowledgment. Additionally, the JavaScript evaluation for event conditions has migrated from Nashorn to GraalJS, featuring a shared engine and source cache for performance, with a configurable context pool to optimize script execution latency.

core/src/main/java/com/netflix/conductor/core/events · high confidence

The core module now includes the TaskCancellationHandler interface, allowing worker tasks to receive cancellation signals and propagate them to owned resources, and the AnnotatedSystemTaskWorker interface to support lifecycle hooks for embedded system tasks exposed via @WorkerTask annotations.

common/src/main/java/org/conductoross/conductor/core · high confidence

The server now includes an AgentSpanUiContextController that serves a dynamic /context.js file to control the visibility of the embedded AI Agents UI pages based on the conductor.integrations.ai.enabled flag, and adds Spring configuration classes to wire up Azure Monitor, CloudWatch, and Logging metrics registries when their respective export properties are enabled.

server/src/main/java/com/netflix/conductor/server · high confidence

The common module now includes several new Jakarta Bean Validation constraints to enforce stricter rules on workflow and task definitions. The ValidNameConstraint restricts workflow and task names to alphanumeric characters, underscores, spaces, hyphens, and specific symbols (\<, \>, {, }, \#), with this validation being toggleable via the conductor.app.workflow.name-validation.enabled configuration. The TaskReferenceNameUniqueConstraint ensures that task reference names are unique across all tasks within a workflow definition and validates that input parameters correctly reference existing tasks. The TaskTimeoutConstraint prevents configuration errors by ensuring that a task's responseTimeoutSeconds does not exceed its timeoutSeconds, and that timeoutSeconds does not exceed totalTimeoutSeconds. Additionally, the OwnerEmailMandatoryConstraint allows for optional owner email validation based on a configurable flag, and the NoSemiColonConstraint prevents colons in string fields.

common/src/main/java/com/netflix/conductor/common/constraints · high confidence

This change introduces a comprehensive set of database migrations for the PostgreSQL persistence layer, establishing the initial schema (V1) and applying subsequent structural and performance improvements. Key additions include new tables for file metadata storage, AgentSpan skill metadata and packages, and a schema registry for versioned definitions. The workflow and task indexing tables are enhanced with columns for parent workflow IDs, classifiers, and end times to support better search, sorting, and hierarchical workflow tracking. Existing tables undergo primary key normalization (removing surrogate IDs in favor of natural keys), index optimizations for queue messages and event executions, and corrections to JSONB indexing on workflow and task indices. A trigger is also added to enforce data integrity on poll data updates.

_postgres-persistence/src/main/resources/db/migration\postgres · high confidence

The Postgres persistence layer now uses a Spring Boot-based configuration class (PostgresConfiguration) and properties binding (PostgresProperties) to manage database connections, Flyway migration settings, and feature toggles. This change introduces support for experimental queue notifications via PostgreSQL LISTEN/NOTIFY, configurable data migrations, and conditional registration of DAOs for indexing, locking, file storage, and AI skill metadata based on specific property flags. Users benefit from improved integration with Spring Boot's auto-configuration, allowing for more flexible and standardised setup of the Postgres backend.

postgres-persistence/src/main/java/com/netflix/conductor/postgres/config · high confidence

The REST layer has been migrated to Spring Boot, introducing a new centralized exception handling strategy via \ApplicationExceptionMapper\ and \ValidationExceptionMapper\ that maps specific exceptions (e.g., \NotFoundException\, \ConflictException\) to appropriate HTTP status codes (404, 409) and logs client errors at WARN level to reduce log noise. This change also introduces a set of new REST controllers (\AdminResource\, \EnvironmentResource\, \EventResource\, \QueueAdminResource\, \SecretResource\, \WorkflowBulkResource\, \WorkflowMessageQueueResource\) and a \RequestMappingConstants\ interface to standardize API paths, adding capabilities such as bulk workflow operations, environment/secret management, and conditional workflow message queue support.

rest/src/main/java/com/netflix/conductor/rest/controllers · high confidence

The \JedisCommands\ interface and \UnifiedJedisCommands\ implementation have been relocated to the \conductor-redis-api\ module. This change reorganizes the codebase structure for Redis client abstractions without altering the external API or runtime behavior for users.

redis-api · high confidence

The Redis locking module now exposes detailed configuration options for Redisson connections, including support for Redis 6+ username authentication, customizable Netty thread counts, cluster-specific connection pool sizes, and an adjustable DNS monitoring interval. Additionally, a new Spring Boot Actuator health indicator is provided to monitor the status of the Redis connection (Single, Cluster, or Sentinel modes), allowing operators to verify connectivity via standard health endpoints.

redis-lock/src/main/java · high confidence

The core data access layer interfaces have been significantly refactored to support new capabilities and a separation of concerns. New interfaces introduced include ConcurrentExecutionLimitDAO for task concurrency limits, RateLimitingDAO for rate limiting, EventHandlerDAO for event handler storage, PollDataDAO for task polling data, EnvironmentDAO for environment variables, and WorkflowMessageQueueDAO for the per-workflow message queue feature. The existing ExecutionDAO, IndexDAO, MetadataDAO, and QueueDAO interfaces have been updated to use new model classes (e.g., WorkflowModel, TaskModel, WorkflowSummary) instead of older ones, and to support new behaviors such as asynchronous indexing, task priority in queues, and improved workflow search. The legacy WorkflowArchiveDAO has been removed.

core/src/main/java/com/netflix/conductor/dao · high confidence

The workflow execution engine now relies on a set of dedicated TaskMapper classes (e.g., DecisionTaskMapper, DoWhileTaskMapper, DynamicTaskMapper, EventTaskMapper, ForkJoinTaskMapper, HTTPTaskMapper, HumanTaskMapper, JoinTaskMapper) to translate workflow definitions into executable tasks. This change centralizes task creation logic, ensuring that task inputs, status, and metadata are consistently mapped from the workflow context. Users benefit from more predictable task scheduling and better separation of concerns in how different task types (like HTTP, Human, or Dynamic tasks) are initialized and executed within the workflow.

core/src/main/java/com/netflix/conductor/core/execution/mapper · high confidence

The JSON serialization setup has been refactored to align with Spring Boot's auto-configuration. A new Spring configuration now applies Jackson customizations (disabling failure on unknown/ignored/null properties) via a builder customizer, while the default Spring-injected ObjectMapper is explicitly configured to include non-null properties and register the Afterburner performance module. The standalone ObjectMapperProvider, used by the client and tests, has been updated to mirror these settings and additionally registers the Kotlin module, ensuring consistent behavior across the application and its clients.

common/src/main/java/com/netflix/conductor/common/config · high confidence

The task metadata models in the common module have been significantly refactored to support enhanced observability and cleaner interfaces. A new ExecutionMetadata class has been introduced to capture detailed operational timing (such as server send time, client receive time, and network latency) and additional context, separate from the core task data. TaskResult has been updated to include a FAILED\_WITH\_TERMINAL\_ERROR status and uses protogen annotations for serialization, while Task now explicitly references the new TaskType enum (which includes new types like AGENT and NOOP) rather than inheriting from TaskResult. Additionally, new classes PollData and TaskExecLog have been added to track worker polling details and execution logs respectively, and TaskDef now includes validation constraints for timeouts and owner email.

common/src/main/java/com/netflix/conductor/common/metadata/tasks · high confidence

A new MetadataMapperService component now automatically resolves and embeds workflow and task definitions into workflow models and individual tasks during execution. This ensures that workflow definitions remain immutable and consistent throughout the lifecycle of a single execution, reducing load on the metadata storage layer. The service also handles missing task definitions by creating ad-hoc definitions for system tasks (disabling retries and timeouts) and automatically resolves the latest version for sub-workflows if no version is specified, throwing clear errors if definitions cannot be found.

core/src/main/java/com/netflix/conductor/core/metadata · high confidence

The workflow metadata models in the common module (including WorkflowDef, WorkflowTask, StartWorkflowRequest, and related classes) have been refactored to use the protogen framework for serialization. This change introduces @ProtoMessage and @ProtoField annotations to the data structures, standardizing how workflow definitions and execution requests are encoded for storage and inter-service communication, while also updating copyright headers to reflect the Conductor Authors project.

common/src/main/java/com/netflix/conductor/common/metadata/workflow · high confidence

The gRPC module's protocol buffer mapping logic has been restructured to improve robustness and clarity. The core mapping logic is now generated in a new \AbstractProtoMapper\ class, while \ProtoMapper\ handles custom conversions. This change specifically addresses the handling of nullable fields in \AbstractProtoMapper\ and introduces special-case logic in \ProtoMapper\ to correctly map \WorkflowTask\ retry counts (converting null to a sentinel value and back) and to properly serialize/deserialize JSON-native objects into Protobuf \Value\ types, ensuring that complex inputs and outputs are preserved accurately over the gRPC interface.

grpc/src/main/java · high confidence

The database migration scripts for populating historical workflow and task data have been corrected to handle timezone parsing and malformed data safely. The new V18.1 migration for end\_time uses a direct cast to timestamptz and a regex guard to ensure ISO-8601 values with 'Z' are interpreted as UTC without aborting on missing milliseconds, while the V13.2 update\_time backfill now correctly applies timezone conversion. These changes prevent migration failures and ensure historical executions sort and filter correctly based on their actual completion times.

_postgres-persistence/src/main/resources/db/migration\_postgres\data · high confidence

Added A2A protocol test resources and demo scripts; Added MySQL persistence integration tests; Added Spock-based test coverage for Cassandra DAOs and caching; Added benchmark suite for JavaScript engine performance; Added contract tests for SchemaDAO and ExecutionDAO persistence layers; Added integration test resources for Kafka module; Added integration tests for the Kafka publish task; Added test coverage for ES7 persistence layer; Added test coverage for ExecutionDAO and PollDataDAO; Added test coverage for SQLite persistence components; Added test coverage for core execution tasks; Added test coverage for event processing, script evaluation, and mock infrastructure; Added test logging configuration; Added test to verify OpenAPI document generation compatibility; Added tests for AsyncSystemTaskExecutor; Added tests for Cassandra authentication properties; Added tests for ConductorObjectMapper serialization; Added tests for ExecutionDAOFacade workflow retrieval and removal logic; Added tests for ExecutorUtils postpone logic and WorkflowSweeper repair behavior; Added tests for HTTP task input handling and REST template provider; Added tests for LocalOnlyLock behavior and configuration; Added tests for MetadataMapperService and validation utilities; Added tests for Redis concurrent execution limit DAO; Added tests for Redis health indicator; Added tests for TaskStatusListener enable/disable logic; Added tests for annotated system task workers and parameter/result mapping; Added tests for gRPC ProtoMapper workflow task serialization; Added tests for model input/output serialization; Added tests for server configuration and metrics wiring; Added tests for the Schema Service and Redis persistence; Added unit tests for AI model provider, LLM helper, and A2A agent workers; Added unit tests for DoWhile, Event, IsolatedTaskQueueProducer, and StartWorkflow tasks; Added unit tests for DummyPayloadStorage download functionality; Added unit tests for JavaScript and GraalJS evaluators; Added unit tests for Kafka publish task components; Added unit tests for REST controller layer; Added unit tests for REST controllers and security filters; Added unit tests for Redis distributed locking behavior; Added unit tests for Redis persistence DAOs; Added unit tests for WorkflowRepairService and WorkflowSweeper; Added unit tests for core service layer validation and behavior; Added unit tests for core utility classes and secrets DAOs; Added unit tests for gRPC service implementations; Added unit tests for metrics infrastructure and workflow monitoring; Added unit tests for the file storage subsystem; Added unit tests for workflow definition and task validation constraints; Added unit tests for workflow task mappers; Expanded test coverage for AgentSpan configuration, A2A integration, and listener composites; Expanded unit test coverage for common metadata and configuration classes; Expanded unit test coverage for workflow execution and decider logic; Initial UI test infrastructure and fixtures; New end-to-end tests for complex workflow control flows; New test utilities and base classes for integration testing; Removal of legacy TestConfiguration class; Removed Dynomite-specific Redis DAO tests and mock infrastructure; Removed Python unit tests for WFClient; Removed SQS queue integration tests; Removed legacy HTTP task integration tests; Removed obsolete TestWorker unit test; Removed obsolete test files for query parser; Removed test for WorkflowTask serialization; Test harness now uses Testcontainers for Redis and Elasticsearch infrastructure.

The project now uses a centralized \dependencies.gradle\ file to define and pin versions for all libraries, including Spring AI (1.1.6), AWS SDK (2.31.68), and Elasticsearch clients (7.17.29, 8.19.11). This change introduces explicit version pinning for critical artifacts like protobuf-java (3.25.5) and GraalVM polyglot (25.0.2) to resolve compatibility issues, and updates AMQP client to 5.35.0 to address security vulnerabilities. Individual module \build.gradle\ files have been updated to reference these centralized variables, ensuring consistent dependency resolution across the multi-module build.

(dependencies) · high confidence

The Gradle wrapper configuration has been updated to download and use Gradle 8.14.3, replacing the previous version 2.14. This change ensures that builds are executed with a significantly newer version of the Gradle build tool, which may bring performance improvements, bug fixes, and compatibility with newer Java versions.

gradle · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 50 → 51 (+1.3)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 79 → 77 (-1.0)
• Architecture 54 → 66 (+11.8)
• Maturity 83 → 76 (-6.7)
• Readiness 53 → 49 (-4.2)
• Security 58 → 68 (+9.6)
• Accessibility 41 → 42 (+0.5)

• AbstractProtoMapper.toProto (cognitive 16) (grpc/src/main/java/com/netflix/conductor/grpc/AbstractProtoMapper.java)
• AbstractProtoMapper.toProto (cognitive 16) (grpc/src/main/java/com/netflix/conductor/grpc/AbstractProtoMapper.java)
• AbstractProtoMapper.toProto (cognitive 17) (grpc/src/main/java/com/netflix/conductor/grpc/AbstractProtoMapper.java)
• AbstractProtoMapper.toProto (cognitive 18) (grpc/src/main/java/com/netflix/conductor/grpc/AbstractProtoMapper.java)
• AbstractProtoMapper.toProto (cognitive 24) (grpc/src/main/java/com/netflix/conductor/grpc/AbstractProtoMapper.java)
• AbstractProtoMapper.toProto (cognitive 29) (grpc/src/main/java/com/netflix/conductor/grpc/AbstractProtoMapper.java)
• Coverage not included — suite not readable by the collector
• Critical CVE: [GHSA redacted] (ui/package-lock.json)
• Critical CVE: [GHSA redacted] (ui/package-lock.json)
• Critical CVE: [GHSA redacted] (ui/package-lock.json)
• Critical CVE: [GHSA redacted] (ui/package-lock.json)
• Critical CVE: [GHSA redacted] (ui/package-lock.json)
• Critical CVE: [GHSA redacted] (ui/package-lock.json)
• Dependency hygiene not measured — dependency manifest found but not parsed for hygiene
• DoWhileTests.testDoWhileScriptIsNotEvaledEarlyWhenSyncSystemTaskInside (cognitive 19) (e2e/src/test/java/io/conductor/e2e/control/DoWhileTests.java)
• Duplicated block (10 lines × 2) (agentspan/src/main/java/org/conductoross/conductor/ai/agentspan/a2a/A2ANativeAgentFacade.java)
• Duplicated block (10 lines × 2) (agentspan/src/main/java/org/conductoross/conductor/ai/agentspan/a2a/A2ANativeAgentFacade.java)
• Duplicated block (10 lines × 2) (agentspan/src/main/java/org/conductoross/conductor/ai/agentspan/runtime/compiler/AgentCompiler.java)
• Duplicated block (10 lines × 2) (agentspan/src/main/java/org/conductoross/conductor/ai/agentspan/runtime/compiler/AgentCompiler.java)
• Duplicated block (10 lines × 2) (agentspan/src/main/java/org/conductoross/conductor/ai/agentspan/runtime/compiler/AgentCompiler.java)
• …and 554 more

• AbstractProtoMapper.toProto (cognitive 16) (grpc/src/main/java/com/netflix/conductor/grpc/AbstractProtoMapper.java)
• AbstractProtoMapper.toProto (cognitive 16) (grpc/src/main/java/com/netflix/conductor/grpc/AbstractProtoMapper.java)
• AbstractProtoMapper.toProto (cognitive 17) (grpc/src/main/java/com/netflix/conductor/grpc/AbstractProtoMapper.java)
• AbstractProtoMapper.toProto (cognitive 18) (grpc/src/main/java/com/netflix/conductor/grpc/AbstractProtoMapper.java)
• AbstractProtoMapper.toProto (cognitive 25) (grpc/src/main/java/com/netflix/conductor/grpc/AbstractProtoMapper.java)
• AbstractProtoMapper.toProto (cognitive 29) (grpc/src/main/java/com/netflix/conductor/grpc/AbstractProtoMapper.java)
• ActionModule.ActionModule (cognitive 18) (ui-next/src/pages/execution/ActionModule.jsx)
• AddTaskSidebar.AddTaskSidebar (cognitive 45) (ui-next/src/components/features/flow/components/RichAddTaskMenu/AddTaskSidebar.tsx)
• AddTaskSidebar.AddTaskSidebar (cyclomatic 42) (ui-next/src/components/features/flow/components/RichAddTaskMenu/AddTaskSidebar.tsx)
• AdvancedSearch.AdvancedSearch (cognitive 37) (ui-next/src/pages/agent/executions/workflowSearchComponents/AdvancedSearch.tsx)
• AdvancedSearch.AdvancedSearch (cognitive 37) (ui-next/src/pages/executions/workflowSearchComponents/AdvancedSearch.tsx)
• AdvancedSearch.AdvancedSearch (cyclomatic 33) (ui-next/src/pages/agent/executions/workflowSearchComponents/AdvancedSearch.tsx)
• AdvancedSearch.AdvancedSearch (cyclomatic 33) (ui-next/src/pages/executions/workflowSearchComponents/AdvancedSearch.tsx)
• AgentDefinitionView.NodeCard (cyclomatic 19) (ui-next/src/pages/execution/AgentExecution/AgentDefinitionView.tsx)
• AgentDefinitionView.buildDefDiagram (cognitive 29) (ui-next/src/pages/execution/AgentExecution/AgentDefinitionView.tsx)
• AgentDefinitionView.buildDefDiagram (cyclomatic 19) (ui-next/src/pages/execution/AgentExecution/AgentDefinitionView.tsx)
• AgentDetailPanel.AgentDetailPanel (cognitive 36) (ui-next/src/pages/execution/AgentExecution/AgentDetailPanel.tsx)
• AgentDetailPanel.AgentDetailPanel (cyclomatic 43) (ui-next/src/pages/execution/AgentExecution/AgentDetailPanel.tsx)
• AgentDetailPanel.AgentInspector (cyclomatic 20) (ui-next/src/pages/execution/AgentExecution/AgentDetailPanel.tsx)
• AgentDetailPanel.GroupDetailPanel (cognitive 21) (ui-next/src/pages/execution/AgentExecution/AgentDetailPanel.tsx)
• …and 1839 more

• 105 commits — 65 feature/other, 40 fixes

• ui-next/src — 35 commits
• (repo) — 15 commits
• agentspan/src — 8 commits
• .github/workflows — 7 commits
• core/src — 7 commits
• (root) — 6 commits
• ui-next/e2e — 5 commits
• ai/src — 3 commits
• docs/devguide — 3 commits
• postgres-persistence/src — 3 commits
• es8-persistence/src — 2 commits
• task-status-listener/src — 2 commits
• ai/README.md — 1 commit
• ai/examples — 1 commit
• cassandra-persistence/src — 1 commit
• common/src — 1 commit
• docs/documentation — 1 commit
• mysql-persistence/src — 1 commit
• redis-configuration/src — 1 commit
• sqlite-persistence/src — 1 commit

• fix: Fix #1569 Postgres metadata status codes (#1571)
• fix: Fix docs deploy: make main.py importable in the mkdocs container
• fix: Fix flaky test (#1597)
• fix: Fix inconsistent ES8 workflow state refresh handling (#1012)
• fix: Fix incorrect conductor version when app is loading (#1511)
• fix: Fix monaco editor context menu paste by forcing loader to use monaco 0.56.0 (#1541)
• fix: Fix references to design docs removed from the repo (#1555)
• fix: Fix sync-execute param docs: remove nonexistent EVENTUAL value, document returnStrategy options (#1579)
• fix: Fix tool-call selection and naming in the agent event listener (#1610)
• fix: Fix/agent execution diagram fixes (#1488)
• fix: Merge branch 'main' into fix/index-end-time-sort
• fix: Merge pull request #1517 from conductor-oss/fix/index-end-time-sort
• fix: Merge pull request #1520 from conductor-oss/feature/agent-mcp-fixes
• fix: [CCOR-13375]fix:agent guide scroll stuck
• fix: [CCOR-13376]fix:update example links of java agent create page (#1634)
• fix: [CCOR-13383]fix:task definition form missing fields (#1586)
• fix: [CCOR-13460]fix: open sub-workflow definition when the version is blank (#1605)
• fix: [CCOR-13474]fix: copy token via sidebar user block extension point (#1606)
• fix: fix(agentspan): preserve MCP tool outputs
• fix: fix(agentspan,ui-next): fix swarm handoff turn-skip scoping and agent diagram rendering
• …and 85 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

conductor-oss/conductor was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.