Skip to content
CAI
Software that uses CAICheck a score

marciok/gust

48.7

Weak · 15 November 2026

11.5k

lines of production code

Elixir

primary language

5

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Features

Add Elixir adapter for DAG parsing

Users can now define and parse DAGs written in Elixir. A new adapter module parses \.ex\ files that use the Gust DSL, compiling the code to extract task definitions, options, and graph structure, and supports task-level options such as \store\_result\, \skip\_if\, \map\_over\, and \wait\_for\.

apps/gust/lib/gust/dag/parser/adapters · high confidence

Add Python DAG parser adapter

Introduces a new parser adapter for Python DAGs, enabling the system to parse \.py\ files by invoking an external \parse\ command via the \uv\ tool. The adapter handles execution errors, such as missing \uv\ or invalid JSON output, and maps the resulting JSON structure into internal DAG definitions, including task dependencies, store result options, and scheduling configurations.

_apps/gust\_py/lib/gust\py/parser · high confidence

Add shell-based DAG task execution with EEx template support

The \gust\_shell\ application introduces a new adapter-based system for executing Directed Acyclic Graph (DAG) tasks as shell commands. This includes a parser that reads YAML definitions, a runtime adapter, and a task worker that executes commands via \:exec.run\, capturing stdout/stderr and handling exit codes or signals through a dedicated \ShellExitError\. A key feature is the integration of EEx templates for task commands and environment variables, allowing dynamic injection of run parameters, secrets, and previous task results at runtime.

_apps/gust\shell/lib · high confidence

Added Postgres implementation for database advisory locking

A new module, Gust.DBLocker.Postgres, has been introduced to provide database-backed advisory locking specifically for PostgreSQL. This implementation utilizes the \pg\_try\_advisory\_lock\ function within a repository checkout to attempt acquiring a lock based on a provided key, passing the success status to a callback function. This adds a concrete backend for the DBLocker behavior, enabling distributed locking capabilities in environments using PostgreSQL.

_apps/gust/lib/gust/db\locker · high confidence

Added release scripts for distributed node startup, CLI access, and migrations

The release now includes shell scripts to support distributed operation and tooling. The \env.sh.eex\ configuration sets the release node name based on the host IP to enable node connections. New overlay scripts allow users to start the core service (\start-core\), run database migrations (\migrate\), and access the CLI in console mode (\gust-cli\).

apps/gust/rel · high confidence

Elixir adapter for task execution with skip logic and serialization validation

The Elixir adapter for the DAG task worker has been implemented to handle task execution, allowing tasks to be conditionally skipped via a \skip\_if\ option and ensuring that results intended for storage are JSON-serializable. It includes robust error handling that captures stack traces for both Elixir exceptions and process exits, and distinguishes between recoverable errors and non-recoverable errors to improve debugging and fault tolerance.

_apps/gust/lib/gust/dag/task\worker · high confidence

Initial release of Gust task orchestration system

This entry marks the initial release of Gust, a task orchestration system built on the Erlang VM. The repository now includes the core application structure, a setup script for generating new Gust projects, and comprehensive documentation covering features like DAG-based workflows, scheduling, and an MCP server for LLM integration. Configuration examples and development guidelines are provided to help users get started.

(repo-wide) · high confidence

Initial release of GustPy app with project scaffolding

The GustPy application has been added to the project, providing the foundational structure for integrating Python DAG support. This change introduces the core app module, standard Elixir project configuration files (formatter, gitignore), and documentation guides covering installation, writing Python DAGs, and internal mechanics, establishing the initial scaffolding for the feature.

_apps/gust\py · high confidence

Introduce Python task messenger with frame-based JSON protocol

Added a new communication layer for interacting with Python tasks, featuring a frame codec that serializes messages with 32-bit length prefixes and a JSON handler that processes log, call, result, and error messages. The handler supports retrieving secrets and task runs by name and run ID, raising an error if a task is not found, and sending replies back to the Python process.

_apps/gust\_py/lib/gust\_py/task\messenger · high confidence

Introduce UV-based Python task execution

The executor now supports running Python tasks via the \uv\ tool. A new \GustPy.Executor.UV\ module handles task invocation by locating the \uv\ executable and executing it with specific arguments for DAG and task identification. If \uv\ is not found on the system path, the execution fails with a clear error rather than crashing, ensuring robustness when the dependency is missing.

_apps/gust\_py/lib/gust\py/executor · high confidence

Introduces database-backed task waiting and resumption logic

Adds a new repository implementation for the DAG task waiter that manages task states in the database. This change enables tasks to wait for specific conditions and be resumed via a transactional operation that updates task parameters and broadcasts status changes. It also supports failing waiting tasks and clearing their wait state, ensuring that dependent runs are triggered appropriately upon resumption or failure.

_apps/gust/lib/gust/dag/task\waiter · high confidence

Introduces extensible runtime adapter protocol for DAG execution

Users can now plug in new languages or execution environments into the Gust DAG runtime via a standardized adapter interface. The diff introduces a new \Gust.DAG.Runtime.Adapter\ protocol defining lifecycle callbacks (\setup\, \teardown\, \on\_finished\_callback\, \kill\) and provides an initial Elixir-specific implementation (\Gust.DAG.Runtime.Adapters.Elixir\) that handles compiling DAG definitions, managing module lifecycles, and executing callbacks. This change enables future support for non-Elixir runtimes by abstracting the execution details behind the adapter contract.

apps/gust/lib/gust/dag/runtime · high confidence

New Gust DAG examples for orchestration and AI workflows

Added example DAGs to the \examples/dags\ directory to demonstrate Gust's capabilities. These include \hello\_world.ex\ for basic task chaining, \parent\_waits\_for\_child.ex\ and \child\_resumes\_parent.ex\ for inter-DAG triggering and synchronization using \TaskWaiter\, \daily\_stock\_decider.ex\ for an LLM-based stock analysis workflow, \fusion\_prompt.ex\ for multi-model panel evaluation via OpenRouter, and shell-based YAML DAGs (\file\_backup.yml\, \parallel\_build.yml\) for build and backup pipelines. A \README.md\ was also added to document these examples.

examples/dags · high confidence

New Gust Web dashboard, API, and MCP server components

This change introduces the core web interface and integration layers for Gust. The dashboard router and LiveViews provide a new UI for managing DAGs, viewing run history, and performing task actions like canceling or restarting. An API controller and router macro expose endpoints for creating DAG runs and resuming waiting tasks. Additionally, an MCP (Model Context Protocol) server implementation is added, allowing external tools to interact with Gust via JSON-RPC to list DAGs, query runs, and trigger or manage tasks.

_apps/gust\web/lib · high confidence

New Mix task for CLI execution

A new Mix task, \gust.cli\, has been added to the application. Running this task executes the \Gust.CLI.exec/1\ function with the provided arguments and displays the result to the user, defaulting the \GUST\_ROLE\ environment variable to \console\ if not already set.

apps/gust/lib/mix · high confidence

New distributed run claiming mechanism with configurable lease times

A new repository implementation for run claiming has been added, enabling distributed workers to safely acquire and renew execution leases for DAG runs. The system now supports a configurable lease duration via the \claim\_lease\_seconds\ environment variable (defaulting to 15 seconds), allowing workers to renew their claim on a run or acquire a new one from the queue using optimistic locking (\FOR UPDATE SKIP LOCKED\). This ensures that only one worker processes a specific run at a time, preventing duplicate execution in a multi-node setup.

apps/gust/lib/gust/run/claim · high confidence

New requeue trigger implementation for resetting and re-queuing DAG runs

A new \Requeue\ trigger module has been introduced to handle the reset and re-queuing of DAG runs and tasks. This component implements the \Gust.DAG.Run.Trigger\ behaviour, providing specific logic to reset entire runs or downstream task branches by updating task statuses to \:created\ and dispatching them via the \Dispatcher\. It distinguishes between resetting a task group and resetting individual mapped task instances, ensuring that downstream dependencies are correctly cleared and re-queued for execution.

apps/gust/lib/gust/dag/run/trigger · high confidence

Role-based runtime architecture with CLI and DAG DSL enhancements

Gust now supports distinct runtime roles (console, web, core, single) to control which background workers are active, allowing users to run a lightweight console for DAG management without dispatching runs or a web interface without background execution. A new CLI (\gust-cli\) enables triggering DAG runs with optional JSON parameters and inspecting DAG definitions from the command line. The DAG DSL has been extended with \task\_action\ for reusable code, \skip\_if\ for conditional execution, \map\_over\ for parallel item processing, \wait\_for\ for external event synchronization, and non-recoverable error handling via \Gust.DAG.NonRecError\. Internally, the application uses a database-backed leader election for distributed coordination, PostgreSQL notifications for run dispatching, and a file watcher for live DAG reloading in development.

apps/gust/lib/gust · high confidence

Removals

Removal of RunRestarter worker implementation

The \Gust.DAG.RunRestarter.Worker\ module has been removed from the codebase. This GenServer previously handled the logic for restarting DAG runs, tasks, and enqueued DAGs by interacting with the flow and loader services. Its deletion indicates that the run restarting functionality is being migrated to a different component, specifically the newly introduced \Trigger\ mechanism mentioned in the commit history.

_apps/gust/lib/gust/dag/run\restarter · high confidence

Behavioural changes

1 commit (0 fixes) modifying apps/gust\_web

A change to existing behaviour in apps/gust\_web — 1 commit, 6 files: “feat: show warning for triggered DAG; fixes \#173” (refs \#173). Also in this area: 4 commits (0 fixes) modifying apps/gust\_web.

_apps/gust\_web/test/gust\_web/live/dag\live · medium confidence · unverified

1 commit (0 fixes) modifying apps/gust\_web, e2e

A change to existing behaviour in apps/gust\_web, e2e — 1 commit, 8 files: “feat: health check for task and dag workers”.

e2e · medium confidence · unverified

2 commits (0 fixes) modifying apps/gust

A change to existing behaviour in apps/gust — 2 commits, 7 files: “feat: command returning a JSON”; “feat: e2e tests with playwright building on docker”. Also in this area: Added tests for the Gust CLI mix task.

apps/gust/test/mix · medium confidence · unverified

Added release scripts for Docker-based node connections and server startup

The gust\_web application now includes specific release environment and overlay scripts to support running in a Docker container. The \env.sh.eex\ script configures the release to distribute by name using the container's hostname, enabling node connections. Additionally, new \server\ and \migrate\ scripts (for both Linux and Windows) are provided to explicitly start the Phoenix server and run database migrations, facilitating single-mode execution within Docker.

_apps/gust\web/rel · high confidence

Configuration modernization: environment variables, new run dispatcher, and MCP support

This change updates the application configuration to improve security and flexibility. Database credentials, secret keys, and the secrets cloak key now read from environment variables (PGHOST, PGUSER, PGPASSWORD, SECRET\_KEY\_BASE, B64\_SECRETS\_CLOAK\_KEY) instead of being hardcoded, with production enforcing the presence of B64\_SECRETS\_CLOAK\_KEY. The run dispatcher is switched from the default to Gust.PGNotifier.Worker in config and Gust.Run.Pooler in tests, replacing the removed stage-based DAG runner supervisors with a cron reload option in dev. The Mailer and Swoosh configurations are removed entirely. Additionally, the Model Context Protocol (MCP) is enabled by default in development and test environments via mcp\_enabled: true, and the esbuild default path is set.

config · high confidence

DAG execution engine refactored with adapter support and new task behaviors

The DAG execution engine has been restructured to support pluggable adapters for different languages, allowing users to define DAGs using non-Elixir runtimes via the new \Gust.DAG.Adapter\ module. The scheduler has been removed in favor of a trigger-based model, and the runner processes now use a gateway pattern instead of the previous stage runner supervisor. Task execution now supports new behaviors including skipping tasks, waiting for external events via the \Gust.DAG.TaskWaiter\ behavior, and expanding tasks over lists using the \Gust.DAG.TaskExpander.MapOver\ implementation. Error handling has been improved with a new \Gust.DAG.NonRecError\ for non-recoverable failures that bypass retries, and stacktraces are now included in error reports. The \Gust.DAG.Folder\ module provides file-based DAG discovery, and task status management now explicitly distinguishes between cancellable and restartable states.

apps/gust/lib/gust/dag · high confidence

DAG parsing now supports pluggable language adapters

The DAG parser has been refactored to support multiple file formats through a new adapter system. Instead of hardcoding support for only \.ex\ files, the parser now iterates over registered adapter modules, allowing new languages to be plugged into Gust. This change introduces a new \Gust.DAG.Parser.Adapter\ behavior for defining parsers and extensions, and removes the previous \Gust.DAG.Compiler.Code\ module which handled Elixir-specific compilation and AST patching. Users can now extend the parser to handle other file types by implementing the adapter protocol.

apps/gust/lib/gust/dag/parser · high confidence

Database schema updates for task execution and run management

The database schema has been updated to support new task and run capabilities. The \gust\_runs\ table now includes claim fields (\claimed\_by\, \claim\_expires\_at\, \claim\_token\) and a \params\ map field. The \gust\_tasks\ table has been extended with \map\_index\ for dynamic mapping, \params\ for task parameters, \waiting\_for\ and \wait\_satisfied\_at\ for wait states, and \retry\at\ for retry logic. Additionally, existing tables (\dags\, \runs\, \tasks\, \logs\, \secrets\) have been renamed with the \gust\\ prefix to avoid naming collisions.

apps/gust/priv/repo · high confidence

Enhanced flow execution tracking and distributed run management

The Gust flows engine now supports more granular run and task states, introducing 'enqueued', 'starting', 'waiting', and 'skipped' statuses to better reflect execution progress. Runs can now carry arbitrary parameters and support claim-based distributed execution via new fields like \claimed\_by\ and \claim\_token\. Tasks are enhanced with support for map-based parallelism (\map\_index\), explicit waiting conditions (\waiting\_for\, \wait\_satisfied\_at\), and retry scheduling (\retry\at\). Additionally, all database tables have been prefixed with 'gust\' to prevent naming collisions, and unique constraints have been added to ensure task identity within a run.

apps/gust/lib/gust/flows · high confidence

File monitor now uses pluggable adapters for parsing

The file monitoring worker now delegates file parsing to a pluggable adapter system rather than using a hardcoded parser. When a file event is detected, the worker determines the appropriate adapter based on the file extension and passes the path to that adapter for parsing. This change enables support for new file types and languages by allowing new adapters to be plugged into the system, while maintaining the existing behavior of broadcasting parsed DAG data to the loader.

_apps/gust/lib/gust/file\monitor · high confidence

Introduce Python task execution adapter with stderr logging

The TaskWorker now includes a new Adapter module that executes DAG tasks as Python processes via the erlexec runtime. This adapter captures standard output as framed messages and logs standard error as warnings instead of printing them. It also introduces a dedicated error struct to handle and report task failures, such as process exits, back to the workflow engine.

_apps/gust\_py/lib/gust\_py/task\worker · high confidence

Introduces pluggable Python task execution and messaging interfaces

The GustPy application now exposes extensible interfaces for executing Python tasks and communicating with the Python runtime. A new Executor module provides a dispatch layer for running commands and starting DAG tasks, defaulting to a UV-based implementation, while a TaskMessenger module handles decoding and replying to messages from the Python side, defaulting to JSON. These changes replace the previous direct port-based communication with a structured, configurable messaging system that allows the underlying implementation to be swapped via application configuration.

_apps/gust\_py/lib/gust\py · high confidence

Mermaid charts now adapt to system dark mode

Mermaid diagrams rendered in the web interface now automatically switch between light and dark themes based on the user's operating system preference. The JavaScript hook listens for system theme changes and updates the diagram's internal theme setting (switching between 'base' and 'dark') to ensure visual consistency with the rest of the application.

_apps/gust\web/assets/js · high confidence

New extensible error reporting and DAG run trigger behaviors

The DAG runner now supports pluggable error reporting and run triggering via new behaviors. ErrorReporter defines a contract for reporting terminal task errors to external services (e.g., Sentry), with the worker capturing exceptions asynchronously and storing any returned external reference in the task's error map. Trigger defines a behavior for resetting and dispatching DAG runs and tasks, delegating to a configured implementation (defaulting to Requeue). These changes enable users to customize error tracking and run control logic without modifying core runner code.

apps/gust/lib/gust/dag/run · high confidence

New run execution engine with claimer, dispatcher, and pooler

The run execution subsystem has been replaced with a new architecture consisting of a Claimer, Dispatcher, and Pooler. The Claimer (Gust.Run.Claimer) is a GenServer that periodically claims runnable DAG runs from a durable queue and starts their execution via the RunnerSupervisor. The Dispatcher (Gust.Run.Dispatcher) provides a configurable abstraction for enqueuing runs, with the default implementation being the Pooler (Gust.Run.Pooler). The Pooler manages the polling loop, updates run statuses to 'enqueued', broadcasts status changes via PubSub, and wakes the Claimer to process new runs. This structure introduces a clear separation of concerns between dispatching, claiming, and execution, replacing the previous monolithic run handling logic.

apps/gust/lib/gust/run · high confidence

Python DAG runtime adapter implements task lifecycle management

The Python runtime adapter now supports full task lifecycle management, including the ability to kill running tasks via the runtime protocol, execute a callback upon task completion to report status, and handle setup and teardown by copying DAG files to a temporary directory and cleaning them up afterward.

_apps/gust\_py/lib/gust\py/runtime · high confidence

Refactor DAG termination to use a gateway instead of direct process management

The DAG terminator implementation has been refactored to replace the previous direct process-based termination logic with a new Gateway module. The old \process.ex\ module, which handled task cancellation and timer cancellation by directly killing processes and sending messages via the Registry, has been removed. It is replaced by \gateway.ex\, which implements the \Gust.DAG.Terminator\ behavior by delegating to \RunGateway\ for both task cancellation and run stopping. This change centralizes termination logic through a gateway interface, improving how run statuses are handled during graceful stops.

apps/gust/lib/gust/dag/terminator · high confidence

Refactored DAG runner architecture with gateway and stage builder

The DAG runner has been restructured to replace the monolithic StageWorker with a modular architecture. A new RunGateway (with a default implementation) now handles command routing and lease protection for distributed runs, while a StageBuilder manages task expansion and reconciliation. Task execution logic has been extracted into a dedicated TaskExecution module, and the DAGWorker has been updated to use a StageCoordinator for state management, supporting features like task cancellation, retry countdowns, and dynamic mapped task results.

apps/gust/lib/gust/dag/runner · high confidence

Refactored cron scheduler with dynamic job management and hot-reload support

The cron scheduling logic has been restructured to support dynamic job lifecycle management. A new JobLoader component now handles the creation, reloading, and deletion of scheduled jobs in response to DAG file changes, including automatic removal of jobs when their corresponding DAG files are deleted. The underlying scheduler module has been renamed and relocated to Gust.DAG.Run.Cron.Scheduler. Additionally, the system now supports hot-reloading of cron schedules during development via a configurable reload option, improving developer experience when modifying DAG definitions.

apps/gust/lib/gust/dag/run/cron · high confidence

Refreshed UI color palette and added keyboard focus indicators

The application's visual theme has been updated with a new color palette for both light and dark modes, shifting from the previous Phoenix/Elixir-inspired hues to a more cohesive scheme using specific OKLCH values for primary, secondary, and neutral colors. This change also introduces a consistent, high-contrast keyboard focus indicator (a 2px solid outline) for interactive elements like links, buttons, and inputs to improve accessibility. Additionally, the styling for task status indicators has been refined, introducing new CSS variables for status colors and adding support for a 'skipped' status, while updating existing statuses like 'running' and 'failed' to use the new palette colors.

_apps/gust\web/assets/css · high confidence

Task error reporting now supports external reference attachment

The error reporting system for DAG runs has been enhanced to handle external error references. A new GenServer worker processes error reports and, upon receiving a valid external reference from the configured reporter, attaches it to the corresponding task via the Flows service and broadcasts the update. This includes validation of the reference (ensuring it is a valid HTTP/HTTPS URL) and handles edge cases such as stale tasks or invalid reference formats by logging appropriate messages.

_apps/gust/lib/gust/dag/run/error\reporter · high confidence

Task skipping and wait conditions now propagate through the DAG

The stage coordinator has been refactored to support skipping tasks when upstream dependencies are skipped, and to handle wait conditions more explicitly. Previously, only upstream failures would stop downstream tasks; now, if any upstream task is skipped, dependent tasks are also skipped. Additionally, the coordinator now tracks waiting tasks separately and respects wait satisfaction timers, allowing tasks to pause execution until specific conditions are met. This change improves the reliability of DAG execution by ensuring that skipped or waiting states are correctly propagated through the dependency graph.

_apps/gust/lib/gust/dag/stage\coordinator · high confidence

Test coverage

13 commits adding/updating tests in apps/gust/test/dag/task\_worker/adapters; Added test coverage for assets, MCP, and well-known controllers; removed page controller test; Added test coverage for dashboard, system, and breadcrumb components; Added test coverage for the GustShell application; Added test helper with Mox mocks for GustPy; Added test infrastructure and fixtures for GustShell; Added test support utilities for environment management and mock actions; Added tests for API authentication plug; Added tests for API, dashboard, MCP, and Mermaid chart modules; Added tests for DAG adapter, folder, and task lifecycle components; Added tests for DAG run requeue and task reset logic; Added tests for DBLocker Postgres module; Added tests for MCP tools and server integration; Added tests for Task Messenger JSON handling; Added tests for claim repository run management; Added tests for core layout and DAG run UI components; Added tests for external reference validation; Added tests for the DAG Run Gateway default implementation; Added tests for the Elixir DAG parser adapter; Added tests for the Gust Web installation task; Added tests for the MCP server resource and tool modules; Added tests for the Python DAG parser adapter; Added tests for the Python executor's UV integration; Added tests for the Python runtime adapter; Added tests for the Task Worker adapter; Added tests for the cron job loader; Added tests for the refactored DAG runner architecture; Added tests for the renamed RetryingTask component; Added tests for the run claimer, pooler, and dispatcher supervisor; Expanded test coverage for Gust core components and DSL features; Reformat DAG validation tests; Removed tests for DAG Scheduler Worker; Removed tests for the DAG RunRestarter worker; Test support updates for connection and live component testing; Updated test mocks and configuration for new DAG and MCP components; Updated test suite to use new logging API; Updated tests for DAG parser adapter delegation; Updated tests for the DAG task runner supervisor.

Dependencies

Major dependency upgrades and new language adapter support

This release updates core Elixir dependencies to newer versions, including Ecto 3.14, Phoenix 1.8.14, Phoenix Live View 1.2, and Bandit 1.12.5, while also upgrading JavaScript libraries like Cytoscape and DOMPurify. It introduces two new optional language adapters—Gust Python (\gust\_py\) and Gust Shell (\gust\_shell\)—which can be enabled via environment variables to extend DAG support beyond Elixir. Additionally, the project adds \logger\_backends\ for enhanced logging, updates the GitHub repository link, and configures the release to include these new applications when their respective environment flags are set.

(dependencies) · high confidence

Written by cca.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 44 → 49 (+4.5)
  • Rubric changed (rubric-2026.10.5 → rubric-2026.11.4) — scores are not directly comparable.

Lenses

  • Code Health 99 → 99 (-0.3)
  • Architecture 93 → 93 (+0.5)
  • Maturity 66 → 66 (+0.7)
  • Readiness 41 → 55 (+13.9)
  • Security 41 → 40 (-1.6)
  • Accessibility 36 → 44 (+7.9)

Resolved (15)

  • High: security finding (details withheld)
  • High: security finding (details withheld)
  • High: security finding (details withheld)
  • High: security finding (details withheld)
  • High: security finding (details withheld)
  • High: security finding (details withheld)
  • High: security finding (details withheld)
  • High: security finding (details withheld)
  • High: security finding (details withheld)
  • High: security finding (details withheld)
  • High: security finding (details withheld)
  • Medium: security finding (details withheld)
  • No ADRs found
  • No dependency advisory monitoring
  • TooManyFunctions: Index (apps/gust_web/lib/gust_web/live/run_live/index.ex)

New (19)

  • Edited copy of a member (11 corresponding lines) (apps/gust/lib/gust/flows.ex)
  • Edited copy of a member (12 corresponding lines) (apps/gust/lib/gust/dag/runner/dag_worker.ex)
  • Edited copy of a member (3 corresponding lines) (apps/gust/lib/gust/dag/parser/adapters/elixir.ex)
  • Edited copy of a member (7 corresponding lines) (apps/gust_web/lib/gust_web/live/dag_summary_component.ex)
  • High: security finding (details withheld)
  • High: security finding (details withheld)
  • High: security finding (details withheld)
  • High: security finding (details withheld)
  • High: security finding (details withheld)
  • High: security finding (details withheld)
  • High: security finding (details withheld)
  • High: security finding (details withheld)
  • High: security finding (details withheld)
  • High: security finding (details withheld)
  • High: security finding (details withheld)
  • High: security finding (details withheld)
  • Medium CVE: EEF-[CVE redacted] (mix.lock)
  • Medium: security finding (details withheld)
  • No ADRs found (mix.exs)

Changes since last survey

  • 20 commits — 14 feature/other, 6 fixes

By area

  • apps/gust — 7 commits
  • (repo) — 6 commits
  • apps/gust_web — 3 commits
  • (root) — 2 commits
  • .github/workflows — 2 commits

Notable commits

  • fix: Merge pull request #174 from marciok/fix/GH-172-run-pub-from-other-dag
  • fix: Merge pull request #175 from marciok/fix/GH-feat-173-warning-on-paused-triggers
  • fix: Merge pull request #178 from marciok/fix/GH-177-limit-mapped-concurrency
  • fix: Merge pull request #179 from marciok/fix/gh-176-process-healthcheck
  • fix: fix: async testing
  • fix: fix: prefix for run pubsub; fixes #172
  • change: Merge branch 'main' of github.com:marciok/gust
  • change: Merge pull request #170 from marciok/v0.1.42-dev
  • change: chore: downgrade CI ubuntu
  • change: docs: contributions update
  • change: feat: DRY pagination logic
  • change: feat: changelog; solves #159
  • change: feat: health check for task and dag workers
  • change: feat: max parallel runs; fixes #177
  • change: feat: restart follows max concurrency rule
  • change: feat: show warning for triggered DAG; fixes #173
  • change: feat: validate release gh action
  • change: feat: warning for when max concurrency is not set
  • change: list: nested module
  • change: test: pagination test coverage

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

Survey your own repository

marciok/gust 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 15 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
  • Measured at commit a3beb6da2c1d91440bbb0f0544dab1d754871ba4 — the exact code this score is about.
  • Scored under rubric-2026.11.4 — the same rubric and the same method as every other entry in this index.
  • Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.65+preprod-3c33c1882dc1.