Accenture/mercury-composable

This system is a polyglot, event-driven application framework that facilitates the development of distributed microservices through a layered architecture of composable functions, YAML-defined flows, and active knowledge graphs. It provides robust infrastructure for service discovery, presence monitoring, and Kafka-based pub/sub communication, while supporting synchronous REST interactions over asynchronous backends via Redis coordination. The platform also includes a dedicated environment for visual graph authoring and AI agent integration, enabling developers to build, test, and deploy complex, event-sourced applications with built-in observability and security features.

62 changes.

This period focused on establishing the foundational infrastructure for the Platform Lambda framework, introducing core modules for HTTP automation, WebSocket communication, and cloud connector adapters, particularly for Kafka. It also expanded the ecosystem with comprehensive example applications and a new Event Script engine to demonstrate event-driven patterns and workflow orchestration.

93 changes.

This period focused on the initial release of the MiniGraph Playground Engine, introducing interactive graph authoring, AI agent integration, and a comprehensive suite of graph skills. Concurrently, the platform expanded its distributed infrastructure with a Redis-backed synchronous-over-async pattern, reactive PostgreSQL support, and advanced Kafka routing capabilities.

The API Playground extension now includes backend services that allow users to list and view Swagger/OpenAPI definition files. A new entry point (MainApp) initializes the application using AutoStart, while two pre-loaded Lambda functions handle the core functionality: CountSwaggerFiles exposes a route to list all available Swagger files found in the /sample/yaml resource directory, and ViewSwaggerFile provides a route to retrieve the content of a specific Swagger file by filename. These services enable the playground to dynamically discover and serve API specifications for testing and exploration.

extensions/api-playground/src/main/java · high confidence

This change introduces a new Kafka-based cloud connector adapter, including the \kafka-connector\ library and a \kafka-presence\ monitor application for service discovery. It adds comprehensive documentation explaining how to enable the connector via configuration, set up the presence monitor, and configure Kafka connections for development or cloud deployment. The update also includes standard build artifacts (gitignore, cleanup scripts) for the new connector modules.

connectors · high confidence

Introduces a new Kotlin-based example application that demonstrates user profile CRUD operations (create, read, delete) using the Platform Lambda framework. The example includes data models, Lambda functions for profile handling, and a REST automation layer exposing endpoints at /api/profile. It features a flow-based architecture with YAML definitions for orchestration, including field-level encryption and decryption using AES-256 keys, and demonstrates async response patterns and exception handling.

examples/kotlin-example/src/main · high confidence

The sync-over-async demo now ships with Spring Boot profiles and YAML flow definitions for its facade, backend, stream-producer, and stream-ui roles. The facade profile exposes REST endpoints (including JSON Schema and Avro variants) and enables the Redis return-route coordinator, while the backend profile disables REST and the coordinator to act as a pure system-of-record. Stream roles are configured for broker-free Redis streaming, and Kafka adapters are defined to route requests and replies through JSON Schema and Avro transport paths.

examples/sync-over-async-demo/src/main/resources · high confidence

Introduces MiniGraph, a new in-memory minimalist property graph designed to handle a small number of nodes efficiently within event flow instances. This component provides a memory-based structure for processing across multiple tasks, featuring unique graph IDs, node and connection management, and serialization capabilities for exporting and importing graph states.

system/platform-core/src/main/java/org/platformlambda/core/graph · high confidence

The kafka-demo example now includes a Java-based worked example demonstrating second-level routing within the Platform Lambda framework. The demo features a MainApp entry point and four processor tasks: DemoProcessor for basic inbound message handling with trace continuity, OrderProcessor for routing based on header values, RefundProcessor for direct task invocation based on payload content, and CatchAllProcessor as a default handler for unmatched records. This provides users with a concrete reference implementation for building Kafka-integrated applications with advanced routing capabilities.

examples/kafka-demo/src/main/java, examples/kafka-demo/src/main/resources · high confidence

A new worked example in \examples/schema-registry-demo\ demonstrates how to interact with the Confluent-compatible Schema Registry mock. The demo includes two Node.js scripts (\register-schema.mjs\ and \get-schema.mjs\) that allow users to register schemas and fetch them by ID without requiring external npm dependencies, alongside sample Avro and JSON Schema files for testing.

examples/schema-registry-demo · high confidence

A new index.html landing page has been added to the composable-example application, providing direct links to various informational endpoints (INFO, Library dependency, Routing, Health, Environment) and specifically highlighting the new Event Script demo for hypothetical profile management.

examples/composable-example/src/main/resources/public · high confidence

New property files have been added to provide configuration templates for a secondary Kafka cluster, enabling dual-cluster connectivity. The set includes secondary-kafka-consumer.properties, secondary-kafka-producer.properties, and secondary-schema-registry.properties. These templates allow users to configure connection details, security protocols (such as SASL\_SSL and OAuth 2.0), and schema registry endpoints for the secondary environment, with sensible defaults like the 8092 port for local dual-broker setups.

system/twin-kafka/src/main/resources · high confidence

The Kafka connector now includes a default properties file (kafka.properties) with a sample bootstrap server address (127.0.0.1:9092) for development and testing, and a new presence connector configuration file (presence.properties) defining default WebSocket URLs for the presence monitor cluster. These files provide out-of-the-box connectivity settings for local environments.

connectors/adapters/kafka/kafka-connector/src/main/resources · high confidence

The composable example application now includes a new DemoHealth service that implements the standard health check interface. This service responds to INFO requests with metadata about the demo service and to HEALTH requests with a status confirmation, providing a template for implementing downstream service health checks in the example.

examples/composable-example/src/main/java/com/accenture/demo/services · high confidence

The Lambda example now includes a public index page that provides direct navigation links to the application's INFO, Library dependency, Routing information, Health, and Environment endpoints, allowing users to easily explore the demo features.

examples/lambda-example/src/main/resources/public · high confidence

A new worked example application has been added to demonstrate the sync-over-async pattern using the Platform Lambda framework. The \MainApp\ entry point supports two operational modes via Spring profiles: the 'facade' profile exposes a synchronous REST endpoint (\POST /api/sync-to-async\) that blocks while waiting for an asynchronous reply delivered via Redis, and the 'backend' profile consumes requests from a Kafka topic and publishes responses back to the reply queue. This example illustrates how to coordinate synchronous client waits with asynchronous backend processing using a Redis-based return route.

examples/sync-over-async-demo/src/main/java/com/accenture/soa/demo · high confidence

The platform now automatically splits large event payloads into smaller blocks when sending over WebSocket connections, ensuring reliable delivery of data that exceeds the configured maximum size (default 65,536 bytes). Incoming segmented blocks are reassembled transparently before being processed, allowing applications to handle large binary data without manual chunking logic.

system/platform-core/src/main/java/org/platformlambda/core/websocket/common · high confidence

The lambda-example now includes a comprehensive set of service demos that illustrate advanced Platform Lambda capabilities. Users can explore progressive result set rendering via Server-Sent Events (HelloSse), request-response patterns with virtual thread suspension and timeout handling (HelloRpc), and cross-runtime event streaming through a remote relay (HelloRemoteRelay). The example also demonstrates file handling with both upload (FileUploadDemo) and download (FileDownloadDemo) flows, generic type transport (HelloGeneric), and authentication integration (AuthDemo, EventApiAuth). These additions provide concrete reference implementations for building non-blocking, event-driven REST endpoints without framework dependencies.

examples/lambda-example/src/main/java/org/platformlambda/services · high confidence

The platform now supports HTTP response streaming, allowing progressive rendering of multi-shot replies over the multi-shot reply route via the new EventStreamRenderer and AsyncHttpResponse services. Additionally, trace-id and correlation-id HTTP headers are now configurable via properties (e.g., http.trace.id.header), enabling per-entry overrides for legacy impedance matching and W3C traceparent header customization.

system/platform-core/src/main/java/org/platformlambda/automation/services · high confidence

The API Playground extension now includes its core configuration and sample resources. An \application.properties\ file sets up the application name, server ports (8200/8222), static content locations, and enables snake\_case serialization. A \rest.yaml\ file defines the REST automation rules for the \/api/specs\ endpoints, including CORS policies and header manipulation (e.g., adding security headers like HSTS and cache-control). Additionally, a sample OpenAPI 3.0 specification (\demo.yaml\) is provided to demonstrate the playground's capabilities, and a placeholder \index.html\ warns if the Swagger UI distribution is missing.

extensions/api-playground/src/main/resources · high confidence

The Kafka Presence Monitor connector now includes its core configuration files and a basic web interface. An application.properties file defines the service name, server port (8080), Kafka connection settings (including a default bootstrap server at 127.0.0.1:9092), and topic configurations. A separate kafka.properties file provides sample Kafka connection details. Additionally, a public/index.html page is added to serve as the entry point, providing links to the application's info, library dependency, and health endpoints.

connectors/adapters/kafka/kafka-presence/src/main/resources · high confidence

The Presence Monitor service now includes its foundational configuration and user interface assets. An application.properties file defines the service as 'presence-monitor' on port 8080, configures Kafka connectivity (defaulting to localhost:9092 for development), and sets up static resource serving. A kafka.properties file provides example SASL authentication settings and a default standalone Kafka connection. Additionally, a public/index.html page is added to serve as the entry point, providing direct links to the /info, /info/lib, and /health endpoints.

connectors/core/service-monitor/src/main/resources · high confidence

Added the initial session logs for the documentation rewrite effort to the \memory/sessions\ directory. These files record the bootstrap of the official GitHub repository, the structural re-architecture of the documentation into a layered Part I–VI skeleton, the creation of deterministic DSL specification kits for MiniGraph, Event Script, and REST automation, and the migration of legacy chapters to semantic slugs with redirects.

memory/sessions · high confidence

The repository is initialized with foundational configuration and documentation files. This includes standard project metadata (LICENSE, CODE\_OF\_CONDUCT, CONTRIBUTING), build environment settings (.java-version, .gitattributes, .gitignore), and a structured AI agent memory system (AGENTS.md, memory/PROTOCOL.md, DECAY.md) along with IDE-specific steering files (.cursorrules, CLAUDE.md, GEMINI.md) to guide developer assistants.

(repo-wide) · high confidence

Adds a new standalone service that exposes Mercury's operational contracts to AI agents via a dedicated REST API on port 8999. The service provides endpoints to list contracts, view details, and access a packaged offline skill snapshot (including SKILL.md and reference guides) for version-matched, immutable documentation. It also includes a local export capability to generate a verifiable skill manifest with SHA-256 hashes.

system/ai-contract-provider/src/main/resources · high confidence

The system now includes a new Event Script engine that allows defining and running asynchronous workflows via YAML configuration files. This change adds a compile-time phase (CompileFlows) that validates and loads flow definitions, a runtime engine (EventScriptManager and TaskExecutor) that manages flow instances, task execution, and state, and an HTTP adapter (HttpToFlow) that bridges incoming HTTP requests into the flow execution context. The engine supports data mapping, simple plugins for type conversion and logic, and preserves business correlation IDs across the flow lifecycle.

system/event-script-engine/src/main · high confidence

The benchmark module now includes a new \benchmark-reporter\ harness that generates self-contained HTML reports to track performance trends across milestone releases. This replaces the retired \benchmark-client\ and provides a standardized way to validate that changes (such as the recent Berkeley DB retirement) do not regress latency or throughput. The module includes a \BENCHMARK-LOG.md\ to record release-over-release findings and committed HTML snapshots (\analysis/\) documenting the historical comparison between the file-based and Berkeley DB stores, serving as a regression baseline for future updates.

benchmark · high confidence

The system/mini-scheduler module adds a new capability to schedule and execute tasks or flows using Quartz cron expressions defined in a YAML configuration file. Users can define jobs with specific services or flows, optional parameters, and a state resolver to manage execution state. The scheduler supports clustering via a configurable state resolver to prevent duplicate executions across multiple instances, and includes a 'deferred start' feature that adds a randomized 0-9 second delay to reduce race conditions. It also offers a backward-compatible leader election mechanism for environments using a service mesh like Kafka.

system/mini-scheduler · high confidence

Adds a new reactive Postgres extension that provides a Spring R2DBC-based connection pool, a \PgService\ to handle query, update, and transaction requests, and a \PgHealth\ lambda that automatically maintains a \health\_check\ table (created via \pg-schema.sql\) to track application instance status and periodically clean up stale records. The extension also includes a \PgRequest\ helper for convenient SQL execution and a \RowParser\ for mapping database rows to maps or POJOs.

extensions/reactive-postgres/src/main · high confidence

The sync-over-async extension now uses Redis as the shared coordination layer for both one-shot synchronous requests and long-lived streaming responses. A new ReturnRouteCoordinator manages per-pod rendezvous by storing return channels and segment queues in Redis, while PendingRequests and PendingStreams enforce per-pod capacity limits for in-flight requests and open streams. Producers use StreamResponder to append segments to Redis queues and wake consumers via Pub/Sub, and consumers use StreamBridge to bridge the Redis drain to HTTP Server-Sent Events (SSE) with idle-expiry watchdogs. Configuration is externalized to the soa.redis.\* namespace (with redis.\* fallback) and includes tunables for TTLs and pending limits, with a dedicated SoaRedisHealthCheck for monitoring.

extensions/sync-over-async/src/main/java/org/platformlambda/sync · high confidence

The platform-core module now includes a new \ConfigBase\ interface and a \PlatformConstants\ class to standardize application configuration management. The \ConfigBase\ interface defines the contract for retrieving properties, checking existence, and accessing composite key values, while \PlatformConstants\ introduces a specific constant for worker instance prefixes (\worker.instances.\). These additions provide a foundational API for configuration handling within the system.

system/platform-core/src/main/java/org/platformlambda/core/util/common · high confidence

The Kafka Flow Adapter now supports subscribing to topics via regex patterns (topic-pattern) in addition to literal names, allowing new matching topics to be picked up automatically. It adds second-level routing, enabling per-message dispatch to different flows or tasks based on record content using a rule set. Users can also opt into Confluent Schema Registry decoding for strict deserialization or best-effort JSON deserialization on non-schema topics. The adapter includes partition pinning for manual assignment, configurable dead-letter topics per binding, and auto-commit mode for higher throughput. Additionally, it supports configurable trace-id, correlation-id, and traceparent header overrides for impedance matching with upstream systems.

system/minimalist-kafka/src/main · high confidence

The lambda-example resource directory now includes several new configuration files to demonstrate platform features. app-log-context.yaml defines a sample structure for application log context, mapping tokens like trace ID and service name to output keys when JSON logging is active. event-over-http.yaml configures routes for the Event-over-HTTP demo, pointing to local targets for 'hello.world' and 'hello.tokens'. application.properties sets up the basic application properties, including REST automation, logging format, and a demo peer token for authentication. rest.yaml defines multiple REST endpoints for demos such as hello.world, hello.sse (streaming), hello.rpc, and hello.upload, along with CORS and header configurations. errorPage.html and helloworld.txt are added as static resources for error handling and file download demonstrations.

examples/lambda-example/src/main/resources · high confidence

The starter-graph template now provides a complete 'Layer 3' application structure where the application logic is defined by a deployed knowledge graph rather than traditional code. It includes a 'starter-quote' graph model that validates input and returns pricing, exposed via a REST endpoint at /api/graph/{graph\_id}. The template enforces a 'compiled or 404' security gate, ensuring only graphs listed in the manifest are executable. Additionally, it enables a 'dev' environment mode by default, which activates the MiniGraph Playground UI, WebSocket sessions, and an AI companion endpoint for interactive graph authoring.

templates/starter-graph · high confidence

The MiniGraph Playground Engine is introduced as a developer-focused environment for creating, testing, and executing Active Knowledge Graphs. It provides a self-service interactive UI for visual graph modeling (including node creation, editing, deletion, and multi-select workspace clipping) and a graph execution engine with built-in skills like data mapping, math evaluation, and API fetching. The engine exposes a synchronous companion endpoint (\/api/companion/{id}/sync\) allowing external scripts, test harnesses, or AI agents to drive Playground sessions over plain HTTP, while the UI communicates with the backend via WebSocket for real-time console output and graph state updates.

system/minigraph-playground-engine · high confidence

The MiniGraph Playground example now includes a new \LlmStreamRelay\ component and \/api/llm/stream\ endpoint that forwards requests to a polyglot peer (e.g., a Python demo app) and renders the provider's real token stream as Server-Sent Events (SSE) to the client. It also ships with a 'support-triage' graph model demonstrating bounded-agency orchestration, where an LLM classifies requests into categories (bug, feature, question) and the graph logic routes the outcome. Configuration for these features is provided via \event-over-http.yaml\ (mapping \llm.stream\ and \llm.chat\ routes) and \graphs.yaml\ (registering the new model).

examples/minigraph-playground/src/main · high confidence

The MiniGraph Playground engine now ships with its core runtime configuration and a comprehensive set of tutorial examples. An application.properties file establishes the service as 'minigraph-playground' on port 8085, enables structured JSON traversal logging for analytics, and configures the engine to load flow definitions from classpath resources. The flows.yaml manifest registers the 'graph-executor' and 'flow-11' event flows, which handle active graph traversal and input echoing respectively. Additionally, the engine includes a full suite of tutorial graph definitions (tutorial-1 through tutorial-14) covering basic data mapping, API fetching with data dictionaries, parallel composition, modules, and complex multi-step workflows with suspension and resumption. Help documentation for graph creation, editing, and command syntax is also provided to guide users.

system/minigraph-playground-engine/src/main/resources · high confidence

A new standalone Mercury application, the AI Contract Provider, has been added to expose operational contracts and packaged documentation to AI agents. It runs as a read-only REST discovery server (default port 8999) that serves a version-matched snapshot of the platform's guides and references. The service provides endpoints to list installed contracts, view detailed contract metadata (including behavior anchors and references), retrieve specific documentation files, and access a deterministic manifest with per-file SHA-256 hashes. Additionally, it supports an offline skill export mode (via the \--export\ flag) that writes the complete rendered snapshot to a local directory, ensuring consistency between the runtime API and the exported files through rigorous verification and cleanup logic.

system/ai-contract-provider/src/main/java · high confidence

The composable-example now includes a Java-based demonstration application that showcases profile lifecycle management (create, read, save, delete) and event-driven communication patterns. The example introduces several new components: data models for profiles and confirmations, a main application entry point that initializes a demo encryption key, and a suite of task handlers. These handlers implement field-level encryption and decryption using AES, profile persistence to a local file store, and an Event-over-HTTP RPC pattern that programmatically calls a peer service. Additionally, it includes an exception handler that demonstrates adding user-defined context to logs.

examples/composable-example/src/main/java/com/accenture/demo/tasks · high confidence

The Kafka connector module now includes the KafkaConnector class, which handles initialization, configuration loading from file or classpath, and broker reachability checks, alongside a new PubSubSetup cloud service that enables standalone streaming pub/sub capabilities for user applications. This change introduces the core infrastructure for Kafka integration within the Platform Lambda framework, allowing applications to leverage Kafka for both system-level service mesh functions and user-level pub/sub communication.

connectors/adapters/kafka/kafka-connector/src/main/java/org/platformlambda/kafka · high confidence

This change introduces three new Java classes in the Kafka connector adapter: EventConsumer, PubSubManager, and TopicManager. EventConsumer handles polling Kafka topics and processing records, supporting virtual topic substitution and partition assignment. PubSubManager implements the PubSubProvider interface to manage event publishing and topic lifecycle operations (create, delete, list, exists) via the cloud manager. TopicManager acts as a Lambda function to handle administrative requests for topic management, including creating and deleting topics through the Kafka AdminClient. These services enable the platform to integrate with Kafka for event-driven communication.

connectors/adapters/kafka/kafka-connector/src/main/java/org/platformlambda/kafka/services · high confidence

A new helper application is introduced in helpers/kafka-standalone to run an embedded Kafka server for local development and testing. It boots a single broker by default on port 9092, and can start a second broker on port 8092 when dual.servers=true is set in application.properties or via the -Ddual.servers=true runtime flag. The helper uses Java 21, ships with a Dockerfile, and includes end-to-end tests that verify message round-trips across both brokers.

helpers/kafka-standalone · high confidence

A new PresenceConnector class has been added to the cloud-connector module to manage WebSocket connection states and coordinate with the service registry. This component handles open and close events to track connectivity, sends periodic keep-alive signals, and notifies the service registry when instances leave, ensuring accurate routing and presence information for the platform.

connectors/core/cloud-connector/src/main/java/org/platformlambda/cloud/reporter · high confidence

The playground engine now exposes several new REST endpoints to enhance debugging and AI integration. Users can inspect the current state of a graph model via the new \DescribeGraph\ endpoint, which returns a 404 for missing drafts. Live graph sessions are accessible through \GetLiveGraph\, and state machine inspection is available via \InspectStateMachine\, which wraps results in a consistent \{inspect, outcome}\ envelope. The synchronous AI-companion endpoint (\PostCompanionCommandSync\) replaces the retired async version, returning command outcomes in-band to allow AI agents to self-correct, while still teeing output to the WebSocket console for human observers. Additionally, new endpoints \GetIndexHtml\ and \GetWsHtml\ serve the playground UI and WebSocket test pages, and \UploadJsonContent\/\UploadMockContent\ allow uploading data to active sessions.

system/minigraph-playground-engine/src/main/java/com/accenture/minigraph/rest · high confidence

A new example application demonstrates building a composable Spring Boot 4 app using platform-core. It includes REST endpoints for single and concurrent async requests, a WebSocket echo service, and a legacy servlet, along with a browser-based WebSocket client and unit tests to verify the behavior.

examples/rest-spring-4-example · high confidence

The playground engine now exposes two new WebSocket services: a 'graph' endpoint that accepts minigraph commands via POST-style message bodies and manages session lifecycle, and a 'json' endpoint that allows users to load, upload, and query XML or JSON data using simple text commands or JSON-Path expressions. This enables direct interaction with graph logic and data structures through the browser's WebSocket interface without relying on the previous REST-only companion approach.

system/minigraph-playground-engine/src/main/java/com/accenture/minigraph/websocket · high confidence

The platform-core module now includes a new WebSocket server implementation consisting of WsEnvelope, WsHandshakeHandler, WsRequestHandler, and WsServerTransmitter. This adds a new system-level WebSocket handshake handler that validates and accepts connections based on configured paths, a request handler that manages WebSocket sessions with automatic idle connection cleanup, and a transmitter that routes messages between the WebSocket and the platform's event system. The implementation supports both binary and text message types, handles connection lifecycle events (open, close, exceptions), and includes built-in housekeeping to remove expired connections.

system/platform-core/src/main/java/org/platformlambda/core/websocket/server · high confidence

The agent-skills directory now includes three new tool-managed skills provided by agent-memory: \apply-critique\ guides the agent through a bounded, human-gated loop to apply reviewer feedback with deterministic validation; \harvest-knowledge\ allows on-demand, incremental syncing of documentation changes into the shared memory layer; and \archive-fact\ provides safe, script-based execution for moving decayed facts to the archive in both Python and Node.js, preventing file truncation errors. These skills are accompanied by their respective documentation and, for \archive-fact\, cross-runtime test suites to ensure parity.

agent-skills · high confidence

The engine now includes a new @FetchFeature annotation to mark feature implementations, along with two new features: LogRequestHeaders and LogResponseHeaders. LogRequestHeaders runs before the main fetch logic and stores incoming request headers in the state machine under the node's request namespace, while LogResponseHeaders runs after and stores outgoing response headers under the response namespace, enabling users to inspect HTTP headers via the state machine.

system/minigraph-playground-engine/src/main/java/com/accenture/minigraph/annotations, system/minigraph-playground-engine/src/main/java/com/accenture/minigraph/features · high confidence

Added two new core classes to the platform-core HTTP automation package: AsyncHttpClient, which manages outbound HTTP requests using Reactor Netty with configurable timeouts and temporary file handling, and HttpRequestHandler, which processes incoming HTTP requests by routing them through the platform's event system. These components enable the platform to act as both an asynchronous HTTP client for outbound calls and a request handler for inbound traffic, integrating with the existing HttpRouter and event streaming infrastructure.

system/platform-core/src/main/java/org/platformlambda/automation/http · high confidence

The cloud connector module now includes three new core classes: ConnectorConfig, which centralizes application configuration and supports optional static topic substitution via YAML; EventProducer, which handles event publishing, destination resolution, and round-robin load balancing for segmented messages; and ServiceLifeCycle, which manages service initialization sequences and readiness signaling through timed event polling.

connectors/core/cloud-connector/src/main/java/org/platformlambda/cloud · high confidence

The event-script-engine now exposes three new collection operators—isEmpty, getFirst, and getLast—allowing users to check if collections, maps, strings, or arrays are empty, and to retrieve the first or last element of a list. These operators are implemented as new plugin classes (IsEmptyOperator, GetFirstOperator, GetLastOperator) within the collection plugin package, providing direct access to these common data manipulation capabilities in script contexts.

system/event-script-engine/src/main/java/com/accenture/services/plugins/collection · high confidence

This change introduces a set of new resource files for the composable-example, establishing its runtime configuration and API definitions. The application.properties file sets up JSON logging, OpenTelemetry trace forwarding (disabled by default), and REST server ports. The app-log-context.yaml file configures structured logging context, mapping trace IDs and correlation IDs to snake\_case keys. REST endpoints are defined in rest.yaml, exposing profile management and event-over-HTTP routes via the flow adapter, along with CORS and header filtering rules. Additional files include flows.yaml to list available event flows, event-over-http.yaml to configure declarative peer-to-peer event routing, and errorPage.html for custom error display.

examples/composable-example/src/main/resources · high confidence

The platform introduces a suite of new annotations in the core module to define application structure and behavior. \PreLoad\ configures preloaded services with options for custom serializers, instance counts, and serialization strategies. \BeforeApplication\ and \MainApplication\ manage the startup sequence, allowing developers to specify execution order for initialization and main application logic. Cloud integration is supported via \CloudConnector\ and \CloudService\ annotations for pluggable cloud modules. Execution control is enhanced with \KernelThreadRunner\ for CPU-intensive tasks and \ZeroTracing\ to disable tracing. Additional annotations include \EventInterceptor\ for request interception, \WebSocketService\ for WebSocket handlers, and \OptionalService\ for conditional module loading based on configuration properties.

system/platform-core/src/main/java/org/platformlambda/core/annotations · high confidence

The platform-core module introduces a set of foundational classes that define how the system handles requests, events, and errors. A new AppException class allows functions to return specific HTTP status codes with custom messages. The EventEnvelope model now supports a language-neutral wire format (STANDARD) alongside the existing compact format, enabling interoperability with other languages via MsgPack. Request handling is centralized in AsyncHttpRequest, which provides methods to parse URLs, query parameters, and headers. Asynchronous communication patterns are formalized through AsyncInbox, FutureInbox, and their multi-response counterparts, which manage timeouts, correlation IDs, and distributed tracing metadata for RPC calls. Additionally, interfaces like CustomSerializer and CloudSetup provide extension points for serialization and cloud-specific initialization.

system/platform-core/src/main/java/org/platformlambda/core/models · high confidence

The platform-core module introduces several new internal services to support system operations. ActuatorServices provides a unified actuator interface for health, liveness, info, routes, and environment checks, with tunable instance counts via environment variables. EventApiService handles Event-over-HTTP requests, supporting RPC, async drop-and-forget, and SSE streaming modes while preserving trace context and wire formats. NoOpFunction serves as a convenient echo function for event scripts. Telemetry intercepts distributed tracing and journaling events, forwarding metrics to optional forwarders and journal recorders. TemporaryInbox manages composite correlation IDs for async multi-inbox patterns.

system/platform-core/src/main/java/org/platformlambda/core/services · high confidence

A new distributed cache extension is available, exposing the \v1.cache.redis\ function for standard cache operations including GET, PUT, DELETE, MGET, MPUT, and list management (PUSH, POP, LEN). The implementation uses a single shared, multiplexed Redis connection for all worker instances to maximize efficiency, and ensures cluster safety by using atomic TTL assignment (e.g., \SETEX\, \SET NX EX\) for all keys. It supports optional key prefixing for multi-tenant isolation and includes a dedicated \redis.health\ check. The cache is opt-in via \redis.cache.enabled\ and reads connection settings from the shared \redis.\*\ namespace.

extensions/distributed-cache, extensions/redis-connection · high confidence

The \examples/distributed-cache-example\ now provides a worked demonstration of the \v1.cache.redis\ distributed-cache module, showing how the same profile data can be stored and retrieved unchanged across three distinct application layers: Layer 1 (event-driven code), Layer 2 (Event Script flows), and Layer 3 (Knowledge Graph). The example uses a shared Redis instance and a plain MsgPack wire format to ensure that a profile written via one layer is readable by the others. It includes a Node.js \playground-session-broker\ script to allow AI agents to host MiniGraph Playground sessions for graph co-authoring, and enables dev-mode features like the Playground UI and AI companion endpoints when \app.env=dev\ is set.

examples/distributed-cache-example · high confidence

Added four new Python scripts to the \scripts/\ directory to enforce consistency between documentation/specs and the engine codebase. \check-doc-canon.py\ validates the documentation structure (slugs, frontmatter, BOM, banned terminology, llms.txt coverage) and asserts that claims in \claims-registry.json\ remain pinned to their source pages and engine tests. \check-event-script-grammar.py\ ensures the event script execution types in the documentation catalog match the engine's \CompileFlows.EXECUTION\_TYPES\. \check-minigraph-grammar.py\ verifies that MiniGraph command and skill routes in the documentation catalog align with the engine's help resources and source routes. \check-rest-automation-grammar.py\ confirms that the HTTP methods listed in the REST automation spec match the engine's \RoutingEntry.VALID\_METHODS\. These tools help prevent silent drift in documentation and DSL specifications.

scripts · high confidence

The platform-core module now includes a new set of serialization and parsing classes in the \org.platformlambda.core.serializers\ package. This adds MsgPack support for efficient binary event payload transport (with \packMapOrList\/\unpackMapOrList\ methods), a \PayloadMapper\ for encoding/decoding typed payloads, and a \SimpleMapper\ wrapping Gson with pre-configured adapters for Java time types (\Instant\, \OffsetDateTime\, etc.) and configurable snake\_case/camelCase output. Additionally, \SimpleXmlParser\ and \SimpleXmlWriter\ provide a lightweight, XXE-secure alternative to Jackson for converting XML to/from Maps.

system/platform-core/src/main/java/org/platformlambda/core/serializers · high confidence

The engine now includes a suite of new skills in the skills package: GraphApiFetcher for executing API requests with dictionary lookups and parallel iteration; GraphDataMapper for applying data transformations; GraphExtension for invoking external flows or subgraphs with concurrency control; GraphIsland as a traversal sink; GraphJoin for synchronizing parallel branches; GraphJs and GraphMath for executing JavaScript and mathematical statements with loop support; and GraphResume for restoring workflow state from a pluggable store after suspension. These skills expand the graph's capabilities for external integration, data processing, and stateful workflow management.

system/minigraph-playground-engine/src/main/java/com/accenture/minigraph/skills · high confidence

The platform-core module introduces a set of new internal data models to support advanced HTTP routing, streaming, and request handling. AssignedRoute and RouteInfo define route configurations, including per-endpoint overrides for trace and correlation ID headers to support legacy impedance matching. AsyncContextHolder and EventStreamState manage per-request context and buffered state for multi-shot HTTP event streams (SSE/chunked). HttpRequestEvent carries request metadata, including W3C trace context and business correlation IDs, while HeaderInfo, CorsInfo, EtagFile, SimpleHttpFilter, and StreamHolder provide supporting structures for header manipulation, CORS, caching, filtering, and stream lifecycle management.

system/platform-core/src/main/java/org/platformlambda/automation/models · high confidence

The cloud connector now includes a set of new internal system services to enhance operational visibility and connectivity management. CloudHealthCheck provides a mechanism to verify system health by performing loopback tests and checking topic availability, while ServiceRegistry manages the live state of cloud routes and origins, supporting lifecycle and presence-monitor subscriptions. ServiceQuery exposes endpoints to download route and node lists, find specific routes, and retrieve system info, and EchoService/EchoInbox handle the underlying asynchronous echo logic required for these health checks. These components are reserved for system use and are not intended for direct application code.

connectors/core/cloud-connector/src/main/java/org/platformlambda/cloud/services · high confidence

The event-script engine now includes a suite of new simple-plugin operators in the logical package, enabling more complex data evaluation within scripts. Users can now perform case-insensitive string checks with startsWith, endsWith, and includes; compare values using equality (eq), inequality (ne), greater than (gt), and less than (lt) operators; and apply logical conjunctions (and), disjunctions (or), and negation (not). Additionally, null checks (isNull, notNull) and conditional logic (ternary) are now available, with numeric comparisons automatically promoting values to ensure accurate results.

system/event-script-engine/src/main/java/com/accenture/services/plugins/logical · high confidence

The minigraph-playground-engine now includes a new math expression evaluation engine in the \com.accenture.minigraph.math\ package. This engine allows users to evaluate mathematical and logical expressions using a JavaScript-like syntax, supporting standard arithmetic operators, trigonometric and other math functions (via a \Math\ namespace), variables, and conditional logic. The implementation consists of a lexer, a shunting-yard parser, and an evaluator that processes expressions into a typed value (number, boolean, or string).

system/minigraph-playground-engine/src/main/java/com/accenture/minigraph/math · high confidence

The minigraph playground engine now includes a new set of core services and data models to support graph execution, command handling, and session management. This introduces the GraphCommandService for processing graph commands, the GraphExecutor for running deployed graphs, and the GraphTraveler for dry-run traversal in the playground. Supporting models like CompiledGraphs, GraphInstance, and GraphSession manage the state and lifecycle of graph executions. Additionally, a GraphExceptionHandler and GraphHousekeeper are added for error handling and resource cleanup, while a placeholder GraphHealth service is provided for system monitoring.

system/minigraph-playground-engine/src/main/java/com/accenture/minigraph/services · high confidence

A new OpenTelemetry forwarder extension has been added to export Mercury's distributed trace metrics to an OTLP collector. The feature is disabled by default and must be explicitly enabled via the \otel.forwarding=true\ property. It preserves existing W3C trace and span IDs to maintain lineage, supports configurable endpoints, timeouts, and compression, and handles credentials via environment variables with per-export reloading to support dynamic secrets. The extension includes robust error handling that reflects HTTP status codes (such as 404 or 401/403) into logs for easier troubleshooting.

extensions/opentelemetry-forwarder/src/main · high confidence

The platform-core system package now includes a set of new foundational classes that manage the application startup sequence and provide the core infrastructure for event streaming. AppStarter and AutoStart handle the initialization phases (BeforeApplication, PreLoad, MainApplication) and support Spring Boot integration, while EssentialServiceLoader registers critical internal services like AsyncHttpClient and Telemetry. For streaming, EventEmitter, EventPublisher, EventStreamWriter, FluxPublisher, and FluxConsumer implement the engine-managed envelope pattern, supporting progressive HTTP response streaming, SSE relay, and reactive Flux-style consumption with built-in TTL and expiration handling. LocalPubSub adds in-memory topic-based pub/sub capabilities, and ObjectStreamIO provides the underlying stream lifecycle management used by the streaming components.

system/platform-core/src/main/java/org/platformlambda/core/system · high confidence

Added a worked example demonstrating reactive database access patterns for the reactive-postgres library. The example includes a Spring R2DBC-based application with a REST endpoint, repository pattern implementation, and direct database client API usage, along with comprehensive unit tests using an embedded PostgreSQL server.

examples/pg-example · high confidence

The scheduler-example now provides a complete working demonstration of the Simple Scheduler, including a REST admin API (GET/POST /api/schedule) for listing and manually triggering jobs, a sample file-based StateResolver for clustering resilience, and a demo flow (hello-flow) with placeholder tasks. The example also includes a fix to the schedule job-list endpoint to tolerate mid-write state files, preventing 500 errors when reading partially written state records.

examples/scheduler-example · high confidence

A new benchmark-reporter module has been added to provide a self-contained, single-JVM end-to-end performance testing harness for the Mercury framework. It runs a suite of RPC and callback workloads—covering normal operation (no back-pressure) and overload scenarios—to measure latency and throughput against an echo worker. The tool captures per-operation metrics and generates a standalone HTML report featuring inline SVG latency histograms and percentile plots, allowing users to evaluate framework behavior under various load conditions without external dependencies.

benchmark/benchmark-reporter · high confidence

A new service-monitor connector has been added to the platform, introducing a suite of components that handle service presence, health monitoring, and dynamic Kafka topic allocation. The system now includes a MainApp entry point that bootstraps the monitor, a PresenceHandler to coordinate peer-to-peer presence data, and a TopicController that manages a bidding protocol (RSVP) to assign and release Kafka topic partitions among applications. Supporting services like MonitorAlive (heartbeat broadcasting), HouseKeeper (cleanup of expired monitors), and AdditionalInfo (querying connection/topic stats) provide real-time visibility into the cluster state, while the MonitorService WebSocket endpoint exposes session and connection metadata to external consumers.

connectors/core/service-monitor/src/main/java · high confidence

Added a new \redis-standalone\ helper under \helpers/\ that runs a real Redis server locally without requiring Docker. This tool uses the \embedded-redis\ library to launch a \redis-server\ subprocess (defaulting to port 6379) and is designed specifically for local development and testing environments. The implementation includes a transient data directory (\/tmp/soa-redis\) that is wiped before each start to ensure a clean slate, along with end-to-end and unit tests to verify server startup, shutdown, and basic RESP protocol interactions.

helpers/redis-standalone · high confidence

A new \schema-registry-standalone\ helper has been added to provide a Confluent-compatible Schema Registry for local development and testing without requiring Docker or external infrastructure. It implements the core REST API subset used by Confluent serializers/deserializers for Avro, JSON Schema, and Protobuf, running on the built-in reactive HTTP server. The service persists schemas as individual files (one per global ID) in a configurable directory (defaulting to \/tmp/schema-registry\), allowing for stable IDs across restarts and on-demand loading of new schema files while the server is running. It is intended as a sibling to \kafka-standalone\ and \redis-standalone\ to support local Kafka flows, specifically backing the schema features of \minimalist-kafka\ and the \sync-over-async-demo\.

helpers/schema-registry-standalone · high confidence

The repository now includes three new starter templates—\starter-function\ (Layer 1), \starter-flow\ (Layer 2), and \starter-graph\ (Layer 3)—that provide standalone, copy-out project scaffolds for building composable functions, event-script flows, and active knowledge graphs respectively. Each template includes both Maven and Gradle build files, documentation, and example code. The Layer 3 (\starter-graph\) template introduces dev-mode support with an integrated MiniGraph Playground and a new Node.js session broker (\playground-session-broker.mjs\) that allows AI agents to host Playground sessions with proper keep-alive handling, replacing the need for hand-rolled WebSocket clients.

templates · high confidence

Added two new scaffolded starter projects to accelerate application development: a 'starter-function' template for Layer 1 composable functions with REST automation, and a 'starter-flow' template for Layer 2 event-script flows. The function starter provides a single composable Java function handling HTTP requests via REST automation, while the flow starter demonstrates a multi-step orchestration pattern using YAML-defined flows that sequence decoupled validation and greeting tasks. Both templates include necessary configuration files, main application entry points, and unit tests to validate the generated code.

templates/starter-flow, templates/starter-function · high confidence

The demo now includes three new Java classes in the stream package that implement the infrastructure for streaming LLM tokens across pods: LlmStreamBridge acts as a bridge to relay provider SSE token streams into the rendezvous, StreamNotifyFacade handles the initial session correlation ID notification to the UI, and StreamProducer manages the posting of stream segments (including chat, notification, and LLM modes) via Redis. This enables the demo to support real-time token streaming from LLM providers like Gemini through a cross-pod architecture.

examples/sync-over-async-demo/src/main/java/com/accenture/soa/demo/stream · high confidence

The sync-over-async-demo example now includes end-to-end demonstrations of the synchronous REST over async Kafka pattern using Confluent JSON Schema and Avro transports, in addition to the existing raw byte\[\] path. This adds dedicated backend tasks (SystemOfRecordJson, SystemOfRecordAvro) and facade reply handlers (SoaReplyJson, SoaReplyAvro) to process schema-validated messages, along with pre-seeded schema registry definitions and a Node.js helper to provision the required multi-partition Kafka topics.

examples/sync-over-async-demo · high confidence

A new worked example demonstrating the twin-kafka module has been added to the examples directory. It packages a three-role application (REST edge, dual-cluster bridge, and system-of-record) into a single JAR, illustrating how to bridge an on-prem Kafka cluster with a Confluent Schema Registry to a cloud cluster using plain JSON. The demo includes Java tasks for request validation and a temporary file-based store, pure YAML flow definitions for the bridge logic, and Node.js helper scripts for topic creation and response listening to verify end-to-end trace and correlation-id continuity across the two clusters.

examples/twin-kafka-demo · high confidence

The Event Script engine now includes a suite of new plugins in the types package that expand data transformation capabilities. Users can convert values to Base64, binary, boolean, double, float, integer, long, and text formats, as well as parse dates and JSON strings. Data structure manipulation is supported via plugins to normalize map keys to camelCase or snake\_case, concatenate strings, extract substrings, remove specific keys, generate unique sets, and transform maps of lists into lists of maps (with an additional plugin to merge results back). Input validation is now available to enforce types and ranges, and a new plugin allows setting or overriding system configuration parameters at runtime.

system/event-script-engine/src/main/java/com/accenture/services/plugins/types · high confidence

Added three new singleton utility classes to the platform-core automation utilities: CustomContentTypeResolver, which allows users to define custom content-type mappings via configuration; MimeTypeResolver, which provides MIME type lookups for file extensions with built-in support for common types like JSON, XML, and HTML; and SimpleHttpUtility, which offers helper methods for setting multiple cookies, filtering HTTP headers, normalizing URLs, decoding query strings, and sending standardized error responses in HTML, JSON, or XML formats.

system/platform-core/src/main/java/org/platformlambda/automation/util · high confidence

Added a set of Node.js scripts to the kafka-demo example to demonstrate end-to-end tracing and advanced routing capabilities. The new helpers include a publisher for inbound messages (publish-inbound.js) and a publisher for second-level routing scenarios (publish-orders.js), which supports exact, wildcard, and body-based routing rules as well as a failure path that dead-letters invalid payloads. A listener (listen-outbound.js) logs messages from the Java application, verifying that trace IDs are preserved across Kafka hops while span IDs are updated. Additionally, a dead-letter queue listener (listen-dlq.js) and a topic creation utility (create-topics.js) are provided to support debugging and setup.

examples/kafka-demo/node · high confidence

The platform now includes a persistent WebSocket client component that maintains long-lived connections to remote servers. This client automatically handles connection establishment, round-robin load balancing across multiple target URLs, and automatic reconnection on failure. It implements a configurable keep-alive mechanism to prevent idle timeouts and ensures message delivery by segmenting large payloads. Users benefit from reliable, stateful WebSocket communication without needing to manually manage connection lifecycle or retry logic.

system/platform-core/src/main/java/org/platformlambda/core/websocket/client · high confidence

The MiniGraph Playground now includes a dedicated session broker script that allows an AI agent to host a Playground session instead of relying on a human's browser connection. This broker manages the WebSocket lifecycle with keep-alive pings and exposes a local control API, enabling stable collaboration where humans can subscribe to the agent's session and sync their work-in-progress graphs without losing data during idle timeouts or app restarts.

examples/minigraph-playground · high confidence

This extension provides a Redis-backed state store for the Active Knowledge Graph's suspend and resume workflow nodes. It enables durable, cross-instance workflow suspension by persisting state to Redis with native TTL expiry and consuming records atomically on retrieval (using GETDEL on Redis 6.2+ or a MULTI/EXEC transaction on older versions) to prevent duplicate execution. A key behavioral improvement is the support for per-iteration state isolation in for\_each fan-out patterns: by appending an optional iteration index to the store key, the extension ensures that parallel subgraph iterations maintain independent state records, preventing collisions when they share the same correlation ID.

extensions/minigraph-state-redis · high confidence

Bridge applications can now connect to a secondary Kafka cluster alongside the primary one. This location introduces the secondary cluster's runtime holder, auto-start logic, health check, and notification function, enabling dual-cluster bridging where producers, consumers, and schema codecs are configured independently per cluster. Users can opt out of the producer or consumer for the secondary cluster, tune cluster-specific header names (correlation ID, trace ID, traceparent), and include the new secondary health check in mandatory dependencies to monitor both clusters.

system/twin-kafka/src/main/java · high confidence

The sync-over-async extension now ships three reusable tasks—SoaReplyTask, SyncAwaitTask, and SyncPrepareTask—that implement the core return-route coordination. SyncPrepareTask registers the Redis return route and serializes the request, SyncAwaitTask blocks on a virtual thread until the response arrives (returning HTTP 200 or mapping timeouts to HTTP 408), and SoaReplyTask delivers the asynchronous response to the return-route coordinator. These tasks are sized for user-facing concurrency (250 instances each) and use a self-contained correlation-id key so they do not depend on transport-specific headers.

extensions/sync-over-async/src/main/java/org/platformlambda/tasks · high confidence

The rest-spring-4 module now provides a pre-configured Spring Boot 4 container that includes a set of built-in actuator servlets for health, liveness, environment, and application info checks, along with an HSTS filter to enforce secure transport headers on HTTPS requests. It also ships with custom HTTP message converters for JSON, XML, HTML, and plain text, and a centralized error handler to standardize error responses across the application.

system/rest-spring-4 · high confidence

The webapp now includes a Workspace sidebar that lets you clip nodes from the graph and paste them into the command input. Clipped items are persisted in an IndexedDB database and synchronised across browser tabs via a BroadcastChannel. You can drag items from the sidebar directly into the graph, right-click for a context menu (Paste to Input, Inspect), and sort the list by recent, type, alias, source, connection count, or a specific property. Batch clipping operations display a single summary toast instead of spamming individual notifications, and pasting an item that already exists in the graph triggers a duplicate dialog asking whether to replace it.

system/minigraph-playground-engine/webapp · high confidence

The Kafka connector module now excludes the snappy-java codec to mitigate [CVE redacted] (an out-of-bounds write vulnerability) and directly pins zstd-jni to version 1.5.7-16 to address [CVE redacted] (an integer overflow). Additionally, the Kafka demo example overrides the httpcore5 version to 5.4.3 to resolve a Snyk HIGH severity vulnerability (CWE-770) in the transitive httpcore5/httpcore5-h2 dependencies.

(dependencies) · high confidence

The platform now supports configuring the HTTP header names used for tracing (trace-id, correlation-id, and traceparent) at both the global level and with specific per-route overrides. This allows users to map incoming trace headers from legacy systems or external services to the platform's internal tracing context, ensuring seamless integration and impedance matching without requiring changes to the upstream services.

system/platform-core/src/main/java/org/platformlambda/automation/config · high confidence

The platform-core utility package has been significantly restructured. The caching layer now uses Caffeine instead of Guava, changing eviction behavior to be approximate and non-deterministic under capacity pressure. Configuration management is handled by new \AppConfigReader\ and \ConfigReader\ classes that consolidate YAML/properties loading, profile activation, and environment variable substitution. The elastic queue overflow buffer now uses a dependency-free file-based store (\FileElasticStore\) instead of Berkeley DB, providing a transient, single-threaded per-route FIFO with immediate segment reclamation. Security utilities in \CryptoApi\ now use \SecureRandom\ for key generation, and new classes like \Feature\ and \ManifestReader\ provide feature flag evaluation and application version detection.

system/platform-core/src/main/java/org/platformlambda/core/util · high confidence

The repository now includes a composable git hook system that enforces security and ritual compliance. The pre-commit hook scans staged memory and configuration files for secrets (blocking commits on detection by default) and checks that edited memory facts are declared in a staged session log. The post-commit hook ensures no working session is left without a session log by auto-stubbing one if needed. Users must run the provided init script to activate these hooks locally.

.githooks · high confidence

The Kafka Presence adapter's entry point has been updated to use the framework's AutoStart mechanism. This change ensures that the adapter initializes consistently with other components in the platform, replacing the previous direct invocation pattern with a standardized startup flow.

connectors/adapters/kafka/kafka-presence/src/main/java · high confidence

The system now enforces a strict deployment gate where graph models are only executable if explicitly listed in the \graph.model.automation\ manifest and pass startup validation (including structural checks, required 'purpose' documentation, and an 'end' node). Additionally, the deprecated 'simple type matching' syntax (e.g., \model.key:type\) in mapping and input properties is automatically converted to the 'simple plugin' syntax (\f:type(model.key)\) at compile time, ensuring consistent behavior and rejecting invalid mappings that lack the required \-\>\ separator.

system/minigraph-playground-engine/src/main/java/com/accenture/minigraph/start · high confidence

The lambda-example module now includes a MainApp entry point that initializes the Platform using the AutoStart utility, replacing previous manual initialization patterns. This change simplifies the startup process for the example by leveraging the framework's automatic configuration and lifecycle management.

examples/lambda-example/src/main/java/org/platformlambda/example · high confidence

The engine introduces a new \FeatureRunner\ interface and \FeatureDef\ record to support pre- and post-processing of HTTP requests within graph nodes, alongside a \GraphModelValidator\ that enforces strict structural rules. This validator ensures that nodes with a \task\ route are paired with a compatible \skill\ (specifically \graph.task\, \graph.suspend\, or \graph.resume\), validates the placement of the \ttl\ parameter, and enforces the suspend/resume contract. Additionally, the \GraphLambdaFunction\ base class is updated to include generic exception context handling and iteration index tracking for \for\_each\ loops, while mock services for account details and MDM profiles are added to support development and testing.

system/minigraph-playground-engine/src/main/java/com/accenture/minigraph/common · high confidence

The platform now ships with a set of default resource files that establish baseline behavior for configuration loading, logging, and static content. A new \app-config-reader.yml\ defines the order in which Spring Boot configuration files are merged. Three new Log4j2 configurations (\log4j2.xml\, \log4j2-json.xml\, \log4j2-compact.xml\) provide default logging appenders for console, JSON, and compact formats, with telemetry logging enabled at INFO level. A \default-log-context.yaml\ template enables structured JSON logging by default, injecting context fields like trace ID, span ID, and UTC timestamp. Default REST endpoint definitions in \default-rest.yaml\ expose standard actuator routes (health, info, routes, env, liveness) with specific timeouts and tracing settings. Static content support is enhanced with \mime-types.yml\ for file extension mapping, a default \errorPage.html\ for HTTP errors, and a \public/index.html\ welcome page linking to the new info and health endpoints.

system/platform-core/src/main/resources · high confidence

The platform now emits structured JSON logs by default, including distributed-tracing fields (correlation ID, trace ID, span ID, service name) and a machine-parseable UTC timestamp. This is powered by new Log4j2 appenders (JsonAppender, CompactAppender) and a context system (LogContext, LogContextConfig) that automatically injects trace data into every log line when running on a worker thread. The feature is enabled out of the box using a built-in template, but can be customized via an app-log-context.yaml file or disabled entirely with app.log.context=false.

system/platform-core/src/main/java/org/platformlambda/core/logging · high confidence

The sync-over-async demo now includes a dedicated error handler that maps backend errors to HTTP responses. When the async backend is unreachable (e.g., Kafka publish or Redis registration failure), 5xx errors are remapped to 503 Service Unavailable to allow caller retries, while 408 timeouts pass through unchanged. The handler also aborts pending sync entries on failure.

examples/sync-over-async-demo/src/main/java/com/accenture/soa/demo/support · high confidence

Added PoJo test model for event script engine tests; Added TestBase for Lambda Example Common Tests; Added contract and file-specific tests for the FileElasticStore; Added emulated LLM round-trip and unit tests for the sync-over-async demo; Added integration tests for Kafka connector edge cases and validation; Added integration tests for cloud connector and monitor edge cases; Added integration tests for cloud connector service registry and event routing; Added integration tests for dual-cluster Kafka bridge and schema registry support; Added integration tests for the sync-over-async MVP and streaming return routes; Added mock infrastructure for cloud connector testing; Added mock service functions for testing platform features; Added test automation services for streaming and relay scenarios; Added test base class for composable example; Added test configuration files for Kafka connector integration tests; Added test configuration files for cloud-connector; Added test configuration fixtures for minimalist-kafka end-to-end tests; Added test configuration for Lambda example; Added test configuration for sync-over-async end-to-end tests; Added test coverage for admin endpoints, event-over-HTTP streaming, and SSE client behavior; Added test coverage for event-script engine components; Added test coverage for flow execution, telemetry, and validation; Added test coverage for key normalization, JSON parsing, config setting, and null handling plugins; Added test coverage for reactive PostgreSQL database operations and SQL statement handling; Added test coverage for the AI Contract Provider discovery and export capabilities; Added test coverage for the sync-over-async Redis return-route mechanism; Added test fixtures for event-script-engine service testing; Added test fixtures for the plugin allowlist gate; Added test harness tasks for the Event Script Engine; Added test infrastructure for DB2 mock service and request handling; Added test infrastructure for Jackson 3 serialization and HTTPS server validation; Added test infrastructure for the Event Script Engine; Added test resource configuration for reactive Postgres integration tests; Added test resource configuration for the Event Script Engine; Added test resource files for service-monitor; Added test resource fixtures for platform-core configuration and static content; Added test resources for MiniGraph Playground flows; Added test resources for OTLP forwarder validation; Added test support classes for reactive PostgreSQL repository testing; Added test support services for reactive PostgreSQL operations; Added tests for Avro conversions and CSFLE schema codec configuration; Added tests for application log context and structured logging; Added tests for environment instance override behavior; Added tests for equality operators with ignoreCase and ignoreType modifiers; Added tests for graph workflow suspension, resume, and mock AI nodes; Added tests for platform shutdown, service queue, and worker handler span forwarding; Added tests for the OpenTelemetry forwarder extension; Added tests for the SimpleLookup decision plugin; Added tests for the service monitor admin HTTP endpoints; Added unit tests and mock infrastructure for the Kafka Presence Monitor; Added unit tests for Kafka demo task processors; Added unit tests for collection operators; Added unit tests for engine guards, expression engine, and playground companion behavior; Added unit tests for platform-core core components; Added unit tests for sync-to-async configuration, error handling, and Redis health checks; Added unit tests for the Kotlin example application; Added unit tests for the Lambda example demo services; Added unit tests for the composable-example flows; Expanded test coverage for minimalist-kafka integration and configuration.

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

• First survey — no prior run to compare against. CAI 60.

• Code Health 81
• Architecture 84
• Maturity 84
• Readiness 56
• Security 60
• Accessibility 56

• 300 commits — 271 feature/other, 29 fixes

• memory/continuity.md — 85 commits
• memory/open-threads — 49 commits
• (root) — 20 commits
• memory/sessions — 19 commits
• system/minigraph-playground-engine — 19 commits
• docs/guides — 18 commits
• extensions/sync-over-async — 10 commits
• system/platform-core — 9 commits
• system/minimalist-kafka — 7 commits
• memory/archive — 6 commits
• draft-design-specs/streaming-return-route.md — 5 commits
• examples/distributed-cache-example — 5 commits
• system/event-script-engine — 5 commits
• agent-skills/memory-lint — 4 commits
• docs/arch-decisions — 4 commits
• docs/presentations — 3 commits
• examples/sync-over-async-demo — 3 commits
• extensions/distributed-cache — 3 commits
• templates/starter-flow — 3 commits
• docs/ai-grammar-methodology.md — 2 commits

• fix: chore(minigraph): rebuild packaged bundle, nanoid audit fix, vendor-router chunk (#344)
• fix: distributed-cache-example: cache value as plain MsgPack (+ Sonar S5778 fix) (#395)
• fix: fix(ai-contract-provider): package RFC.md into the skill snapshot; rename the proposal register (#424)
• fix: fix(cache-example): Layer 1 surfaces a cache failure, never a miss; Java ⇄ Rust distributed-cache interop report (#426)
• fix: fix(deps): vertx-core 5.1.6 + Jackson 2 BOM 2.22.2 for the field Snyk gate; proactive Jackson 3 / Tomcat pins (#320)
• fix: fix(deps,docs): align BouncyCastle at 1.86; document the for_each store key everywhere (#420)
• fix: fix(distributed-cache): classify Redis failures - 408 for a command timeout, 503 for an unreachable Redis (#429)
• fix: fix(kafka): let the serdes inherit the Schema Registry client config (#318)
• fix: fix(minimalist-kafka): kafka.health builds its probe client regardless of the thread context classloader (#403)
• fix: fix(minimalist-kafka): pin the module classloader across the whole kafka.health probe (#409)
• fix: fix(platform-core): resolve a function's error status from its cause chain, not the outermost wrapper (#427)
• fix: fix(redis-connection): reset the shared connection after a command timeout - recovery bounded by the timeout, not Lettuce's backoff (#433)
• fix: fix: a skill-less graph node and unreachable mixed-case Kafka headers (#406)
• fix: fix: exclude the snappy codec - [CVE redacted] via kafka-clients (field Snyk) (#382)
• fix: fix: minute-boundary ISO date parsing + null operands in text conversion (#342)
• fix: fix: pin zstd-jni 1.5.7-16 - [CVE redacted] via kafka-clients (field Snyk) (#380)
• fix: fix: tolerate a mid-write state file in the schedule job-list endpoint (#384)
• fix: health checks: hardening round - kernel threads for Kafka, structured 503 message, scan fixes (#362)
• fix: memory: #426 and mercury #286 merged - cache interop report + L1 fix on both mains
• fix: memory: #428 / mercury #288 merged; classification fix branches rebased (pending PR)
• …and 280 more

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

Accenture/mercury-composable 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.