Terminal
Terminal/Skill
Audits existing Kestra flows for missing retries, timeouts, concurrency limits, error handlers and idempotency guards, then applies the fixes you confirm.
By Kestra
Works with
npx skills add kestra-io/agent-skills --skill kestra-flow-hardeningAudit existing Kestra flows, surface resilience / idempotency / guardrail gaps as a severity-ranked report, then apply the edits the user confirms.
This is the auditing counterpart to the sibling skills:
| Skill | Owns |
|---|---|
kestra-flow | Authoring — create / modify / debug flow YAML from intent |
kestra-flow-hardening | Auditing — find gaps, recommend + apply guardrails |
kestra-ops | Operating — validate / deploy / run via kestractl |
Hand off to kestra-flow for "build a new flow" and to kestra-ops for "validate / deploy this".
Trigger on requests to harden, audit, review, or make production-ready / resilient / idempotent:
Do not use this skill to author a brand-new flow from a description — that is kestra-flow.
./flows/, ./flows/*.yml)kestra-ops / kestractl (the user pairs the skills; this skill does not require a running instance)curl -s https://api.kestra.io/v1/plugins/schemas/flow
Read the raw JSON. The schema is the source of truth for which properties and types
exist in the target version. Never recommend a property absent from the schema — this is
what catches version traps such as retry.maxAttempt (pre-0.24) vs retry.maxAttempts.
Hardening must be proportional to what the flow does and where it runs. Read these signals and tailor the audit — do not apply a fixed checklist to every flow:
prod.* / staging.* raises the bar; dev.* / sandbox.* / tutorial.* gets a lighter touch ("this looks like dev — hardening deferred unless you're promoting it").Never invent risk. If a flow is genuinely sound, returning "No critical or high findings; this flow is reasonably hardened" is a correct, encouraged outcome. Do not manufacture Low-severity nits to look busy.
Evaluate each relevant dimension. For exact, copy-pasteable YAML per construct and the
"when to apply / when NOT to" guidance, load
references/hardening-patterns.md.
Resilience
retry where whole-execution replay makes sense.Failure handling
errors (global) for alerting; local errors inside flowable tasks for targeted cleanup.finally for resource teardown (containers, temp infra) — runs while execution is still RUNNING.afterExecution for final-state-based notifications (SUCCESS / FAILED / WARNING) via runIf.allowFailure / allowWarning on genuinely non-critical tasks only.Concurrency & idempotency
concurrency limit + behavior (QUEUE / CANCEL / FAIL) for flows hitting shared / rate-limited systems.system.correlationId + duplicate check (EE) or KV-based state guard (OSS).allowConcurrent / Schedule overlap behavior.Guardrails & contracts
checks (≥ 1.2) for pre-execution input validation.sla — MAX_DURATION / EXECUTION_ASSERTION with breach labels + alerting.SELECT / ENUM / SECRET instead of loose STRING.Hygiene
store: true / stores for large outputs instead of carrying data in the execution context.kestra-flow's rule — see Shared rules below).Platform-fit & maintainability (advisory — not hardening, never a blocker) These are recommendations, not risks. They never carry a severity and never block; they surface in a separate Advisory section (see report format). Use them to nudge users toward better-maintained flows, not to gate anything.
Script task with a large inline script: /
commands: block (roughly > 15–20 lines, or containing real program logic) is harder to
read, test, and version. Recommend moving the code into a Namespace File and calling it
from a Commands task (namespaceFiles: {enabled: true, include: [...]}), or reading it via
read('path') in a Script task. Kestra's own guidance: Commands for production
workloads, Script for quick iteration.curl / wget / requests → io.kestra.plugin.core.http.Request / Downloadpsql / mysql / sqlite3 → the matching JDBC plugin (io.kestra.plugin.jdbc.*)aws / gcloud / az CLI → the cloud plugins (io.kestra.plugin.aws|gcp|azure.*)dbt → io.kestra.plugin.dbt.*; git clone → io.kestra.plugin.git.Clone| Severity | Definition | Example |
|---|---|---|
| Critical | Will cause data corruption, duplicate side-effects, or silent loss in production | Retry / allowFailure on a non-idempotent write; no concurrency limit on non-atomic state updates; hardcoded secret |
| High | Will cause outages / hangs / cost-blowouts or undetected failures | No timeout on a cloud / script task; no errors alerting; no SLA on a business-critical schedule |
| Medium | Degraded resilience / recoverability | Missing transient retries on HTTP / JDBC; no finally teardown leaking resources; loose input typing |
| Low | Hygiene / maintainability | Missing descriptions / labels; naming; large-output store unset |
Platform-fit recommendations (long scripts → Namespace Files; scripts → native plugins) are not assigned a severity. They are reported separately as Advisory and never block.
A retry is good advice for a flaky read and catastrophic for a non-idempotent write (double-charge, duplicate insert). Classify every candidate task before recommending:
| Tier | How detected | Retry recommendation |
|---|---|---|
| Safe | Read-only by type (HTTP GET, SELECT, fetch / list, Log) | Recommend retries freely |
| Conditionally safe | Write with a natural idempotency key, or transactional / upsert task | Recommend retries with the precondition stated |
| Unsafe / unknown | Opaque scripts, POST / PUT to unknown endpoints, non-transactional writes | Do NOT recommend a blind retry. Flag the idempotency question in the report with both branches: dedup guard (correlationId / KV) vs. retry-if-safe. Let the user decide at confirm-time. |
Format (findings numbered globally so the user can select by number):
## Hardening audit: <flow id> (<namespace>, v<X.Y>, OSS/EE)
### Critical
1. **<title>** — `tasks.<id>`
Risk: <what breaks in production if unfixed>
Caveat: <e.g. only safe if this endpoint dedupes on a key>
Proposed: <the edit, or both branches for unknown-safety tasks>
### High
2. ...
### Medium
### Low
### Advisory (platform-fit) — not hardening, optional
- **Long inline script** — `tasks.transform`
Move the ~40-line script into a Namespace File and call it from a `Commands` task
(versioned, testable, editable in the Code Editor).
- **Script duplicates a plugin** — `tasks.fetch`
This `curl` shell task can be `io.kestra.plugin.core.http.Request` (verified in schema).
---
Summary: N Critical · N High · N Medium · N Low · N Advisory
Reply with the numbers to apply (e.g. `1,4,7`), `all`, or `none`.
On apply 1,4,7 / all:
id / namespace, task ordering, and comments. Never restructure unrelated parts.kestractl flow validate (via kestra-ops) as an optional final gate; do not require a live instance.kestra-flow)Do not restate — reuse the kestra-flow skill's rules so they don't drift:
inputs of type SECRET or {{ secret('...') }}.id / namespace../flows/ingest.yml and add retries and timeouts where safe."./flows/ for resilience gaps and rank them worst-first."