Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Inline comments:
In `@wavefront/server/apps/floware/floware/server.py`:
- Around line 270-275: The consumer task is being fire-and-forgeted and not shut
down properly; keep a Task reference for
AsyncAgenticExecutionResultConsumer.start() (and similarly for
start_redis_listener) on the server instance, and on application shutdown call
the consumer.stop() method and await the stored Task to ensure cooperative
shutdown; update the wiring where AsyncAgenticExecutionResultConsumer is
instantiated to store the returned asyncio.Task (instead of discarding it) and
add shutdown logic that calls AsyncAgenticExecutionResultConsumer.stop() and
awaits the Task to avoid abrupt cancellation and RUF006.

In
`@wavefront/server/background_jobs/celery_worker/celery_worker/tasks/agent_task.py`:
- Line 114: The variable `namespace` is unpacked but never used; rename it to
`_namespace` at the unpacking site to mark it intentionally unused (i.e., change
the tuple assignment that currently includes `namespace` to use `_namespace`),
and update any local references if present to use the new name; keep the rest of
the logic in the same function (the unpacking location in agent_task.py)
unchanged.
- Around line 19-20: MAX_RETRIES and RETRY_DELAY are parsed with
int(os.getenv(...)) which raises ValueError on non-integer env values and will
break module import; update the parsing logic for the constants (MAX_RETRIES,
RETRY_DELAY) to validate and safely convert the env values by checking/os.getenv
return and wrapping int(...) in a try/except (catch ValueError) or using a
helper parse_int_with_default that returns the provided default on error, and
ensure you still convert valid numeric strings to int while falling back to '0'
and '30' respectively and optionally log a warning when a malformed value is
detected.

In
`@wavefront/server/background_jobs/celery_worker/celery_worker/tasks/workflow_task.py`:
- Around line 19-20: Handle possible ValueError when parsing
CELERY_TASK_MAX_RETRIES and CELERY_TASK_RETRY_DELAY_SECONDS by wrapping the
int() conversions for MAX_RETRIES and RETRY_DELAY in a safe-parse routine: catch
ValueError (and TypeError) and fall back to the default values (0 and 30
respectively), and emit a warning via the module logger (or print) indicating
the invalid env var and the fallback used; implement this logic replacing the
direct int(os.getenv(...)) calls so imports won't fail on malformed env values.

In
`@wavefront/server/background_jobs/celery_worker/celery_worker/worker_setup.py`:
- Around line 80-82: The plain print statement exposing ADC project and
GOOGLE_CLOUD_PROJECT should be removed or guarded; replace the print in
worker_setup.py with a logger.debug call (e.g., logger =
logging.getLogger(__name__); logger.debug(...)) and ensure it only emits when
debug is enabled (wrap with a check like if settings.DEBUG or an explicit
ENV_DEBUG flag or rely on logger level configuration) so sensitive project
identifiers are not printed in production logs.

In
`@wavefront/server/modules/agents_module/agents_module/services/async_agentic_execution_result_consumer.py`:
- Around line 52-85: The comment and error-handling around Redis Streams in
AsyncAgenticExecutionResultConsumer are incorrect and allow failed messages to
remain stuck in the PEL; update the comments around _cache.xgroup_create and the
xread_group call to state that id='0' only sets the initial offset for new
groups and that XREADGROUP with '>' only returns new, never-delivered messages
(pending entries must be explicitly handled). Modify the consumer to explicitly
ack-and-skip permanently unprocessable payloads (e.g. when parsing execution_id
fails inside the _process(fields) flow) instead of letting them remain pending:
catch the specific parse/validation error, call _cache.xack for the msg_id, log
the problem, and continue. As an improvement add a startup or periodic
pending-entry drain (call XAUTOCLAIM/XCLAIM or an initial XREADGROUP with a
numeric id) to reclaim stale PEL entries for retry; keep existing general
retry/backoff for transient processing errors but do not rely on process restart
to redeliver pending messages.

In
`@wavefront/server/modules/agents_module/agents_module/services/async_agentic_execution_service.py`:
- Around line 380-382: The pagination is applied after limiting (records = await
self.repo.find(**filters, limit=limit) then records = records[offset:]) which
breaks pages; update the call to self.repo.find to pass both offset and limit
(i.e., include offset=offset alongside limit=limit) and remove the in-memory
slice, so pagination is done by the repository; locate this change in the
AsyncAgenticExecutionService method where self.repo.find is called and adjust
parameters accordingly (or if repository lacks support, fetch all then slice,
but prefer adding offset to repo.find).
- Around line 203-210: The DB record is created before calling
get_celery_client().send_task, so if send_task raises we leave a permanent
"pending" row; wrap the send_task call in a try/except and on failure perform a
compensating update via the repository (e.g., use self.repo.find_one_and_update
on the execution id to set status='failed' and record the exception message in
an error field, or delete the execution row if that is preferred) and re-raise
or return an appropriate error; apply the same try/except+compensation pattern
to the other enqueue path that uses get_celery_client().send_task (the block
referenced around lines 265-272) so no orphaned pending records remain.
- Around line 129-134: Replace the naked base64 decoding with a guarded decode
that catches invalid input: wrap the base64.b64decode(raw_b64, validate=True)
call in a try/except that catches binascii.Error/ValueError and returns or
raises a controlled validation error (e.g., raise a ValidationError or return a
4xx response) instead of letting the exception bubble, then only call
self.cloud_storage.save_small_file(file_content=file_bytes,
bucket_name=self.bucket, key=key) after a successful decode; reference the
raw_b64 variable, the file_bytes result, and the
self.cloud_storage.save_small_file call to locate where to add the try/except
and error mapping.

In `@wavefront/server/modules/agents_module/agents_module/utils/celery_client.py`:
- Around line 6-7: get_celery_client currently uses
os.environ['CELERY_BROKER_URL'] which will raise a raw KeyError on missing
config; change it to read the broker via os.getenv('CELERY_BROKER_URL') (or
os.getenv with a sensible default used elsewhere) and explicitly validate the
result in get_celery_client: if the value is None or empty, raise a clear
RuntimeError (or ValueError) with a descriptive message about the missing
CELERY_BROKER_URL, otherwise pass the value into Celery('async_executor',
broker=<validated_value>); reference the get_celery_client function and Celery
call when making this change.

In
`@wavefront/server/modules/db_repo_module/db_repo_module/alembic/versions/2026_05_12_1549-3b5b1bf90e6c_add_async_agentic_executions.py`:
- Around line 24-57: The migration creates the async_agentic_executions table
with free-form entity_type and status columns which need DB-level constraints;
update the migration that defines table async_agentic_executions to add
constraints for entity_type and status (either replace those sa.String columns
with a database enum type or add sa.CheckConstraint checks) and ensure the
chosen allowed values (e.g., the lifecycle statuses used by your application)
are enforced and created/dropped in upgrade()/downgrade() so the constraint is
present for status and entity_type validation at the DB level.

---

Nitpick comments:
In `@wavefront/server/background_jobs/celery_worker/celery_worker/main.py`:
- Around line 1-8: The file calls load_dotenv() after importing
celery_worker.celery_app (which itself already calls load_dotenv()), causing
redundancy and a potential ordering issue; fix by either moving the standalone
load_dotenv() call to the very top of this module before any imports (so
environment variables are guaranteed before importing celery_worker.celery_app)
or simply remove the load_dotenv() line since celery_worker.celery_app already
performs dotenv loading—update main.py accordingly and keep the imports to
reference app and tasks (celery_worker.celery_app,
celery_worker.tasks.agent_task, celery_worker.tasks.workflow_task).

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Inline comments:
In `@wavefront/server/apps/floware/floware/server.py`:
- Around line 186-188: Replace the reuse of agent_yaml_bucket for execution
artifacts by adding a new config key agents.executions_bucket and wiring it
through where the bucket is passed: change the call site that currently uses
executions_bucket=config['agents']['agent_yaml_bucket'] in floware.server (same
invocation that passes async_agentic_execution_repository) to use
executions_bucket=config['agents']['executions_bucket'], and make the equivalent
change in celery_worker.worker_setup (where the worker reads agent YAML bucket)
so both files read agents.executions_bucket; also update the
config/schema/defaults to define agents.executions_bucket and ensure any code
that constructs S3/GS clients or performs lifecycle/ACL operations references
the new key instead of agent_yaml_bucket.

In
`@wavefront/server/background_jobs/celery_worker/celery_worker/tasks/workflow_task.py`:
- Around line 17-30: The current services.cache.xadd call that emits the
'in_progress' event in _run is outside the try/except so a Redis error can
bubble out and prevent the workflow from publishing a 'failed' event; wrap the
services.cache.xadd(STREAM_NAME, {...}) call either inside the existing try
block that surrounds the workflow execution or in its own small try/except that
catches/logs the xadd failure (using execution_id) and continues so the main run
proceeds and the existing failure-handling path can still publish the 'failed'
event; ensure you reference the same STREAM_NAME, the execution_id from payload,
and keep the error field consistent with the other event emissions.

In
`@wavefront/server/modules/agents_module/agents_module/controllers/async_inference_controller.py`:
- Around line 157-229: get_execution_status and list_executions lack tenant/user
scoping and error handling, allowing cross-tenant reads; add ownership fields to
the AsyncAgenticExecution model (e.g., tenant_id and user_id), call
extract_auth_credentials(request) in both
async_inference_controller.get_execution_status and .list_executions to obtain
the caller principal, pass those credentials into AsyncAgenticExecutionService
methods (get_execution_status and list_executions) so the service filters by
tenant_id/user_id (and validates entity_id ownership when entity_id is
provided), and wrap the list_executions service call in a try/except ValueError
to return the same 4xx JSONResponse pattern used in get_execution_status.
- Around line 50-68: The controller currently builds an incomplete llm_config
dict (only 'type','llm_model','api_key','base_url') which drops required fields
like display_name, parameters and model_type and will cause
LlmInferenceConfig(**llm_config_dict) to fail; instead pass the full
llm_config_dict returned from
llm_inference_config_service.get_config(payload.llm_inference_config_id) into
the Celery task (or serialize the full LlmInferenceConfig object) rather than
whitelisting fields here—update async_inference_controller.py to remove the
field subset logic and forward the complete dict (or a serialized
LlmInferenceConfig) so agent_task.py receives the full config.

---

Duplicate comments:
In
`@wavefront/server/modules/agents_module/agents_module/services/async_agentic_execution_service.py`:
- Around line 384-403: The list_executions implementation is doing in-memory
pagination by calling repo.find(limit=offset+limit) and slicing
records[offset:], which is inefficient; update the repository and call sites to
support SQL-level offset. Change SQLAlchemyRepository.find signature from def
find(self, limit: int = 100, **filters) to def find(self, offset: int = 0,
limit: int = 100, **filters) and in the query builder chain .offset(offset)
before .limit(limit) in both code paths; then update
AsyncAgenticExecutionService.list_executions to call
self.repo.find(offset=offset, limit=limit, **filters) and remove the Python
slice so it returns [self._build_status_response(r.to_dict()) for r in records].

---

Nitpick comments:
In `@wavefront/server/apps/floware/floware/server.py`:
- Around line 286-296: The shutdown currently cancels
async_agentic_exec_consumer_task on TimeoutError but returns without awaiting
it, which can prevent the consumer's cleanup from running; after calling
async_agentic_exec_consumer_task.cancel() (and logger.warning) await the task
and catch and swallow asyncio.CancelledError (or use
asyncio.shield/asyncio.wait_for as appropriate) so the consumer's
finally/cleanup (e.g., xack/closing Redis) runs before lifespan exits; keep the
existing scheduler_manager.shutdown() and async_agentic_exec_consumer.stop()
calls and only proceed after the awaited cancellation completes.

In
`@wavefront/server/background_jobs/celery_worker/celery_worker/tasks/workflow_task.py`:
- Around line 8-13: Refactor the four private helpers (_build_history, _now,
_reconstruct_inputs, _save_json) out of agent_task into a new neutral module
(e.g., celery_worker/tasks/_helpers.py) with public names (build_history →
build_history, _now → now, _reconstruct_inputs → reconstruct_inputs, _save_json
→ save_json); move the implementations into that file, update both agent_task
and workflow_task to import these helpers from celery_worker.tasks._helpers
instead of importing leading-underscore symbols, and update any call sites in
workflow_task.py and agent_task.py to use the new public function names to
remove the cross-module private import coupling.

In `@wavefront/server/modules/agents_module/agents_module/utils/celery_client.py`:
- Around line 6-10: get_celery_client currently constructs a new
Celery('async_executor', broker=...) on every call; change it to build the
Celery app once and return the cached instance (e.g., create a module-level
variable like _celery_app or decorate get_celery_client with
functools.lru_cache(maxsize=1)) so repeated calls reuse the same Celery object;
keep the existing env var check for CELERY_BROKER_URL and ensure the cached
instance is created using that value and returned by get_celery_client.