@compozy/cli 0.2.9 → 0.2.11

package/README.md

@@ -92,6 +92,7 @@ Execution runtimes are separate from skill installation. To run `compozy exec`,
 | Claude Agent       | `claude`       | `claude-agent-acp`               |
 | Codex CLI          | `codex`        | `codex-acp`                      |
 | GitHub Copilot CLI | `copilot`      | `copilot --acp`                  |
+| Devin CLI          | `devin`        | `devin acp`                      |
 | Cursor             | `cursor-agent` | `cursor-agent acp`               |
 | Droid              | `droid`        | `droid exec --output-format acp` |
 | OpenCode           | `opencode`     | `opencode acp`                   |
@@ -117,8 +118,8 @@ Task and review issue files use YAML frontmatter for parseable metadata such as
 
 - `compozy daemon start|status|stop` manages the home-scoped daemon lifecycle. `daemon start` is idempotent, and task/review/exec commands auto-start the daemon when needed.
 - `compozy workspaces list|show|register|unregister|resolve` exposes the daemon workspace registry. Workspaces are also lazily registered when you run daemon-backed commands inside them.
-- `compozy tasks run <slug>` is the canonical single-workflow runner. In interactive terminals it attaches to the TUI by default; in non-interactive environments it falls back to streaming. Use `--ui`, `--stream`, `--detach`, or `--attach` to override that behavior.
-- `compozy tasks run --multiple alpha,beta` starts one daemon-owned queue for several task workflows. Use `tasks run --multiple` when the same flags and runtime defaults should apply to an ordered batch; keep using `tasks run <slug>` for one workflow or scripts that expect one run ID per invocation.
+- `compozy tasks run <slug>` is the canonical single-workflow runner. In interactive terminals it attaches to the TUI by default; in non-interactive environments it falls back to streaming. Use `--ui`, `--stream`, `--detach`, or `--attach` to override that behavior. Add `--parallel-tasks` to opt into dependency-aware parallel execution for task files inside one workflow.
+- `compozy tasks run --multiple alpha,beta` starts one daemon-owned queue for several task workflows. Use `tasks run --multiple` when the same flags and runtime defaults should apply to an ordered batch; keep using `tasks run <slug>` for one workflow or scripts that expect one run ID per invocation. Add `--parallel` to run the batch concurrently — each child runs in its own isolated git worktree, bounded by `--parallel-limit` (default `2`).
 - Independent `compozy tasks run` invocations from different workspaces run concurrently on the shared home-scoped daemon. When another workspace already has an active run, the CLI prints a warning with the busy workspace and run ID before starting the new run.
 - `compozy runs attach <run-id>` restores the interactive TUI for an existing daemon-managed run, while `compozy runs watch <run-id>` streams textual observation from the same snapshot-plus-stream transport.
 - `compozy reviews fetch|list|show|fix` is the canonical review command family.
@@ -176,10 +177,29 @@ types = ["frontend", "backend", "docs", "test", "infra", "refactor", "chore", "b
 [tasks.run]
 include_completed = false
 run_multiple_mode = "enqueued"
+run_multiple_parallel_limit = 2
+
+[tasks.run.parallel]
+enabled = false
+max_concurrency = 4
+
+[tasks.run.parallel.conflict_resolver]
+ide = "codex"
+model = "gpt-5.5"
+reasoning_effort = "medium"
+max_attempts = 1
+validation_command = []
 
 [exec]
 output_format = "text"
 
+[recovery]
+enabled = false
+ide = "codex"
+model = "gpt-5.5"
+reasoning_effort = "medium"
+max_attempts = 1
+
 [fix_reviews]
 concurrent = 2
 batch_size = 3
@@ -195,9 +215,11 @@ Supported sections:
 - `[defaults]` for shared execution defaults such as `ide`, `model`, `reasoning_effort`, `access_mode`, `timeout`, `tail_lines`, `add_dirs`, `auto_commit`, `max_retries`, and `retry_backoff_multiplier`
 - `[exec]` for `output_format` plus exec-specific runtime overrides such as `ide`, `model`, `reasoning_effort`, `access_mode`, `timeout`, `tail_lines`, `add_dirs`, `max_retries`, and `retry_backoff_multiplier`
 - `[tasks]` for the allowed task `type` list used by `cy-create-tasks` and `compozy tasks validate`
-- `[tasks.run]` for workflow-run defaults used by `compozy tasks run`, such as `include_completed` and `run_multiple_mode`
+- `[tasks.run]` for workflow-run defaults used by `compozy tasks run`, such as `include_completed`, `run_multiple_mode`, and `run_multiple_parallel_limit`
+- `[tasks.run.parallel]` for dependency-aware parallel execution inside one PRD task workflow, including `enabled`, `max_concurrency`, and the conflict-resolver agent under `[tasks.run.parallel.conflict_resolver]`
 - `[fix_reviews]` for `concurrent`, `batch_size`, and `include_resolved`
 - `[fetch_reviews]` for `provider` and `nitpicks` (controls CodeRabbit review-body comments; default is enabled when unset)
+- `[recovery]` for agentic recovery defaults used by run-producing commands: `enabled`, `ide`, `model`, `reasoning_effort`, and `max_attempts`
 - `[sound]` for optional run-completion audio presets or absolute file paths
 
 Notes:
@@ -206,11 +228,17 @@ Notes:
 - `.compozy/tasks` remains the fixed workflow root in this version; the config file does not change the workflow root path.
 - Unknown keys and invalid value types are rejected during config loading.
 - Relative `add_dirs` are resolved against the owning config scope: the user home directory for `~/.compozy/config.toml` and the workspace root for `.compozy/config.toml`.
-- `[tasks.run] run_multiple_mode` controls `tasks run --multiple` scheduling. When unset, the built-in default is `"enqueued"`.
-- `run_multiple_mode = "parallel"` is accepted in V1 for forward-compatible config, but Compozy prints a V2 worktree-isolation fallback message and runs the queue in enqueued order. Real parallel multi-run execution waits for git worktree isolation.
+- `[tasks.run] run_multiple_mode` controls `tasks run --multiple` scheduling. Valid values are `"enqueued"` and `"parallel"`; when unset, the built-in default is `"enqueued"`.
+- `run_multiple_mode = "parallel"` runs the batch concurrently, with each child in its own isolated git worktree. The CLI `--parallel` flag overrides this config value for a single invocation.
+- `[tasks.run] run_multiple_parallel_limit` caps how many children run at once in parallel mode. It must be a positive integer and defaults to `2`. The CLI `--parallel-limit <n>` flag overrides it for a single invocation. The limit has no effect in enqueued mode, which always runs one child at a time.
+- `[tasks.run.parallel] enabled = true` runs pending task files in one workflow by dependency waves. The CLI `--parallel-tasks` flag overrides this config value for a single invocation.
+- `[tasks.run.parallel] max_concurrency` caps concurrent task worktrees within a wave and defaults to `4`. The conflict resolver uses `ide`, `model`, `reasoning_effort`, and `max_attempts` for bounded merge-conflict resolution.
+- `[tasks.run.parallel.conflict_resolver] validation_command` is optional and disabled by default. When set, it is an argv-style command such as `["go", "test", "./..."]`, runs without a shell after conflict markers and unmerged entries are gone, and must not modify the integration worktree. Omit it or set `[]` to rely only on universal git validation.
 - `max_retries` applies to execution-stage ACP failures and inactivity timeouts for `compozy exec`, `compozy tasks run`, and `compozy reviews fix`.
 - Built-in CLI defaults retry timed-out or transient ACP failures twice; set `max_retries = 0` or pass `--max-retries 0` to opt out.
 - `retry_backoff_multiplier` only increases the next attempt timeout; retries restart immediately and do not add a sleep delay.
+- Recovery is disabled by default. When enabled, `max_attempts` is the number of remediation plus restart cycles and must be between `1` and `3`.
+- Recovery config is resolved fresh for each invocation and is not persisted into run or exec metadata. Use `--recovery`, `--no-recovery`, `--recovery-ide`, `--recovery-model`, `--recovery-reasoning`, and `--recovery-max-attempts` to override `[recovery]` for one command.
 
 ## Reusable Agents
 
@@ -399,12 +427,14 @@ Generated task files use task schema v2 (`status`, `title`, `type`, `complexity`
 
 ```bash
 compozy tasks run user-auth --ide claude
+compozy tasks run user-auth --parallel-tasks
 compozy tasks run --multiple user-auth,cleanup --ide claude
+compozy tasks run --multiple user-auth,cleanup --parallel --parallel-limit 2
 ```
 
 Each pending task is processed sequentially through the shared daemon — the agent reads the spec, implements the code, validates it, and updates the task status. Use `--dry-run` to preview prompts without executing.
 `compozy tasks run` validates task metadata before execution. Use `--skip-validation` when validation already ran elsewhere, or `--force` to continue after validation failures in non-interactive environments.
-Use `compozy tasks run --multiple <slug-a>,<slug-b>` when you want one command to enqueue several workflows with the same runtime flags. The input is one comma-separated slug list; `compozy tasks run <slug>` remains the single-workflow command.
+Use `compozy tasks run --multiple <slug-a>,<slug-b>` when you want one command to enqueue several workflows with the same runtime flags. The input is one comma-separated slug list; `compozy tasks run <slug>` remains the single-workflow command. Add `--parallel` to run independent workflows concurrently in isolated git worktrees instead of one at a time.
 
 ### 7. Review
 
@@ -497,13 +527,14 @@ The `cy-workflow-memory` skill handles all of this automatically when referenced
 | Claude Code    | `claude`       |
 | Codex          | `codex`        |
 | GitHub Copilot | `copilot`      |
+| Devin CLI      | `devin`        |
 | Cursor         | `cursor-agent` |
 | Droid          | `droid`        |
 | OpenCode       | `opencode`     |
 | Pi             | `pi`           |
 | Gemini         | `gemini`       |
 
-**Skill installation** (`compozy setup`) — 40+ agents and editors, including Claude Code, Codex, Cursor, Droid, OpenCode, Pi, Gemini CLI, GitHub Copilot, Windsurf, Amp, Continue, Goose, Roo Code, Augment, Kiro CLI, Cline, and many more. `compozy setup` installs core workflow skills plus any setup assets shipped by enabled extensions. Run `compozy setup` to see all detected agents on your system.
+**Skill installation** (`compozy setup`) — 40+ agents and editors, including Claude Code, Codex, Cursor, Devin CLI, Droid, OpenCode, Pi, Gemini CLI, GitHub Copilot, Windsurf, Amp, Continue, Goose, Roo Code, Augment, Kiro CLI, Cline, and many more. `compozy setup` installs core workflow skills plus any setup assets shipped by enabled extensions. Run `compozy setup` to see all detected agents on your system.
 
 When installing to multiple agents, Compozy offers two modes:
 
@@ -611,24 +642,39 @@ compozy tasks run <slug> [flags]
 
 The CLI resolves workspace defaults locally, validates the task metadata, auto-starts the daemon when needed, and then starts the workflow through the daemon transport.
 
-| Flag                  | Default | Description                                                                         |
-| --------------------- | ------- | ----------------------------------------------------------------------------------- |
-| `--name`              |         | Workflow slug (defaults to the positional slug)                                     |
-| `--multiple`          |         | Comma-separated workflow slugs to run through one daemon-owned parent queue         |
-| `--include-completed` | `false` | Re-run completed tasks                                                              |
-| `--recursive`, `-r`   | `false` | Discover `task_NNN.md` files in nested subdirectories of the workflow root          |
-| `--skip-validation`   | `false` | Skip task metadata preflight; use only when validation already ran elsewhere        |
-| `--force`             | `false` | Continue after task metadata validation fails in non-interactive mode               |
-| `--attach`            | `auto`  | Attach mode: `auto`, `ui`, `stream`, or `detach`                                    |
-| `--ui`                | `false` | Force interactive TUI attach mode                                                   |
-| `--stream`            | `false` | Force textual stream attach mode                                                    |
-| `--detach`            | `false` | Start the run without attaching a client                                            |
-| `--task-runtime`      |         | Per-task runtime override rule (`type=...`, `id=...`, `ide=...`, `model=...`, etc.) |
+| Flag                      | Default   | Description                                                                                      |
+| ------------------------- | --------- | ------------------------------------------------------------------------------------------------ |
+| `--name`                  |           | Workflow slug (defaults to the positional slug)                                                  |
+| `--multiple`              |           | Comma-separated workflow slugs to run through one daemon-owned parent queue                      |
+| `--parallel`              | `false`   | Run `--multiple` workflows concurrently in isolated git worktrees (valid only with `--multiple`) |
+| `--parallel-limit`        | `2`       | Max children started at once in `--parallel` mode; must be `> 0` (valid only with `--multiple`)  |
+| `--parallel-tasks`        | `false`   | Run task files inside one PRD workflow in dependency-aware parallel mode                         |
+| `--include-completed`     | `false`   | Re-run completed tasks                                                                           |
+| `--recursive`, `-r`       | `false`   | Discover `task_NNN.md` files in nested subdirectories of the workflow root                       |
+| `--skip-validation`       | `false`   | Skip task metadata preflight; use only when validation already ran elsewhere                     |
+| `--force`                 | `false`   | Continue after task metadata validation fails in non-interactive mode                            |
+| `--attach`                | `auto`    | Attach mode: `auto`, `ui`, `stream`, or `detach`                                                 |
+| `--ui`                    | `false`   | Force interactive TUI attach mode                                                                |
+| `--stream`                | `false`   | Force textual stream attach mode                                                                 |
+| `--detach`                | `false`   | Start the run without attaching a client                                                         |
+| `--task-runtime`          |           | Per-task runtime override rule (`type=...`, `id=...`, `ide=...`, `model=...`, etc.)              |
+| `--recovery`              | `false`   | Enable agentic recovery for failed runs                                                          |
+| `--no-recovery`           | `false`   | Disable agentic recovery for this invocation                                                     |
+| `--recovery-ide`          | `codex`   | Runtime used by the recovery agent                                                               |
+| `--recovery-model`        | `gpt-5.5` | Model used by the recovery agent                                                                 |
+| `--recovery-reasoning`    | `medium`  | Recovery agent reasoning effort: `low`, `medium`, `high`, or `xhigh`                             |
+| `--recovery-max-attempts` | `1`       | Recovery remediation plus restart cycles; must be between `1` and `3`                            |
 
 When `--recursive` is set, tasks are grouped by directory (root tasks first, then each subdirectory in alphabetical order, numerically within), and `_`/`.`-prefixed directories, `reviews-*` rounds, `adrs/`, and `memory/` are skipped. The same setting can be persisted as `[tasks.run] recursive = true` in workspace TOML or chosen from the interactive task-runtime form.
 
 Use `tasks run --multiple` when you want to start several task workflows from one invocation with the same runtime flags. Use `tasks run <slug>` when you only need one workflow run, when a script expects a single workflow slug, or when you want the existing single-run command path.
 
+For one workflow, `--parallel-tasks` executes pending task files in dependency waves using isolated worktrees, bounded by `[tasks.run.parallel] max_concurrency`:
+
+```bash
+compozy tasks run my-feature --parallel-tasks
+```
+
 The `--multiple` flag takes one comma-separated slug list:
 
 ```bash
@@ -637,20 +683,49 @@ compozy tasks run --multiple alpha,beta --stream
 compozy tasks run --multiple alpha,beta --detach
 ```
 
-Scheduling is controlled by `.compozy/config.toml` or `~/.compozy/config.toml`:
+Scheduling is controlled by the `--parallel`/`--parallel-limit` flags or by `.compozy/config.toml` / `~/.compozy/config.toml`:
 
 ```toml
 [tasks.run]
-run_multiple_mode = "enqueued"
+run_multiple_mode = "enqueued"        # "enqueued" (default) or "parallel"
+run_multiple_parallel_limit = 2       # max concurrent children in parallel mode
+```
+
+`"enqueued"` (the default) runs one child workflow at a time in the requested order. `"parallel"` runs independent children concurrently, each in its own isolated git worktree, bounded by the parallel limit:
+
+```bash
+compozy tasks run --multiple alpha,beta --parallel
+compozy tasks run --multiple alpha,beta --parallel --parallel-limit 3
+```
+
+Resolution precedence:
+
+- Mode: `--parallel` flag > `run_multiple_mode` config > `enqueued` default.
+- Limit: `--parallel-limit <n>` flag > `run_multiple_parallel_limit` config > `2` default.
+
+`--parallel` and `--parallel-limit` are valid only with `--multiple`, and the limit must be a positive integer; invalid combinations are rejected before the daemon is contacted.
+
+**Worktree isolation.** In parallel mode the parent workspace must be on a named git branch. Compozy resolves the current branch and `HEAD` once, then creates one detached git worktree per child under `~/.compozy/state/worktrees/`. Each child runs with its workspace root and task directory remapped into that worktree, so concurrent agents get isolated working trees, indexes, and `HEAD`s while sharing the repository object store. Worktrees do **not** isolate shared runtime resources such as ports, credentials, provider rate limits, caches, or external services — treat parallel batches as genuinely independent tasks.
+
+**Preservation and V1 non-goals.** Every child worktree is preserved for manual review while the run settles, regardless of child status. Compozy does not auto-merge, auto-push, or branch those results, and it does not predict semantic conflicts; recombining results is a manual step. Each detached worktree records its base branch and commit so you can branch or merge from it yourself. Preserved worktrees are reclaimed only by explicit retention cleanup through `compozy runs purge`; dirty task worktrees make purge fail before run metadata is deleted.
+
+**Fail-late aggregation.** A child failure does not cancel its siblings. The parent reaches a terminal status only after every started child settles: `completed` when all children complete, or `failed` when any child fails, crashes, or cannot start (the parent error names the failed slugs). Canceling the parent cancels running children and marks not-started children canceled. In non-TUI runs the parent command exits non-zero when the aggregate status is failed, canceled, or crashed.
+
+**Handoff output.** After the queue settles, `--stream` runs (and the UI-settled fallback) print a final handoff that lists each child in requested order so every preserved worktree is locatable:
+
+```text
+task multi-run handoff:
+  alpha completed | run=child-alpha | worktree=~/.compozy/state/worktrees/<ws>/<parent>/01-alpha | branch=main
+  beta failed | run=child-beta | worktree=~/.compozy/state/worktrees/<ws>/<parent>/02-beta | boom
 ```
 
-`"enqueued"` is the default and runs one child workflow at a time in the requested order. `"parallel"` is also accepted in V1, but Compozy prints a fallback message and still runs the queue as `"enqueued"` until V2 adds git worktree-backed isolation for concurrent agents.
+Missing run ids or worktree paths render as `-`. Streamed child events also carry `worktree=<path>`, and the TUI shows a worktree status line for the selected child.
 
 Cross-workspace runs are different from `--multiple` scheduling: the home-scoped daemon accepts separate `compozy tasks run` invocations from different workspaces concurrently and does not queue or reject the second run. Before starting a non-dry-run task workflow, the CLI checks daemon status; if active runs belong to another registered workspace, it warns with the busy workspace name/path and run ID, then proceeds. The warning is skipped when the daemon is idle, when the active run belongs to the same workspace, or when `--dry-run` is set.
 
 In the TUI, every requested slug has a tab. Queued tabs appear before their child run exists, the running tab shows the familiar task-run surface, and completed, failed, or canceled tabs remain available for inspection. The quit dialog applies to the parent queue: `Close TUI` detaches and leaves the queue running in the daemon, `Stop Run` cancels the parent queue, cancels the active child, and marks queued workflows canceled, and `Cancel` returns to the TUI without changing execution.
 
-The multi-run path uses the same attach and runtime flags as single-run `tasks run`, except `--multiple` cannot be combined with a positional slug or `--name`.
+The multi-run path uses the same attach and runtime flags as single-run `tasks run`, except `--multiple` cannot be combined with a positional slug, `--name`, or `--parallel-tasks`.
 
 </details>
 
@@ -677,7 +752,7 @@ compozy runs watch <run-id>
 compozy runs purge
 ```
 
-Use `runs attach` to restore the interactive TUI for an existing run, `runs watch` for textual streaming observation, and `runs purge` to delete terminal run artifacts according to the configured retention policy.
+Use `runs attach` to restore the interactive TUI for an existing run, `runs watch` for textual streaming observation, and `runs purge` to delete terminal run artifacts according to the configured retention policy. Purge also removes clean Compozy-owned preserved worktrees recorded by terminal run events under `~/.compozy/state/worktrees/`; it ignores paths outside that root and stops before deleting run metadata if a task worktree is dirty.
 
 </details>
 
@@ -717,6 +792,12 @@ Provide exactly one prompt source: a positional prompt, `--prompt-file`, or `std
 | `--reasoning-effort`         | `medium`    | `low`, `medium`, `high`, `xhigh`                                                           |
 | `--access-mode`              | `full`      | `default` or `full` runtime access policy                                                  |
 | `--timeout`                  | `10m`       | Activity timeout per job                                                                   |
+| `--recovery`                 | `false`     | Enable agentic recovery for failed exec runs                                               |
+| `--no-recovery`              | `false`     | Disable agentic recovery for this invocation                                               |
+| `--recovery-ide`             | `codex`     | Runtime used by the recovery agent                                                         |
+| `--recovery-model`           | `gpt-5.5`   | Model used by the recovery agent                                                           |
+| `--recovery-reasoning`       | `medium`    | Recovery agent reasoning effort: `low`, `medium`, `high`, or `xhigh`                       |
+| `--recovery-max-attempts`    | `1`         | Recovery remediation plus restart cycles; must be between `1` and `3`                      |
 | `--max-retries`              | `2`         | Retry execution-stage ACP failures or timeouts N times                                     |
 | `--retry-backoff-multiplier` | `1.5`       | Multiplier applied to the next timeout after each retry                                    |
 | `--tail-lines`               | `0`         | Maximum log lines retained per job in UI (`0` = full history)                              |

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@compozy/cli",
   "type": "module",
-  "version": "0.2.9",
+  "version": "0.2.11",
   "description": "Compozy CLI",
   "scripts": {
     "postinstall": "node install.js",
@@ -27,63 +27,63 @@
   },
   "archives": {
     "darwin-arm64": {
-      "name": "compozy_0.2.9_darwin_arm64.tar.gz",
-      "url": "https://github.com/compozy/compozy/releases/download/v0.2.9/compozy_0.2.9_darwin_arm64.tar.gz",
+      "name": "compozy_0.2.11_darwin_arm64.tar.gz",
+      "url": "https://github.com/compozy/compozy/releases/download/v0.2.11/compozy_0.2.11_darwin_arm64.tar.gz",
       "bins": [
         "compozy"
       ],
       "format": "tar.gz",
       "checksum": {
         "algorithm": "sha256",
-        "digest": "5d31ce148773d839c60591b638dc4e2df964e31bff343105f1d117d91f70b62e"
+        "digest": "085f7c59bdcdaf95688ba12eb8df49df59fb243bcd550771e76f810ae70a3f59"
       }
     },
     "darwin-x64": {
-      "name": "compozy_0.2.9_darwin_x86_64.tar.gz",
-      "url": "https://github.com/compozy/compozy/releases/download/v0.2.9/compozy_0.2.9_darwin_x86_64.tar.gz",
+      "name": "compozy_0.2.11_darwin_x86_64.tar.gz",
+      "url": "https://github.com/compozy/compozy/releases/download/v0.2.11/compozy_0.2.11_darwin_x86_64.tar.gz",
       "bins": [
         "compozy"
       ],
       "format": "tar.gz",
       "checksum": {
         "algorithm": "sha256",
-        "digest": "6ac75231066a63d7dcc17909581ab15fc8c8c2d86a46f7c9241f59c6e368ecdf"
+        "digest": "f6f28f751b83929e7c33baafc8ee61cab007b9d574848e6cc9cb8481f266b32a"
       }
     },
     "linux-arm64": {
-      "name": "compozy_0.2.9_linux_arm64.tar.gz",
-      "url": "https://github.com/compozy/compozy/releases/download/v0.2.9/compozy_0.2.9_linux_arm64.tar.gz",
+      "name": "compozy_0.2.11_linux_arm64.tar.gz",
+      "url": "https://github.com/compozy/compozy/releases/download/v0.2.11/compozy_0.2.11_linux_arm64.tar.gz",
       "bins": [
         "compozy"
       ],
       "format": "tar.gz",
       "checksum": {
         "algorithm": "sha256",
-        "digest": "ab25dce444fd9f546072551a1c5cf8c33c6f1c998d4f5f5fbfbc8f3e1317b8b6"
+        "digest": "a6f22fe7da79e791eb5c5cc370afa0135c316fec52e66cfa87e75e1d24ef809b"
       }
     },
     "linux-x64": {
-      "name": "compozy_0.2.9_linux_x86_64.tar.gz",
-      "url": "https://github.com/compozy/compozy/releases/download/v0.2.9/compozy_0.2.9_linux_x86_64.tar.gz",
+      "name": "compozy_0.2.11_linux_x86_64.tar.gz",
+      "url": "https://github.com/compozy/compozy/releases/download/v0.2.11/compozy_0.2.11_linux_x86_64.tar.gz",
       "bins": [
         "compozy"
       ],
       "format": "tar.gz",
       "checksum": {
         "algorithm": "sha256",
-        "digest": "b0f254cdc786da264e87965584ca587aa023299d37487a34bcaa061a37d91039"
+        "digest": "c87cd7055f75b258557466cbb87a019850b567bb247dbefe334b8e5dc683cf1d"
       }
     },
     "win32-x64": {
-      "name": "compozy_0.2.9_windows_x86_64.zip",
-      "url": "https://github.com/compozy/compozy/releases/download/v0.2.9/compozy_0.2.9_windows_x86_64.zip",
+      "name": "compozy_0.2.11_windows_x86_64.zip",
+      "url": "https://github.com/compozy/compozy/releases/download/v0.2.11/compozy_0.2.11_windows_x86_64.zip",
       "bins": [
         "compozy.exe"
       ],
       "format": "zip",
       "checksum": {
         "algorithm": "sha256",
-        "digest": "053180f60010cc5f4ac3f518860134ff786b3be9fc9bb67b1aee5044f5dc0ddd"
+        "digest": "bfdf1fcc2b6b0445a65b916cc8130240a136b153d77ce6b881d872d00637504a"
       }
     }
   }