Skip to content
CAI
Software that uses CAICheck a score

Accenture/mercury-composable

57.5

Adequate · 23 October 2026

98.7k

lines of production code

Java

with TypeScript, JavaScript

5

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

This system is a reactive, event-driven application framework for Java and Kotlin that facilitates the development of distributed microservices. It provides core infrastructure for asynchronous communication, service discovery, and cloud connectivity, with specific adapters for Kafka and Redis. The platform supports multiple architectural patterns, including composable functions, YAML-defined event flows, and visual active knowledge graphs, while offering tools for performance benchmarking, AI agent integration, and local development simulation.

How it got here

2023–2024 — Platform core and Kafka connector development

70 changes.

This period focused on establishing the foundational Platform Lambda core, including deterministic serialization, HTTP routing, and WebSocket support, alongside the introduction of a comprehensive Kafka cloud connector for event-driven communication. The work also expanded the framework with an Event Script Engine for workflow orchestration and provided extensive demo applications and test coverage to validate these new capabilities.

2025–2026 — MiniGraph engine and reactive extensions

115 changes.

This period focused on the development of the MiniGraph Playground engine, introducing a comprehensive graph execution model with suspend/resume capabilities, exact decimal arithmetic, and a React-based web interface. Concurrently, the platform expanded its reactive ecosystem with new extensions for PostgreSQL, Kafka schema registry support, and a Redis-backed synchronous-over-async pattern, all accompanied by extensive test coverage and documentation restructuring.

Features

API Playground adds file management for Swagger specs

The API Playground now allows users to view, list, and deploy Swagger/OpenAPI specification files. A new service layer manages a configurable specs folder (via the \api.playground.specs\ property), serving bundled sample files like \demo.yaml\ and any user-deployed files, with deployed files taking precedence. Users can list available specs, view individual files, and deploy new documents via a PUT endpoint that requires confirmation to overwrite existing files, ensuring safe management of API definitions within the playground.

extensions/api-playground/src/main/java/com/accenture/examples/services · high confidence

API Playground now fetches Swagger UI at build time and supports saving specs

The API Playground extension no longer bundles Swagger UI assets; instead, it uses new Python and Node.js scripts to fetch the latest release into a local folder at build time, ensuring the UI stays current without committing third-party code. The application now provides a 'Specs' interface and a 'Deploy' action that allows users to save loaded OpenAPI documents (from URLs, MiniGraph sources, or file drops) into a configurable local folder, making them available via new REST endpoints (GET/PUT /api/specs) and the UI's Specs list.

extensions/api-playground · high confidence

Active-active deployment support via ActiveEnvironment singleton

The mini-scheduler now includes an ActiveEnvironment singleton that enables active-active deployments across multiple sites (e.g., Production and DR). It determines whether this instance is active or standby by comparing its local environment (configured via \scheduler.environment\) against a persisted active environment (retrieved from a configurable store function, default \v1.environment.store\). Scheduled jobs only run on the active instance; standby instances skip jobs but still honor manual operator runs. The active environment is persisted to ensure consistency across restarts, with a fallback to in-memory state if no store is configured.

mini-scheduler · high confidence

Add Confluent Schema Registry support for Avro and JSON schemas

The minimalist Kafka module now supports Confluent Schema Registry wire formats for Avro and JSON schemas. This introduces a new schema package containing a thread-safe codec that bridges the platform's plain Java Map/List data to Confluent's serialized format, using an in-memory managed cache to optimize schema lookups and reduce registry round-trips. Avro serialization handles partial records by applying schema defaults, while JSON support is also wired. Protobuf is recognized but intentionally excluded due to a security vulnerability in the underlying Confluent provider dependency.

system/minimalist-kafka/src/main/java/org/platformlambda/mini/kafka/schema · high confidence

Add Kafka cloud connector adapter and documentation

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

Add Kotlin example application for profile management

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

Add Kotlin example application with profile data models

A new Kotlin example application has been added to the examples directory, providing a reference implementation for users. This includes data models for user profiles (Profile) and profile confirmations (ProfileConfirmation), demonstrating how to handle data serialization and structure within the platform's Kotlin ecosystem.

kotlin-example · high confidence

Add MainApp entry point for API Playground

A new MainApp class has been added to the API Playground extension, implementing the EntryPoint interface and utilizing AutoStart for initialization. This provides a consistent application startup mechanism for the extension.

extensions/api-playground/src/main/java/com/accenture/examples · high confidence

Add WsMetadata record for WebSocket session tracking

A new WsMetadata record has been introduced in the service-monitor module to encapsulate WebSocket connection details. This record stores the session identifier, transaction path, and origin, providing a structured way to track and manage metadata for active WebSocket connections within the platform.

service-monitor · high confidence

Add configuration for sync-over-async demo roles and transport variants

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

Added Schema Registry demo with Node.js helper scripts

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

Added ServiceLifeCycle for event consumer initialization

The cloud-connector now includes a new ServiceLifeCycle class that manages the initialization sequence for event consumers. This component ensures consumers are ready to process events by sending an initialization token and coordinating with the event emitter and pub/sub system before starting normal operation.

cloud-connector · high confidence

Added composable event choreography demo landing page

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

Added configuration templates for secondary Kafka cluster support

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

Added default configuration files for Kafka and Presence connectors

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

Added demo health check service

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

Added sync-over-async worked example application

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

Expanded lambda-example with streaming, RPC, and file I/O demos

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

Graph set packaging, deployment, and math engine updates

The engine now supports deploying graph models as packaged sets (.pack files) via a new GraphSet utility and GraphSetLoader, which unpacks sets into a designated folder and registers them in the compiled-graph registry, enforcing strict naming and content rules. The math evaluation context has been expanded with a new DECIMAL type and a round function that uses half-up rounding away from zero, aligning with the f:round plugin. Additionally, the Playground's home page now serves a plain static page in production (non-dev) environments, ensuring the interactive Playground UI is only available in development mode.

minigraph-playground-engine · high confidence

HTTP response streaming and configurable trace headers

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

Initial API Playground configuration and sample definitions

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

Initial configuration and static assets for Kafka Presence Monitor

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

Initial configuration and static assets for the Presence Monitor service

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

Initial project scaffolding and AI agent onboarding

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

Introduce AI Contract Provider service for operational contract discovery

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

Introduce Event Script engine with flow execution, HTTP adapter, and simple plugin system

The event-script-engine module now provides the core runtime for defining and executing event-driven flows via YAML configuration. A new HTTP adapter (HttpToFlow) bridges incoming HTTP requests into the flow engine, mapping request headers, body, and cookies into the flow's input dataset while preserving upstream business correlation IDs. The engine compiles flows at startup (CompileFlows), enforcing mandatory descriptions and protecting reserved model metadata keys from accidental overwrites. It supports a pluggable function system (SimplePluginLoader) that registers type-conversion and arithmetic plugins (e.g., text, int, decimal) while scanning plugin class bodies to ensure they only reference an allowlist of safe packages. For testing, a mock helper (EventScriptMock) allows rerouting task functions and attaching monitors to capture state and data mapping changes.

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

Introduce benchmark-reporter for release-over-release performance tracking

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

Introduce mini-scheduler for YAML-based cron job orchestration

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

Introduces Redis-backed synchronous request/reply and streaming return routes

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

Introduction of HttpRequestHandler for HTTP request processing

A new HttpRequestHandler class has been added to the platform-core automation module to manage incoming HTTP requests. This handler implements the Vert.x HttpServerRequest handler interface, routing requests based on configured routes, handling WebSocket prefixes, serving the index.html for root paths, and managing request contexts with timeout and multipart upload support. It also handles standard HTTP headers like Date and Connection, and returns appropriate status codes (404, 405, 400) for invalid routes or methods.

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

Introduction of core configuration and platform constant interfaces

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

Introduction of the Event Script Engine Task Executor

The event-script-engine module now includes the core TaskExecutor component, which orchestrates the execution of scripted workflows. This component manages flow instances, resolves task references, and handles the lifecycle of sequential, parallel, and fork-join execution patterns. It enforces strict input/output data mapping via a DataMappingHelper, supports dynamic model index comparisons, and integrates distributed tracing for observability. Users can now define and run complex event-driven scripts with features like task-level TTL overrides, state machine monitoring, and custom HTTP error responses.

event-script-engine · high confidence

Lambda example adds configuration for log context, event-over-HTTP, and REST endpoints

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

MiniGraph Playground Engine documentation and webapp source added

The repository now includes the complete source and documentation for the MiniGraph Playground webapp, a single-source React UI deployed to both the Java engine in this repository and the Rust engine in the sibling \mercury\ repository. This addition provides the interactive interface for creating, testing, and executing Active Knowledge Graphs, featuring a WebSocket-based console, a visual graph canvas with in-place authoring, a help browser, and a workspace clipboard. The included documentation details the architecture, component structure, protocol contract, and build/deploy procedures for maintaining this shared frontend.

system/minigraph-playground-engine · high confidence

MiniGraph Playground adds AI token streaming and bounded-agency triage demo

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

MiniGraph Playground engine configuration and REST API definitions

The MiniGraph Playground engine now includes its core configuration and API definitions in the resources directory. The application.properties file sets the server port to 8085, enables JSON-structured logging for graph traversal analytics, and configures temporary graph storage. The rest.yaml file defines the available REST endpoints, including synchronous AI-companion commands, graph import and set management, live session inspection, and mock services, along with CORS and security headers. The flows.yaml file registers the graph executor and flow definitions used by the engine.

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

New AI Contract Provider service for operational discovery and offline skill export

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

New ContractEntry model for AI contract provider

The AI contract provider now includes a new ContractEntry record to represent operational contracts defined in contracts.yaml. This model captures the contract's ID, module, summary, behavior anchor classes, and packaged references, enabling the system to structure and process contract metadata for AI-driven discovery.

ai-contract-provider · high confidence

New DECIMAL statement with exact decimal arithmetic and strict type separation

The math engine now supports a new DECIMAL statement that performs exact decimal arithmetic using BigDecimal, distinct from the existing double-precision path. This change introduces a parallel evaluation system where number literals are parsed directly into decimals, ensuring exact results for addition, subtraction, and multiplication, while division is rounded to 34 significant digits. The engine strictly separates types: booleans are never treated as numbers, and unknown functions or unsupported operations (such as trigonometry, logarithms, and constants like PI) fail by name. Additionally, numeric string comparison is now exact, allowing strings that represent canonical numbers to compare numerically against other numbers.

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

New Java demo application for profile management and event-driven patterns

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

New Kafka Flow Adapter with advanced routing and schema support

The minimalist-kafka module now includes a Kafka Flow Adapter that reads a \kafka-flow-adapter.yaml\ configuration to map Kafka topics to Event Script flows. This adapter supports regex-based topic subscriptions, per-binding dead-letter queues (DLQ), and optional partition pinning. It introduces second-level routing, allowing messages to be directed to different flows or functions based on record headers or body content using a declarative rule syntax. The module also adds support for Confluent Schema Registry with Avro and JSON schema serialization, and includes a \SimpleKafkaNotification\ function for publishing events to Kafka with automatic trace propagation.

minimalist-kafka · high confidence

New Kafka connector and standalone pub/sub service

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

New Kafka connector services for event consumption and pub/sub management

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

New Kafka demo worked example with second-level routing

The kafka-demo example now includes a complete configuration set for a pure event/flow processor, featuring both direct and second-level message routing. Users can observe how the Kafka flow adapter routes messages from 'demo.inbound' to a single flow, while 'demo.orders' uses rule-based second-level routing to dispatch events to specific flows (like 'demo-order-flow') or tasks (like 'demo.refund.processor') based on headers or body content, with a catch-all flow for unmatched records. The demo also configures dead-letter queues (DLQs) for both topics, sets retry policies, and includes logging configuration to highlight telemetry spans while suppressing Kafka client noise.

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

New Kafka standalone helper with dual-broker support

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

New Layer 3 starter template with active knowledge graph execution

The starter-graph template now provides a complete, self-contained application scaffold for building Active Knowledge Graph services. It includes a Java entry point, configuration for the Platform Lambda framework, and a REST API exposed at /api/graph/{graph\_id} that executes graph models defined in a deployment manifest (graphs.yaml). A sample 'starter-quote' graph is included to demonstrate zero-code logic, validating inputs and returning structured responses. The template also ships with a MiniGraph Playground UI for development, accessible via the home page when running in dev mode, and includes unit tests to verify graph execution, error handling, and manifest-based access control.

templates/starter-graph · high confidence

New PgRequest class for batch inserts and atomic transactions

The reactive-postgres extension now includes a new PgRequest utility class that simplifies high-volume data operations. Users can insert many rows in a single multi-row INSERT statement via insertRows, which automatically batches large datasets to stay within parameter limits and executes them atomically. Additionally, the class provides a transaction method that allows multiple SQL statements across different tables to be executed in a single transaction, ensuring all-or-none semantics.

reactive-postgres · high confidence

New PresenceConnector for WebSocket lifecycle and service discovery

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

New REST endpoints for graph inspection, OpenAPI generation, and session management

The Playground engine now exposes several new REST endpoints in development mode to enhance graph inspection and management. Users can now retrieve a live graph session's state via GET /api/live-graph/{id} and inspect specific state machine keys with GET /api/inspect/{id}/{key}, which wraps the result in an {inspect, outcome} envelope. Graph models can be imported into a session's draft via POST /api/graph/import/{id}, and the engine can generate an on-demand OpenAPI 3.0 document (YAML or JSON) or a derived contract view via GET /api/openapi/{graph\_id} or GET /api/openapi/session/{sessionId}. Additionally, a WebSocket-ready HTML interface is served at GET /ws/{graph\|json}, and mock data (body, headers, or model variables) can be uploaded via POST /api/upload/{id} with the appropriate namespace query parameter.

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

New Spring Boot 4 REST example with async, WebSocket, and servlet demos

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

New WebSocket endpoints for graph commands and JSON/XML path queries

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

New WebSocket server implementation with dedicated handshake and request handling

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

New agent skills for applying critiques, harvesting knowledge, and safely archiving facts

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

New annotation and header-logging features for the fetch pipeline

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

New benchmark-reporter tool for Mercury framework performance testing

A new self-contained benchmark-reporter module has been added to the benchmark directory. It provides a single-JVM end-to-end performance reporter for the Mercury framework that runs a suite of scenarios against an echo worker route to measure latency and throughput under both normal and overload conditions. The tool captures per-operation end-to-end latency, computes detailed statistics (including percentiles and log-spaced histograms), and generates a self-contained HTML report with inline SVG visualizations. It is configured via system properties and can be run anywhere a JRE is available.

benchmark-reporter · high confidence

New cloud connector core components for configuration, event routing, and service lifecycle

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

New collection operators for checking emptiness and retrieving first/last items

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

New command-line graph packager for building and validating graph sets

A new \graph-packager\ CLI tool is introduced to support build pipelines by allowing users to pack, unpack, and inspect graph sets from the command line. The tool provides \pack\ (with support for individual files, folders, or a manifest), \unpack\, and \inspect\ commands, and it enforces the engine's deployment gate rules at packaging time—refusing to create packages that contain invalid graphs or illegal names. It outputs a \.pack\ file containing the graph set and a SHA-256 checksum, and includes a test suite to verify correct packing, unpacking, and validation behavior.

helpers/graph-packager · high confidence

New configuration files for the composable-example application

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

New core annotations for application lifecycle, cloud integration, and execution control

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

New core data models and exception handling for the platform runtime

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

New core system services for actuation, event routing, and telemetry

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

New decision-table plugins for lookup and range-based eligibility rules

The event-script engine now includes four new decision-table plugins in the decision package: SimpleLookup, SimpleRangeLookup, SimpleMinRange, and SimpleMaxRange. SimpleLookup resolves a rule name from a static decision table by matching a value against listed entries (case-insensitive text comparison). SimpleRangeLookup matches a numeric or text value against a table of range bands (min..max, with exclusive upper bounds and open ends), supporting numeric, quoted (case-sensitive), and unquoted text (case-insensitive) comparisons, while validating that all bands in a table share the same kind. SimpleMinRange and SimpleMaxRange extract the lower and upper bounds, respectively, from a range notation string, returning exact decimal text for non-integer numbers and handling open ends with optional defaults. These plugins enable users to define eligibility rules, tiers, and time windows using structured decision tables and range notations within the script engine.

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

New distributed cache extension (v1.cache.redis) with cluster-safe operations

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

New distributed-cache example demonstrating cross-layer interoperability

The examples/distributed-cache-example now provides a runnable demonstration of the distributed-cache module (v1.cache.redis), showing how a single profile store can be accessed via three distinct layers—Platform Core (Layer 1), Event Script (Layer 2), and Knowledge Graph (Layer 3)—all sharing one Redis cache and a plain MsgPack wire format. The example includes Java functions for encoding/decoding profiles, YAML flows for Layer 2, and a JSON graph for Layer 3, along with a Node.js Playground session broker script that allows AI agents to host and collaborate on graph models in dev mode.

examples/distributed-cache-example · high confidence

New documentation and grammar drift-check scripts

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

New exact-decimal arithmetic plugins alongside existing numeric operations

The arithmetic plugin family in the event-script engine now includes a set of new f:decimal\* functions (decimalAdd, decimalSubtract, decimalMultiply, decimalDiv, decimalMod, decimalCompare, and decimalRound) that perform exact decimal arithmetic and return canonical decimal strings, complementing the existing f:add, f:subtract, f:multiply, f:div, f:mod, f:increment, f:decrement, and f:round plugins that operate on long or double values. This gives users precise decimal calculations where needed while retaining the original numeric behavior for other cases.

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

New externalized configuration templates for Kafka and Schema Registry clients

The minimalist-kafka module now ships with three new configuration templates (kafka-consumer.properties, kafka-producer.properties, and schema-registry.properties) that allow users to externalize client settings for easier environment-specific tuning. The consumer template introduces support for the KIP-848 consumer group protocol (defaulting to 'auto' to leverage broker-driven rebalancing where available) and enforces at-least-once delivery semantics via pinned deserializers and auto-commit settings. The producer template defaults to the SimpleRandomPartitioner to ensure uniform traffic distribution and sets acks=all for durability. The Schema Registry template provides a verbatim pass-through for Confluent client parameters, including explicit support for OAuth 2.0 authentication and SSL/TLS configuration.

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

New graph skills for API fetching, data mapping, extensions, joins, and suspension

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

New internal model classes for routing, streaming, and request context

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

New internal services for health checks, service discovery, and presence monitoring

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

New lambda-example demo with SSE streaming and RPC patterns

The examples/lambda-example directory now includes a comprehensive demonstration application featuring progressive result set rendering via Server-Sent Events (SSE) and synchronous-style request-response (RPC) between functions. The new README documents how to use the hello.sse endpoint for streaming data progressively and the hello.rpc endpoint for non-blocking RPC calls using virtual threads. A Node.js SSE client script (scripts/sse-client.mjs) is provided to test the streaming functionality, and a .gitignore file has been added to exclude build artifacts and IDE files.

examples/lambda-example · high confidence

New logical and comparison operators for the event-script engine

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

New minigraph playground engine services and models

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

New opt-in OpenTelemetry trace forwarding via OTLP

A new OpenTelemetry forwarder extension has been added to export Mercury's distributed trace metrics to an OTLP collector. This feature is disabled by default and must be explicitly enabled by setting otel.forwarding=true in application.properties or via the -Dotel.forwarding=true runtime flag. When enabled, the forwarder preserves existing W3C trace, span, and parent-span IDs to maintain lineage, reads configuration (endpoint, timeouts, compression, service name) from application.properties with environment variable substitution, and re-reads credential headers on every export to support dynamic secrets from vaults without restarts. The forwarder is marked with @ZeroTracing to prevent self-tracing and includes improved diagnostic logging for OTLP export failures, such as HTTP 404/401/403 errors with actionable hints.

opentelemetry-forwarder · high confidence

New platform-core system components for event streaming and service initialization

This change introduces a set of new core classes in the platform-core system package that establish the foundation for event-driven communication and streaming. AutoStart serves as the entry point to initialize the application, while EssentialServiceLoader registers critical internal services like AsyncHttpClient and Telemetry before application startup. The EventEmitter acts as the central hub for managing event routing, including configuration for multicast, journaling, and event-over-HTTP. Supporting this are EventPublisher and FluxPublisher for delivering messages to event streams, EventStreamWriter for handling HTTP response streaming with proper trace context, and LocalPubSub for in-memory topic-based communication. The Platform class provides the core singleton managing the Vertx engine, thread pools, and service registry, while PostOffice handles message sending with trace and correlation context, and PubSub abstracts the underlying event stream provider.

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

New reactive PostgreSQL example application

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

New reactive PostgreSQL extension with named parameters and transaction support

This change introduces a new reactive PostgreSQL extension that enables developers to execute queries and updates using named parameters (e.g., :id) alongside positional parameters, with automatic conversion to the $n syntax required by R2DBC. It adds a \PgTransactionBuilder\ to construct multi-step transactions across multiple tables, ensuring all-or-none execution via \PgService\. The extension includes a built-in health check mechanism (\PgHealth\) that tracks application instance status in a \health\_check\ table, along with configuration (\ReactivePgConfig\) for connection pooling and JSR-310 date/time conversions.

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

New serialization and XML parsing utilities

The platform introduces a new set of core serialization components in the \serializers\ package. \PayloadMapper\ provides a centralized, type-aware encoder/decoder for messages, now supporting \java.time.Instant\ alongside legacy \Date\ types. \SimpleMapper\ replaces or supplements the previous JSON handling by wrapping Google Gson with explicit adapters for \java.time\ types (\Instant\, \LocalDate\, \LocalDateTime\, \LocalTime\, \OffsetDateTime\) and SQL types, while respecting configuration for snake\_case or camelCase field naming. Additionally, \SimpleXmlParser\ and \SimpleXmlWriter\ provide a lightweight, secure (XXE-protected) alternative to Jackson for converting between XML and Map structures, enabling applications to handle XML payloads without the overhead of a full XML mapper.

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

New service-monitor connector for presence tracking and topic management

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

New standalone Redis helper for local development and testing

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

New standalone Schema Registry mock for local development

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

New starter templates for Layer 1, 2, and 3 applications with AI-assisted development support

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

New starter templates for function-based and flow-based applications

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

New static template pages for the MiniGraph service and playground

The service now serves dedicated HTML templates for its entry points and demo interfaces. The main entry page (index.html) provides direct links to the INFO, Library dependency, Routing, Health, and Environment endpoints. The playground entry point (playground.html) loads the modern React-based UI via preloaded JavaScript and CSS assets. Additionally, standalone WebSocket demo pages (ws-graph.html and ws-json.html) are included to allow users to manually test graph and JSON-path WebSocket connections with built-in keep-alive and input history features.

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

New streaming return-path primitives: StreamSegment and EventStreamSink

The sync-over-async extension now includes the core data model and sink for its streaming capabilities. A new \StreamSegment\ record defines the unit of data exchanged over the rendezvous queue, supporting \data\, \eof\, and \exception\ types with optional SSE event names. The new \EventStreamSink\ class consumes these segments and forwards them to the HTTP response writer, handling the final mile of SSE/chunked framing, ordered replies, and disconnect handling. This provides the foundation for streaming return routes within the single-JVM end-to-end flow.

sync-over-async · high confidence

New streaming return-route components for cross-pod LLM token delivery

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

New sync-over-async demo with JSON Schema and Avro transport variants

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

New twin-kafka-demo worked example for dual-cluster bridging

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

New type-conversion and data-mapping plugins for Event Script

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

New utility classes for content-type resolution, MIME mapping, and HTTP handling

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

New zero-dependency MessagePack codec replaces msgpack-core

The system/minimalist-msgpack module introduces a new, zero-dependency MessagePack codec (MsgPackReader and MsgPackWriter) that replaces the previous msgpack-core library. This new implementation reads and writes nil, boolean, integer, float, string, binary, array, and map values using the official specification, ensuring compatibility with existing MessagePack data. It is designed for thread safety with no shared state, making it suitable for use in virtual threads, and includes robust error handling for malformed input, such as invalid format bytes and buffer overflows.

system/minimalist-msgpack · high confidence

Node.js Kafka demo helpers with trace continuity and second-level routing

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

Persistent WebSocket client with automatic reconnection and keep-alive

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

Plain home page for non-development environments

A static index.html has been added to serve as the root entry point when the application is not running in development mode. This page displays a simple 'MiniGraph Service' heading and provides links to various informational and health endpoints (such as /info, /health, and /env), ensuring that production deployments have a valid root page instead of the interactive Playground UI which is reserved for the dev environment.

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

Platform core introduces deterministic serialization, streaming HTTP client, and in-memory graph support

The platform-core module adds several new capabilities: a new AsyncHttpClient for asynchronous HTTP requests with streaming support; a MiniGraph in-memory property graph for lightweight graph processing; a CanonicalPackager for deterministic MsgPack serialization ensuring consistent byte output across engines; and updated serialization models including FutureInbox and FutureMultiInbox for improved RPC response handling. These changes enhance the platform's ability to handle complex data serialization, asynchronous communication, and graph-based workflows.

platform-core · high confidence

Playground session broker for AI agent hosting

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

Redis-based suspend/resume state store with for\_each iteration isolation

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

Scheduler example adds active-active environment switching and admin endpoints

The scheduler example now includes support for active-active deployments (RFC-0008) by introducing an operations dashboard endpoint at \/api/scheduler/environment\. This allows operators to switch the active environment (e.g., from 'prod' to 'DR') via a POST request, with the state persisted through a configurable store (\v1.environment.store\) so that all instances follow the change at the next scheduled point. The example also provides a new admin endpoint at \/api/schedule\ to list scheduled jobs and \/api/schedule/{name}\ to view or trigger individual jobs, backed by a sample file-based state resolver (\v1.state.resolver\) and environment store (\EnvironmentStore\) for demonstration purposes.

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

Secondary Kafka cluster support with health checks and notification routing

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

Ship reusable sync-over-async flow tasks

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

Spring Boot 4 REST container with built-in actuator endpoints and HSTS

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

Workspace clipboard with persistent storage, drag-and-drop, and sorting

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

Security

Security patches for Kafka clients and HTTP core

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

Behavioural changes

Configurable trace-id headers with per-entry overrides

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

Core utility classes refactored and replaced with modern implementations

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

Distributed Redis cache service with specific error classification

The distributed-cache extension now exposes a Redis-backed cache service at route v1.cache.redis, supporting GET, PUT, DELETE, MGET, MPUT, and list operations via a shared connection. A key behavioral improvement is the classification of Redis failures: command timeouts now return HTTP 408 and unreachable Redis instances return HTTP 503, allowing callers to distinguish between transient network issues and specific command timeouts rather than receiving a generic 500 error.

distributed-cache · high confidence

Documentation rewrite: new site structure and terminology

The documentation has been restructured into a seven-part hierarchy (Orientation, Foundations, and three specific layers for Event-driven, Composable, and Knowledge Graph, plus Operate and Reference). This change introduces a 'Foundations' section for framework-wide concepts, adds 'Overview' pages for each layer, and standardizes the navigation shape. Additionally, the request-pipeline stage previously called 'event boundary' is now named 'protocol boundary' for greater precision, and all legacy URL redirects have been removed in favor of a clean rewrite with no backward compatibility.

memory/sessions · high confidence

Enforced pre-commit secret scanning and post-commit session logging

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

Kafka Presence adapter now uses AutoStart for consistent initialization

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

Kafka consumer rebalance protocol auto-detection and configuration hardening

The Kafka flow adapter now automatically detects whether the connected cluster supports the KIP-848 consumer rebalance protocol by probing the cluster's finalized \group.version\ feature flag, resolving \group.protocol=auto\ to either \consumer\ or \classic\ without manual configuration. This change introduces a \GroupProtocolResolver\ that safely probes the cluster using only connection credentials (no ACLs required) and includes conflict guards to prevent incompatible client-side tuning settings (like \session.timeout.ms\) from being used with the new protocol. Additionally, the module externalizes Kafka client configuration to external template files, allows per-binding dead-letter queue (DLQ) topics, supports regex-based topic subscriptions, and enables optional consumer partition pinning for specific deployment models.

system/minimalist-kafka/src/main/java/org/platformlambda/mini/kafka · high confidence

Mandatory graph compilation gate and deprecated syntax conversion

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

New Lambda example entry point using AutoStart

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

New common infrastructure and validation rules for graph execution

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

New default configuration, logging, and static resource templates

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

New minimalist-jsonpath engine replaces Jayway JsonPath

The system now uses a new in-house JSONPath engine, minimalist-jsonpath, which implements the RFC 9535 standard. This engine replaces the previous Jayway JsonPath library, removing the dependency on json-smart (which had an unresolved vulnerability) and ensuring consistent behavior with the Rust engine. The new engine supports the full RFC 9535 specification, including segments, selectors, filters, literals, functions, and regular expressions, with type-strict comparisons and strict adherence to the standard's grammar. It also includes a lenient mode for handling hyphens in dot-notation member names, matching the behavior of the Rust engine.

minimalist-jsonpath, system/minimalist-jsonpath · high confidence

Playground UI rebuild and dependency updates

The playground webapp assets have been regenerated, reflecting a refresh of npm dependencies and a Vite upgrade from 8.1.5 to 8.3.5. The updated CSS bundle introduces a comprehensive visual overhaul of the interface, including refined styling for the graph canvas, node authoring rings, and connection banners, alongside improved UI components for the console, payload editor, and command input.

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

Redis connection resets on timeout instead of waiting for Lettuce backoff

The shared Redis command connection now resets immediately when a command times out, rather than waiting for Lettuce's internal exponential backoff (capped at 30 seconds). This change ensures that recovery is bounded by the configured command timeout (redis.timeout.ms), providing a faster and more honest failure response (503 Redis unavailable) during outages or slow servers, while preventing connect storms via a 250ms retry hold window.

redis-connection · high confidence

Structured JSON logging with automatic trace context

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

Sync-over-async demo adds error handler with 5xx-to-503 remapping

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

Test coverage

Added PoJo test model for event script engine tests; Added TestBase for Lambda Example Common Tests; Added contract and file-specific tests for FileElasticStore; Added emulated LLM round-trip and unit tests for the sync-over-async demo; Added integration and unit tests for the scheduler example; 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 infrastructure for service-monitor tests; Added mock service functions for testing platform features; Added mock test infrastructure for OpenTelemetry trace forwarding; 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 graph engine core components; 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 and flow manifests for the event-script-engine; Added test resource configuration for composable-example; Added test resource configuration for reactive Postgres integration tests; 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 decimal arithmetic plugin operand handling; Added tests for decision plugins: range bounds, simple lookup, and range lookup; 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 OTLP forwarder's export reliability and diagnostics; Added tests for the OpenTelemetry forwarder and span data mapping; 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 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.

How this codebase got here

This is the PUBLIC form of this artifact. Findings are listed in full, but the details of SECURITY findings — which rule fired, in which file, on which line, and how to fix it — are deliberately withheld, and any secret-scanner results are excluded entirely. Where detail is absent here it was REMOVED FOR PUBLICATION; it is not missing from the analysis. The complete artifact is available from the repository owner.

Score

  • CAI 53 → 58 (+4.4)

Lenses

  • Code Health 75 → 75 (+0.1)
  • Architecture 97 → 97 (-0.3)
  • Maturity 55 → 84 (+28.6)
  • Readiness 57 → 57 (+0.5)
  • Security 69 → 89 (+20.3)
  • Accessibility 44 → 44 (+0.0)
  • Performance 78 → 78 (+0.0)

Resolved (76)

  • Context/problem and consequences/trade-offs are both absent from the visible text (memory/archive/2026-Q3.md)
  • High: security finding (details withheld)
  • Low: security finding (details withheld)
  • Medium: security finding (details withheld)
  • Medium: security finding (details withheld)
  • Medium: security finding (details withheld)
  • Medium: security finding (details withheld)
  • Medium: security finding (details withheld)
  • Medium: security finding (details withheld)
  • Medium: security finding (details withheld)
  • Medium: security finding (details withheld)
  • Medium: security finding (details withheld)
  • Medium: security finding (details withheld)
  • Medium: security finding (details withheld)
  • Medium: security finding (details withheld)
  • Medium: security finding (details withheld)
  • Medium: security finding (details withheld)
  • Medium: security finding (details withheld)
  • Medium: security finding (details withheld)
  • No SBOM
  • …and 56 more

New (10)

  • ClassTooLong: Parser (system/minimalist-jsonpath/src/main/java/org/platformlambda/mini/jsonpath/Parser.java)
  • Documentation: no installation or build instructions (extensions/reactive-postgres/README.md)
  • Duplicated block (13 lines × 2) (system/event-script-engine/src/main/java/com/accenture/util/RangeNotation.java)
  • Duplicated block (6 lines × 2) (system/event-script-engine/src/main/java/com/accenture/util/JsonPathSource.java)
  • Duplicated block (6 lines × 3) (system/event-script-engine/src/main/java/com/accenture/util/JsonPathSource.java)
  • FileTooLong: util/DataMappingHelper.java (system/event-script-engine/src/main/java/com/accenture/util/DataMappingHelper.java)
  • Off the main sequence: minimalist-jsonpath
  • Only one decision and two testable consequences are visible: the standalone schema-registry mock server (Avro/JSON Schema, Confluent-compatible REST API) is implemented; a final validation round upgrading agent-memory v4.25.0 to v4.26.1 with 0 lint errors; and an upgrade plan for v4.23.1→v4.25.0 (three rungs + re-synced docs). The decision 'Schema Registry feature' is a minor one-line entry in the body, not a real Decision section. (memory/archive/2026-Q3.md)
  • Projects may be oversized for their cohesion
  • TooManyMethods: Parser (system/minimalist-jsonpath/src/main/java/org/platformlambda/mini/jsonpath/Parser.java)

Changes since last survey

  • 7 commits — 6 feature/other, 1 fixes

By area

  • memory/open-threads — 2 commits
  • system/minimalist-jsonpath — 2 commits
  • docs/arch-decisions — 1 commit
  • memory/sessions — 1 commit
  • system/platform-core — 1 commit

Notable commits

  • fix: fix: a WebSocket session's exception warning names the exception type (#582)
  • change: chore: close the local Sonar findings in the RFC-0010 code; no behaviour change (#581)
  • change: docs: ADR-0031 - JSONPath is RFC 9535 on both engines; minimalist-jsonpath replaces Jayway JsonPath (RFC-0010 promoted) (#580)
  • change: feat: JSONPath follows RFC 9535 - an in-house engine, minimalist-jsonpath, replaces Jayway JsonPath (RFC-0010) (#579)
  • change: memory: invariant re-verification walked with Eric - 19 core facts and the Vision confirmed, two wordings refreshed; the doc-improvement thread closed
  • change: memory: review 2026-10-22 - 13 footers refreshed, 10 faded facts archived, 2 completed threads swept; invariant re-verify and stalled-thread gates raised
  • change: memory: session 2026-10-22-224554 - the third reactor run and the #581 merge

Architecture

  • Containers 0 added · 0 removed · contexts 1 added · 0 removed · edges 1 added · 0 removed

Added bounded contexts (1)

  • minimalist-jsonpath

Added dependency edges (1)

  • platform-core → minimalist-jsonpath

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

Survey your own repository

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.

About this page

  • The score is its most recent published measurement, taken on 23 October 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
  • Measured at commit 7fd23ebe15890070e6717dff5291510eade6378a — the exact code this score is about.
  • Scored under rubric-2026.10.5 — the same rubric and the same method as every other entry in this index.
  • Measured by watchdog.canine.dev using codehealth-analyzer measure-2026.10.6+preprod-d36780c2d857.