bmad-module-ultracode-goal 2.0.0 → 2.2.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/.claude-plugin/marketplace.json +1 -1
- package/README.md +5 -5
- package/docs/404.md +1 -1
- package/docs/_internal/STABILITY.md +13 -9
- package/docs/architecture.md +17 -12
- package/docs/comparison.md +19 -11
- package/docs/gate-model.md +24 -0
- package/docs/getting-started.md +1 -1
- package/docs/how-it-works.md +3 -3
- package/docs/index.md +0 -1
- package/docs/operating-tips.md +4 -2
- package/docs/troubleshooting.md +9 -5
- package/docs/why-ultracode-goal.md +1 -1
- package/package.json +5 -4
- package/skills/ucg-formalize/SKILL.md +136 -39
- package/skills/ucg-resolve/SKILL.md +86 -58
- package/skills/ucg-status/SKILL.md +64 -30
- package/skills/ultracode-goal/SKILL.md +9 -11
- package/skills/ultracode-goal/assets/module-help.csv +1 -1
- package/skills/ultracode-goal/assets/module.yaml +8 -3
- package/skills/ultracode-goal/assets/ucg-awareness/bmad-testarch-test-design.toml +8 -0
- package/skills/ultracode-goal/customize.toml +12 -7
- package/skills/ultracode-goal/references/define-done.md +3 -3
- package/skills/ultracode-goal/references/execute.md +40 -53
- package/skills/ultracode-goal/references/finalize.md +12 -12
- package/skills/ultracode-goal/references/gate.md +42 -11
- package/skills/ultracode-goal/references/health-check.md +7 -4
- package/skills/ultracode-goal/references/ingest-and-scope.md +4 -4
- package/skills/ultracode-goal/references/preflight.md +10 -9
- package/skills/ultracode-goal/scripts/gate_eval.py +684 -39
- package/skills/ultracode-goal/scripts/gate_trail.py +131 -32
- package/skills/ultracode-goal/scripts/health_check_fp.py +98 -3
- package/skills/ultracode-goal/scripts/hooks/guard_pretooluse.py +56 -14
- package/skills/ultracode-goal/scripts/mem_observation.py +48 -10
- package/skills/ultracode-goal/scripts/mutate_check.py +353 -0
- package/skills/ultracode-goal/scripts/preflight_check.py +397 -3
- package/skills/ultracode-goal/scripts/status_render.py +20 -2
- package/skills/ultracode-goal/scripts/story_sizing.py +193 -0
- package/tools/build-docs.js +24 -1
- package/tools/validate-docs-links.js +169 -8
- package/website/astro.config.mjs +0 -1
- package/docs/parallel-mode.md +0 -68
- package/skills/ultracode-goal/assets/execute-epic.workflow.js +0 -249
|
@@ -19,7 +19,7 @@
|
|
|
19
19
|
"name": "bmad-module-ultracode-goal",
|
|
20
20
|
"source": "./",
|
|
21
21
|
"description": "Supercharges BMAD with Claude Code Goal Mode, Auto Mode, and Auto Memory: autonomous Epic execution to a machine-checked, TEA-gated Definition-of-Done. Execute Epics. Accumulate Knowledge. Deliver Outcomes.",
|
|
22
|
-
"version": "2.
|
|
22
|
+
"version": "2.2.0",
|
|
23
23
|
"author": {
|
|
24
24
|
"name": "Armel"
|
|
25
25
|
},
|
package/README.md
CHANGED
|
@@ -50,6 +50,7 @@ That verdict is a small, real JSON object; here is the actual output of `gate_ev
|
|
|
50
50
|
"overall_status": "88%",
|
|
51
51
|
"nfr_status": null,
|
|
52
52
|
"review_score": null,
|
|
53
|
+
"epic_level": false,
|
|
53
54
|
"reasons": [
|
|
54
55
|
"gate read from gate-decision.json",
|
|
55
56
|
"gate_status PASS -> advance"
|
|
@@ -76,7 +77,7 @@ You'll be prompted for a project name and whether to install the learning materi
|
|
|
76
77
|
Invoke the skill in natural language: "run this epic autonomously," "execute this epic," or `ultracode goal`. The conductor ingests the epic, preflights, defines done with TEA, executes, gates, and finalizes. Flags shape the run:
|
|
77
78
|
|
|
78
79
|
- `--light`: run the **trace gate only** (the production default runs the full TEA gate set).
|
|
79
|
-
- `--parallel`:
|
|
80
|
+
- `--parallel`: retired. Still accepted so an old invocation does not error: the run logs one note that the flag was accepted and ignored, then executes the sequential `/goal` spine.
|
|
80
81
|
- `--yes`: skip Stage 1's open-floor invite and the launch confirm. It **never** skips the hard preflight gate.
|
|
81
82
|
- `-H`: headless: run non-interactively and emit the five-key status JSON at every exit point.
|
|
82
83
|
- `--retro`: run the close-out retrospective (interactive runs offer it anyway; headless runs it only when this flag is passed).
|
|
@@ -104,10 +105,10 @@ UCG's closest peer is [bmad-loop](https://github.com/bmad-code-org/bmad-loop) (f
|
|
|
104
105
|
|
|
105
106
|
You don't have to take the gate's word for it. The deterministic pieces ship with a test suite, and you can run the evaluator on a real artifact yourself.
|
|
106
107
|
|
|
107
|
-
Run the Python suite (
|
|
108
|
+
Run the Python suite (1,700+ tests across the preflight, gate, hook, readiness, memory, mutation-runner, and customization scripts):
|
|
108
109
|
|
|
109
110
|
```bash
|
|
110
|
-
uv run --with pytest pytest skills/ultracode-goal/scripts/tests/ -
|
|
111
|
+
uv run --with pytest==9.1.1 --with pytest-xdist==3.8.0 pytest skills/ultracode-goal/scripts/tests/ -n auto
|
|
111
112
|
```
|
|
112
113
|
|
|
113
114
|
Then inspect any `gate-decision.json` TEA wrote and evaluate it directly:
|
|
@@ -130,7 +131,6 @@ The docs are organized into three buckets: **Why** (start here), **Try** (do stu
|
|
|
130
131
|
|
|
131
132
|
- **[Getting Started](./docs/getting-started.md)**: install, prerequisites, the flags, and your first autonomous run.
|
|
132
133
|
- **[How It Works](./docs/how-it-works.md)**: the six stages, their routing conditions, and the headless five-key emit.
|
|
133
|
-
- **[Parallel Mode](./docs/parallel-mode.md)**: the experimental worktree fan-out and its known limits.
|
|
134
134
|
|
|
135
135
|
**Reference**
|
|
136
136
|
|
|
@@ -153,7 +153,7 @@ UCG is a conductor over primitives it does not replace. It builds on:
|
|
|
153
153
|
| ---------------------------------------------------------------------- | ------------------------------------------------------------------------------ |
|
|
154
154
|
| [BMAD Method](https://github.com/bmad-code-org/BMAD-METHOD) | The epic toolbox UCG orchestrates (sprint planning, story creation, dev, review) |
|
|
155
155
|
| [TEA Test Architect](https://github.com/bmad-code-org/bmad-method-test-architecture-enterprise) | Machine-checked quality gates: test-design, ATDD, NFR, trace; the gate artifact |
|
|
156
|
-
| [Claude Code](https://claude.com/product/claude-code) | `/goal`, Auto Mode, Auto Memory, hooks, and git
|
|
156
|
+
| [Claude Code](https://claude.com/product/claude-code) | `/goal`, Auto Mode, Auto Memory, hooks, and git branches, the primitives UCG composes |
|
|
157
157
|
|
|
158
158
|
## Contributing
|
|
159
159
|
|
package/docs/404.md
CHANGED
|
@@ -12,7 +12,7 @@ Use the **search bar** at the top of the page, or jump to one of these pages tha
|
|
|
12
12
|
|
|
13
13
|
**Why**: [Why UltraCode Goal](./why-ultracode-goal.md)
|
|
14
14
|
|
|
15
|
-
**Try**: [Getting Started](./getting-started.md) · [How It Works](./how-it-works.md) · [
|
|
15
|
+
**Try**: [Getting Started](./getting-started.md) · [How It Works](./how-it-works.md) · [Architecture](./architecture.md)
|
|
16
16
|
|
|
17
17
|
**Reference**: [Architecture](./architecture.md) · [Gate Model](./gate-model.md) · [Health Check](./health-check.md) · [Troubleshooting](./troubleshooting.md)
|
|
18
18
|
|
|
@@ -1,11 +1,11 @@
|
|
|
1
1
|
---
|
|
2
2
|
title: Stability and Public Contract
|
|
3
|
-
description: "The
|
|
3
|
+
description: "The 2.x stability posture: which CLI, config, JSON, and gate surfaces are the supported public contract, what a major costs, and everything that is @internal and free to change."
|
|
4
4
|
---
|
|
5
5
|
|
|
6
|
-
> **Status:**
|
|
6
|
+
> **Status:** 2.x. The surfaces below are the public contract. Per [Semantic Versioning 2.0.0](https://semver.org/), a breaking change to any of them requires a MAJOR bump; everything marked `@internal` may change in any release. This document is what a consumer pins against.
|
|
7
7
|
|
|
8
|
-
This is the stability posture for `bmad-module-ultracode-goal` at `
|
|
8
|
+
This is the stability posture for `bmad-module-ultracode-goal` at `2.x`. It enumerates the surfaces a downstream consumer or automator may reasonably depend on, versus everything else, which is `@internal`.
|
|
9
9
|
|
|
10
10
|
## Public contract
|
|
11
11
|
|
|
@@ -20,10 +20,12 @@ The installer CLI is invoked via `npx bmad-module-ultracode-goal <subcommand>`.
|
|
|
20
20
|
|
|
21
21
|
### The `[workflow]` customize.toml keys
|
|
22
22
|
|
|
23
|
-
The keys in the shipped `[workflow]` block of `customize.toml` (including `persistent_facts`, `tea_config_path`, `trace_output_dir`, `implementation_artifacts`, `deferred_work_path`, `epic_branch_prefix`, `protected_branches`, `max_turns_per_story`, `story_token_budget` (**deprecated, no-op**), `parallel_max_concurrency
|
|
23
|
+
The keys in the shipped `[workflow]` block of `customize.toml` (including `persistent_facts`, `tea_config_path`, `trace_output_dir`, `implementation_artifacts`, `deferred_work_path`, `epic_branch_prefix`, `protected_branches`, `max_turns_per_story`, `story_token_budget` (**deprecated, no-op**), `parallel_max_concurrency` (**deprecated, no-op**), `allowlist_commands`, `on_epic_complete`, `on_escalation`, `cross_session_recall`, and `graphify_integration`) are the supported override surface. Teams and users override them in `_bmad/custom/ultracode-goal.toml` (and `.user.toml`) with base → team → user resolution (scalars override, tables deep-merge, arrays append). Renaming or removing a key, or changing how it resolves, is a contract change. See [architecture](../architecture.md).
|
|
24
24
|
|
|
25
25
|
`story_token_budget` is **deprecated** as of the deprecation note in `CHANGELOG.md`: it is still shipped, still accepted, and still resolves, so existing overrides keep working and nothing errors. It is a no-op; no layer reads it any more. The runaway bound is turns only, via `max_turns_per_story`. The key stays enumerated here (and stays in `customize.toml`) precisely because removing it would be the contract break this section forbids.
|
|
26
26
|
|
|
27
|
+
`parallel_max_concurrency` is **deprecated** on the same terms, as of the retirement of the experimental `--parallel` fan-out: still shipped, still accepted, still resolves, read by nothing. The `--parallel` flag itself is likewise still accepted by the skill and ignored (the run logs one note and executes the sequential spine), so an operator's old invocation keeps working.
|
|
28
|
+
|
|
27
29
|
### The headless five-key JSON emit shape
|
|
28
30
|
|
|
29
31
|
Every headless (`-H`) exit point emits one object with exactly these five keys, always present, `null` when an artifact was not produced, plus a conditional sixth, `reason`, carrying a one-line cause only when blocked. A **complete** emit omits `reason` entirely; it is not present-and-`null`, so read it only when `status` is `blocked`:
|
|
@@ -48,7 +50,7 @@ A headless run writes that same object to `{workflow.implementation_artifacts}/r
|
|
|
48
50
|
|
|
49
51
|
- **The guarantee**: once a headless run resolves `{workflow.implementation_artifacts}` it clears any prior `run-result.json`, before any stage work. From that point on the file's presence means **this** run reached a terminal. The guarantee is scoped to that moment, so a consumer should still prefer a parseable stdout envelope when the file is absent.
|
|
50
52
|
|
|
51
|
-
Four documented exceptions, none of which is a contract break: a block that fires **before** `{workflow.implementation_artifacts}` resolves (the "not a BMAD project" stop) neither writes nor clears, so it leaves the stdout envelope as its sole output and is the one case where a prior run's file can survive; a terminal whose best-effort write failed leaves no file while still printing its envelope; a headless run that has not yet reached a terminal (still running, crashed, or killed) has no file, because startup cleared any prior one; and an **attended** run writes no file at all and clears none. The file is overwrite-in-place, so it carries no cross-run history
|
|
53
|
+
Four documented exceptions, none of which is a contract break: a block that fires **before** `{workflow.implementation_artifacts}` resolves (the "not a BMAD project" stop) neither writes nor clears, so it leaves the stdout envelope as its sole output and is the one case where a prior run's file can survive; a terminal whose best-effort write failed leaves no file while still printing its envelope; a headless run that has not yet reached a terminal (still running, crashed, or killed) has no file, because startup cleared any prior one; and an **attended** run writes no file at all and clears none. The file is overwrite-in-place, so it carries no cross-run history.
|
|
52
54
|
|
|
53
55
|
### The skill name and invocation phrases
|
|
54
56
|
|
|
@@ -58,8 +60,10 @@ The skill name `ultracode-goal` and its documented invocation phrases ("run an e
|
|
|
58
60
|
|
|
59
61
|
`scripts/gate_eval.py` is the deterministic completion authority. Covered:
|
|
60
62
|
|
|
61
|
-
- **CLI flags**: `--trace-output` (required), `--profile` (`light` | `production`, required), `--story`, `--nfr`, `--test-review` (production only), `--epic-level
|
|
63
|
+
- **CLI flags**: `--trace-output` (required), `--profile` (`light` | `production`, required), `--story`, `--nfr`, `--test-review` (production only), `--tests-ran` (per-story only), `--cycle-profile` (per-story only), `--epic-level`, `--rollup` and `--sprint-status` (roll-up only: `--rollup` requires `--epic-level`, `--story <epic id>` and `--sprint-status`, and `--sprint-status` is rejected without `--rollup`; every roll-up refusal resolves to `gate_status: NOT_EVALUATED` -> `escalate`, never to a silent narrower answer).
|
|
62
64
|
- **The production signals are required, not optional, on a per-story gate.** Under `--profile production` an omitted `--nfr` or `--test-review` is a *failing* signal, exactly as a supplied-but-missing path already was. `--epic-level` is the one sanctioned omission: it declares the epic roll-up, where TEA writes no aggregate to AND, and it cannot be combined with either path (doing so is an invocation error, exit 2). Under `--profile light` the flag is a no-op.
|
|
65
|
+
- **The sweep-scope cap** (`--tests-ran`): optional PATH to the story's `.tests-ran-<story_id>` marker, read in both profiles. The marker's `scope=` line is read fail-closed: `scope=full` passes the verdict through; `scope=scoped`, a missing marker, a missing `scope=` line, or an unrecognised value caps `advance`/`defer` at `reloop` (defer moves too, because its route advances the story). It cannot be combined with `--epic-level` (an invocation error, exit 2). **Omitting the flag skips the check**: invocations that predate the flag keep their verdicts, per the breaking-change rule below. The verdict JSON's `sweep_scope` key carries the recognised value or `null`, and is present exactly when the flag was supplied, so the printed shape of pre-flag invocations is unchanged.
|
|
66
|
+
- **The delta cycle profile** (`--cycle-profile`, `full` | `delta`): `delta` declares a mid-loop gate that re-ran only the previously failed assessor dimension(s); its verdict is capped at `reloop` (`advance` and `defer` both move to `reloop`). An unrecognised value is an argparse error (exit 2), and the flag cannot be combined with `--epic-level` (exit 2). Omission is the full behaviour. The `cycle_profile` JSON key is present exactly when the flag was supplied.
|
|
63
67
|
- **Verdict vocabulary**: the `verdict` values `advance` / `defer` / `reloop` / `escalate`, and the `gate_status` values `PASS` / `CONCERNS` / `FAIL` / `WAIVED` / `NOT_EVALUATED`, plus the mapping between them. See the [gate model](../gate-model.md).
|
|
64
68
|
- **`--story` fail-closed resolution**: when `--story` matches no artifact in a trace dir whose reports or gate-decision files are named per story, the result is `NOT_EVALUATED` (so, `escalate`), never a fallback to another story's gate. A trace dir whose candidates are all generically named (`trace.md`, `gate-decision.json`) still resolves unscoped. Which file the resolver picks, and how it decides that a name carries a story id, are internal.
|
|
65
69
|
|
|
@@ -76,7 +80,7 @@ flowchart LR
|
|
|
76
80
|
class ADV,DEF,REL,ESC verdict
|
|
77
81
|
```
|
|
78
82
|
|
|
79
|
-
The printed JSON object's key set (`verdict`, `gate_status`, `p0_status`, `p1_status`, `overall_status`, `nfr_status`, `review_score`, `epic_level`, `reasons`) is the consumable shape; the human-readable `reasons` strings are not contractual wording. `epic_level` is how a consumer tells an `advance` that ANDed both production signals from one that skipped them by declaration: `nfr_status: null` alone cannot say which, and the distinction is not readable from `reasons` precisely because that wording is not contractual.
|
|
83
|
+
The printed JSON object's key set (`verdict`, `gate_status`, `p0_status`, `p1_status`, `overall_status`, `nfr_status`, `review_score`, `epic_level`, `reasons`) is the consumable shape; the human-readable `reasons` strings are not contractual wording. Two keys are conditional by design: `sweep_scope` appears exactly when `--tests-ran` was supplied (its value the recognised `scope=` reading, or `null`) and `cycle_profile` exactly when `--cycle-profile` was; each is absent otherwise, so an invocation that predates the flags prints the same shape it always did. `epic_level` is how a consumer tells an `advance` that ANDed both production signals from one that skipped them by declaration: `nfr_status: null` alone cannot say which, and the distinction is not readable from `reasons` precisely because that wording is not contractual.
|
|
80
84
|
|
|
81
85
|
## @internal: not covered
|
|
82
86
|
|
|
@@ -85,7 +89,7 @@ Everything not enumerated above is `@internal` and may change in any release, ma
|
|
|
85
89
|
- **Installer library internals**: the implementation behind the CLI subcommands; what is covered is the observable subcommand surface, not how the files get placed.
|
|
86
90
|
- **Reference file structure**: the `references/*.md` stage files' internal structure, step ordering, prose, and section headings. The stage *names* are referenced by the health-check fingerprint (see below) but the file contents are an authoring surface.
|
|
87
91
|
- **Script internals**: the internal functions, regexes, and intermediate behavior of `preflight_check.py`, `gate_eval.py`, `health_check_fp.py`, and the hook scripts. The covered surface is `gate_eval.py`'s CLI and verdict vocabulary above; everything else (the `preflight_check.py` JSON shape, the fingerprint tuple format, the hook env-var names) is internal and may change.
|
|
88
|
-
- **The
|
|
92
|
+
- **The retired `--parallel` workflow**: the experimental fan-out (`assets/execute-epic.workflow.js`, its `/ultracode-goal-execute` registration, args binding and return shape) was explicitly excluded from this contract while it shipped, and has been removed. The `--parallel` flag is still accepted and ignored, and `parallel_max_concurrency` is deprecated, still resolving, no-op — the `story_token_budget` treatment (see [Public contract](#public-contract)).
|
|
89
93
|
- **`_bmad-output/` artifact layout**, with one exception: run folders, the decision log, `run-report.md`, `run-status.json`, the deferred-work ledger, and the improvement queue are run outputs, not a downstream-consumable schema. **`run-result.json` is the exception and is covered** (see [the headless result file](#the-headless-result-file)); it is the one artifact in that tree an automator may pin against. The headless emit shape (covered above) is the supported way to locate the rest of these paths programmatically.
|
|
90
94
|
|
|
91
95
|
## SemVer note
|
|
@@ -96,7 +100,7 @@ What counts as breaking, stated so it is not re-litigated per release:
|
|
|
96
100
|
|
|
97
101
|
- Removing or renaming an enumerated CLI flag, subcommand, config key, or JSON key.
|
|
98
102
|
- **Changing the verdict an unchanged, previously-documented invocation returns.** This is the one that bites, and it bit at 2.0.0: `gate_eval.py --profile production` with neither signal flag was the documented epic-level invocation and returned `advance`; it now returns `reloop` unless `--epic-level` is passed. That the old answer was unearned did not make the change non-breaking — a consumer's pipeline still changed behaviour on an upgrade they did not ask for.
|
|
99
|
-
- Adding a key to the
|
|
103
|
+
- Adding a key to the JSON an UNCHANGED invocation prints (the verdict object or the headless envelope), for a consumer validating the shape strictly. A key that appears only when a newly introduced flag is supplied is additive, not breaking: `sweep_scope` and `cycle_profile` are the worked example, present exactly when `--tests-ran` / `--cycle-profile` are passed and absent from every pre-flag invocation's output.
|
|
100
104
|
|
|
101
105
|
What does not:
|
|
102
106
|
|
package/docs/architecture.md
CHANGED
|
@@ -3,15 +3,15 @@ title: Architecture
|
|
|
3
3
|
description: "How UltraCode Goal works as a conductor over BMAD, TEA, and Claude Code primitives: the three enforcement layers, file layout, and customization resolution."
|
|
4
4
|
---
|
|
5
5
|
|
|
6
|
-
UltraCode Goal is a conductor. It orchestrates the installed BMAD epic toolbox and the TEA gates, composing Claude Code primitives (`/goal`, Auto Mode, Auto Memory, hooks, git
|
|
6
|
+
UltraCode Goal is a conductor. It orchestrates the installed BMAD epic toolbox and the TEA gates, composing Claude Code primitives (`/goal`, Auto Mode, Auto Memory, hooks, git branch isolation) and replaces none of them. This page covers the conductor model, the three enforcement layers in depth, the file layout, customization resolution, and why the hooks live where they do.
|
|
7
7
|
|
|
8
8
|
## The conductor model
|
|
9
9
|
|
|
10
10
|
The skill owns no implementation logic of its own for building features or running tests. What it owns is the *order*, the *gates*, and the *enforcement*. It delegates:
|
|
11
11
|
|
|
12
|
-
- **Epic toolbox**: `bmad-sprint-planning`, `bmad-create-story`, `bmad-
|
|
12
|
+
- **Epic toolbox**: `bmad-sprint-planning`, `bmad-create-story`, `bmad-dev-story`, `bmad-code-review`, `bmad-correct-course`, `bmad-retrospective`.
|
|
13
13
|
- **TEA gates**: `bmad-testarch-framework`, `-ci`, `-test-design`, `-atdd`, `-automate`, `-test-review`, `-nfr`, `-trace`.
|
|
14
|
-
- **Claude Code primitives**: the `/goal` loop drives execution; Auto Mode and ultracode session effort make the unattended run possible; Auto Memory carries learnings forward; hooks enforce invariants; git branches
|
|
14
|
+
- **Claude Code primitives**: the `/goal` loop drives execution; Auto Mode and ultracode session effort make the unattended run possible; Auto Memory carries learnings forward; hooks enforce invariants; git branches provide isolation and rollback.
|
|
15
15
|
|
|
16
16
|
Because it is a conductor, the truth of "is this done" lives in the artifacts its delegates produce, not in the conductor's own reasoning. That is the whole design: the model arranges the work, but a script reads the verdict.
|
|
17
17
|
|
|
@@ -21,7 +21,7 @@ These are the module's non-negotiables. Each exists because the documented mecha
|
|
|
21
21
|
|
|
22
22
|
### 1. Deterministic gate truth
|
|
23
23
|
|
|
24
|
-
`scripts/gate_eval.py` reads TEA's `gate-decision.json` and maps its gate status to a routing verdict (`PASS`/`WAIVED` → advance, `CONCERNS` → defer, `FAIL` → reloop, `NOT_EVALUATED` → escalate). It never re-derives TEA's thresholds and never reads the transcript. The `/goal` evaluator that drives execution can only see what the run surfaces, it cannot open the gate file, so it is structurally incapable of being the completion authority. The script is. In production, two extra signals can only downgrade an `advance`, never lift a lower verdict. See the [gate model](./gate-model.md) for the full mapping diagram, thresholds, and the fail-closed contract.
|
|
24
|
+
`scripts/gate_eval.py` reads TEA's `gate-decision.json` and maps its gate status to a routing verdict (`PASS`/`WAIVED` → advance, `CONCERNS` → defer, `FAIL` → reloop, `NOT_EVALUATED` → escalate). It never re-derives TEA's thresholds and never reads the transcript. The `/goal` evaluator that drives execution can only see what the run surfaces, it cannot open the gate file, so it is structurally incapable of being the completion authority. The script is. In production, two extra signals can only downgrade an `advance`, never lift a lower verdict; in both profiles a `scope=scoped` tests-ran marker caps a story-moving verdict at `reloop`, so a scoped re-loop sweep can never advance a story. See the [gate model](./gate-model.md) for the full mapping diagram, thresholds, and the fail-closed contract.
|
|
25
25
|
|
|
26
26
|
### 2. Hooks as invariants
|
|
27
27
|
|
|
@@ -34,7 +34,7 @@ Both hooks read their config from env first (so the conductor injects per-run va
|
|
|
34
34
|
|
|
35
35
|
### 3. Budget enforcement
|
|
36
36
|
|
|
37
|
-
A runaway story is bounded by three layers in order of authority: the **in-condition** "…or stop after N turns" clause inside the `/goal` condition (the real in-loop bound), the **gate re-loop budget** (a `reloop` that would exceed `max_turns_per_story` becomes `escalate`), and the **Stop hook** as the defensive backstop described above. Rollback is git, not `/rewind` (an Epic branch off a protected branch, one commit per green story
|
|
37
|
+
A runaway story is bounded by three layers in order of authority: the **in-condition** "…or stop after N turns" clause inside the `/goal` condition (the real in-loop bound), the **gate re-loop budget** (a `reloop` that would exceed `max_turns_per_story` becomes `escalate`), and the **Stop hook** as the defensive backstop described above. Rollback is git, not `/rewind` (an Epic branch off a protected branch, one commit per green story) because `/rewind` checkpoints miss the Bash-driven changes that make up the run.
|
|
38
38
|
|
|
39
39
|
## File layout
|
|
40
40
|
|
|
@@ -56,10 +56,12 @@ skills/ultracode-goal/
|
|
|
56
56
|
├── scripts/ # Deterministic truth (run via `uv`)
|
|
57
57
|
│ ├── preflight_check.py # mechanical preflight facts + blocker budget
|
|
58
58
|
│ ├── gate_eval.py # gate status -> verdict (the completion authority)
|
|
59
|
+
│ ├── mutate_check.py # mutation harness: attributable-red proof for the story's guards
|
|
59
60
|
│ ├── gate_trail.py # per-story evidence trail (gate-trail.md) at finalize
|
|
60
61
|
│ ├── formalize_check.py # readiness kernel behind the /ucg-formalize gate
|
|
61
62
|
│ ├── status_render.py # read-side render behind /ucg-status
|
|
62
63
|
│ ├── red_ids.py # preflight-RED identity (the resolve join key)
|
|
64
|
+
│ ├── story_sizing.py # decomposition sizing + parent-AC claim reconciliation
|
|
63
65
|
│ ├── drive_epic.py # one `claude -p` per story (--max-stories work bound)
|
|
64
66
|
│ ├── headless_envelope.py # the one five-key headless-envelope adapter
|
|
65
67
|
│ ├── health_check_fp.py # health-check fingerprint + seen-cache plumbing
|
|
@@ -72,17 +74,20 @@ skills/ultracode-goal/
|
|
|
72
74
|
│ └── hooks/
|
|
73
75
|
│ ├── guard_pretooluse.py # commit invariants (PreToolUse)
|
|
74
76
|
│ └── budget_stop.py # turn budget (Stop)
|
|
75
|
-
├── skills/
|
|
76
|
-
│ ├── ucg-formalize/ # Standalone readiness gate
|
|
77
|
-
│ ├── ucg-resolve/ # Decide-surface for a blocked or escalated run
|
|
78
|
-
│ └── ucg-status/ # Read-only status view over a run
|
|
79
77
|
└── assets/
|
|
80
|
-
├── execute-epic.workflow.js # EXPERIMENTAL --parallel worktree fan-out
|
|
81
78
|
├── module.yaml · module-setup.md · module-help.csv # install metadata
|
|
82
79
|
└── ucg-awareness/ # shift-left planning customization fragments
|
|
80
|
+
|
|
81
|
+
skills/ucg-formalize/ # Standalone readiness gate
|
|
82
|
+
skills/ucg-resolve/ # Decide-surface for a blocked or escalated run
|
|
83
|
+
skills/ucg-status/ # Read-only status view over a run
|
|
84
|
+
# Top-level siblings of `ultracode-goal`, not children:
|
|
85
|
+
# the IDE's skill loader enumerates one level, so a
|
|
86
|
+
# nested command never resolves. Each stays thin and
|
|
87
|
+
# reaches back into the parent via `{ucg-root}`.
|
|
83
88
|
```
|
|
84
89
|
|
|
85
|
-
`SKILL.md` carries the routing and the contract; the `references/*.md` files carry each stage's procedure and testable routing conditions; the `scripts/*.py` files carry the deterministic facts the model cannot fudge (the gate, preflight, readiness kernel, hooks, and the install-time/recall plumbing); the `skills
|
|
90
|
+
`SKILL.md` carries the routing and the contract; the `references/*.md` files carry each stage's procedure and testable routing conditions; the `scripts/*.py` files carry the deterministic facts the model cannot fudge (the gate, preflight, readiness kernel, hooks, and the install-time/recall plumbing); the top-level sibling skills `skills/ucg-*` are the operator-facing surfaces (`ucg-formalize` the standalone readiness gate, `ucg-resolve` the decide-surface for a stopped run, `ucg-status` the read-only run view); and the `assets/` hold install metadata and the planning-customization fragments. See [how it works](./how-it-works.md) for the stages.
|
|
86
91
|
|
|
87
92
|
## Customization resolution
|
|
88
93
|
|
|
@@ -94,7 +99,7 @@ Configuration resolves in three layers, base → team → user, via `resolve_cus
|
|
|
94
99
|
|
|
95
100
|
Neither override file is created by any installer, and a missing one is not an error: the resolver loads it non-required and treats absence as an empty table, so a fresh project resolves the base layer alone. You create them when you first need to override something. Do not mistake them for the `config.toml` and `config.user.toml` already sitting in that directory: those are BMAD's own configuration, and a UCG knob written there resolves to nothing.
|
|
96
101
|
|
|
97
|
-
Merge semantics: **scalars override**, **tables deep-merge**, **arrays append**. At activation the skill runs `resolve_customization.py --skill {skill-root} --key workflow`; if that fails, it resolves the three files itself in the same order. The shipped base layer defines the run's knobs: the TEA/artifact paths (`tea_config_path`, `trace_output_dir`, `implementation_artifacts`, `deferred_work_path`), the git guardrails (`epic_branch_prefix`, `protected_branches`), the turn budget (`max_turns_per_story`; `story_token_budget` remains as a deprecated no-op key), the
|
|
102
|
+
Merge semantics: **scalars override**, **tables deep-merge**, **arrays append**. At activation the skill runs `resolve_customization.py --skill {skill-root} --key workflow`; if that fails, it resolves the three files itself in the same order. The shipped base layer defines the run's knobs: the TEA/artifact paths (`tea_config_path`, `trace_output_dir`, `implementation_artifacts`, `deferred_work_path`), the git guardrails (`epic_branch_prefix`, `protected_branches`), the turn budget (`max_turns_per_story`; `story_token_budget` remains as a deprecated no-op key), `parallel_max_concurrency` (deprecated no-op since the `--parallel` retirement), the `allowlist_commands`, the two lifecycle hooks (`on_epic_complete`, `on_escalation`), the [health check](./health-check.md) family (`health_check_repo`, `health_check_seen_cache`, `health_check_queue_path`, `health_check_autosubmit`), and the two optional third-party integrations, both off by default: [`cross_session_recall`](./cross-session-recall.md) and [`graphify_integration`](./knowledge-graph-refresh.md). Teams and users override without editing the shipped file. Remember that a budget or branch override only reaches the *enforcement* layer because preflight threads it into the hook env (see layer 2 above).
|
|
98
103
|
|
|
99
104
|
The three TOML layers merge once, but a branch or budget value then travels two ways: the conductor reads it directly, while the hooks only see it if preflight re-injects it as env:
|
|
100
105
|
|
package/docs/comparison.md
CHANGED
|
@@ -5,13 +5,19 @@ description: An honest, side-by-side comparison of UltraCode Goal and bmad-code-
|
|
|
5
5
|
|
|
6
6
|
Both UltraCode Goal (UCG) and [bmad-loop](https://github.com/bmad-code-org/bmad-loop) (formerly bmad-auto; renamed at v0.8.0) automate the BMAD implementation phase without a babysitter. They are siblings, not clones: they make opposite bets on where the control loop lives and how completion is judged. This page compares them honestly, including the places where bmad-loop is the better tool.
|
|
7
7
|
|
|
8
|
-
Snapshot: UCG
|
|
8
|
+
Snapshot: UCG v2.0.0 and bmad-loop v0.9.1, both released on 2026-08-02. Both projects are young and moving fast.
|
|
9
|
+
|
|
10
|
+
bmad-loop's v0.9.1 is a compatibility hotfix rather than new capability: BMAD-METHOD renamed its dev primitive from `bmad-dev-auto` to `bmad-build-auto`, and bmad-loop now resolves the primitive on disk so a project on either era validates and runs. Notably it *refuses* the forwarding shim upstream left behind, because that shim's migration prompt is interactive and would halt an unattended session with nothing written to disk, and it added checks for a worktree that could not be given its upstream skills. UCG is not affected by that rename: it orchestrates `bmad-dev-story`, not the auto primitive. The substantive capability release remains v0.9.0 (2026-07-21), which added a `stories.yaml` planning mode with per-story checkpoints, patch-restore escalation recovery, a pluggable multiplexer-backend registry, verify-gate integrity fixes, a graceful stop that finishes the in-flight item, an active-agent indicator, an OpenCode adapter driven over HTTP rather than a multiplexer, and schema-versioned `--json` documents for eight commands.
|
|
11
|
+
|
|
12
|
+
UCG reached v2.0.0 on 2026-08-02. Its headline is unglamorous and worth stating plainly: a quality scan paired the usual prose review with critics reading the Python directly, and nine high-severity defects survived independent reproduction. Six were fail-opens, cases where the module could report work passed that it never actually checked, including a commit guard bypassable by any shell compound form, an NFR audit reading `NOT_ASSESSED` that passed the production gate, and a readiness kernel scoring `ready` on an unparseable sprint board. A seventh was reachability: the three companion skills below shipped nested one directory too deep for the skill loader, so `/ucg-formalize`, `/ucg-resolve` and `/ucg-status` returned `Unknown skill` for their entire existence. All are fixed, each with a test that fails against the previous implementation.
|
|
13
|
+
|
|
14
|
+
Treat every line below as a point-in-time reading of two *released* versions, and verify the current state for yourself (links at the bottom); both projects' main branches run well ahead of their tags.
|
|
9
15
|
|
|
10
16
|
## The one difference everything else follows from
|
|
11
17
|
|
|
12
18
|
bmad-loop puts the control loop in **plain Python, outside the agent**. A deterministic orchestrator picks the next story, spawns a fresh, disposable coding-agent session (over tmux by default) for each step, watches structured hook events the session writes, and decides retries, gates, and completion in code. No LLM sits in the control loop.
|
|
13
19
|
|
|
14
|
-
UCG puts the control loop **inside Claude Code**. The run is a Claude Code skill that composes `/goal`, Auto Mode, Auto Memory, and runtime hooks
|
|
20
|
+
UCG puts the control loop **inside Claude Code**. The run is a Claude Code skill that composes `/goal`, Auto Mode, Auto Memory, and runtime hooks. The per-story loop is paced by Claude Code's `/goal` evaluator (an LLM), while the binding completion verdict is a deterministic script (`gate_eval.py`) that reads the Test Architect's (TEA) gate artifact.
|
|
15
21
|
|
|
16
22
|
The consequence cascades: bmad-loop is a tool you run beside any supported agent; UCG is a capability that lives within one specific agent.
|
|
17
23
|
|
|
@@ -25,14 +31,14 @@ The consequence cascades: bmad-loop is a tool you run beside any supported agent
|
|
|
25
31
|
| Scope | Implementation phase: `backlog` and `ready-for-dev` stories from `sprint-status.yaml`, or opt-in from a typed `stories.yaml`, through dev, review, verify, commit | Whole Epic, six stages: ingest and scope, planning-readiness preflight, ATDD (acceptance-test-driven development) test generation, execute, TEA gate, finalize, whose terminal step is a workflow health check that the skill's own table numbers as a seventh stage |
|
|
26
32
|
| Completion authority | Checks on the spec and result artifacts, a proof-of-work diff, and your test and lint commands; opt-in TEA gate steps via a bundled plugin (advisory by default) | TEA quality gate: `gate-decision.json` (P0/P1/overall), combined in the default profile with NFR and test-review artifacts, read fail-closed by `gate_eval.py` |
|
|
27
33
|
| Test strategy | Your `[verify].commands` plus adversarial review hunters; opt-in TEA test-design and ATDD workflows via the bundled plugin | ATDD: acceptance criteria become executable red-phase tests driven to green; TEA traceability |
|
|
28
|
-
| Pre-launch gate | `validate
|
|
29
|
-
| Observability | A live terminal dashboard (built with Textual): runs table, attach to live sessions, journal, cost-weighted token totals, an active-agent indicator naming what is driving the current stage, plus schema-versioned `--json` documents for scripted readers | Files plus a read-only renderer: `.decision-log.md`, a `run-status.json` heartbeat
|
|
34
|
+
| Pre-launch gate | `validate`, a registry of named checks across BMAD config, policy, sprint-status, git, multiplexer and process host, CLI binary and profile, hook registration, base skills, and stories-mode manifest and dispatch; v0.9.1 added `skills.base-shim`, which refuses the forwarding shim BMAD-METHOD's rename left behind | A mechanical preflight script plus a readiness check and a semantic scan that refuse to launch on an undecided product or architecture decision |
|
|
35
|
+
| Observability | A live terminal dashboard (built with Textual): runs table, attach to live sessions, journal, cost-weighted token totals, an active-agent indicator naming what is driving the current stage, plus schema-versioned `--json` documents for scripted readers | Files plus a read-only renderer: `.decision-log.md`, a `run-status.json` heartbeat, a transcript ticker that prints each gate verdict, a `gate-trail.md` evidence trail at finalize, and `/ucg-status` to assemble all of it on demand |
|
|
30
36
|
| Deferred work | A triage-and-execute **sweep** engine plus a decisions workflow | A ledger the gate only appends to, surfaced at finalize and readable mid-run through `/ucg-status`, with `/ucg-resolve` able to mark an answered decision row resolved; no execute engine |
|
|
31
37
|
| Escalation | Typed (CRITICAL / PREFERENCE) plus an interactive resolve agent that re-arms the spec and re-applies the saved patch, so review resumes on the restored diff | An `escalate` verdict, a typed `escalation-<story-id>.json` sidecar (`source`, `kind`, `decision_needed`, `evidence`), an `on_escalation` hook, a path-pinned `run-result.json` for every headless terminal exit that got far enough to resolve its artifacts path, not only blocked ones, and `/ucg-resolve` to answer what is pending; resume from the decision log |
|
|
32
|
-
| Isolation | In place by default; opt-in git worktree per story or bundle, merged back locally | None
|
|
38
|
+
| Isolation | In place by default; opt-in git worktree per story or bundle, merged back locally | None (stories run sequentially in one session; the experimental `--parallel` worktree mode was retired) |
|
|
33
39
|
| Extensibility | A plugin system (observe, veto, mutate) with bundled TEA and Unity plugins | `customize.toml` knobs, planning-shaping fragments, and two optional third-party integrations configured there, both off by default and neither able to touch a gate verdict: [claude-mem recall](./cross-session-recall.md) and a [graphify knowledge-graph refresh](./knowledge-graph-refresh.md) |
|
|
34
40
|
| Self-improvement | Not shipped | A health check that files deduplicated GitHub issues about its own friction |
|
|
35
|
-
| Maturity | First-party (bmad-code-org); v0.9.0, whose headline
|
|
41
|
+
| Maturity | First-party (bmad-code-org); v0.9.1, a compatibility hotfix over v0.9.0, whose headline was stable schema-versioned `--json` contracts that evolve additively; rich docs; CI + test suite | Community module; v2.0.0, which closes nine high-severity defects (six of them fail-opens in the completion path) and carries four breaking changes with migrations, over the v1.0.0 SemVer contract; docs site; CI + test suite |
|
|
36
42
|
| License | MIT | MIT |
|
|
37
43
|
|
|
38
44
|
## Where bmad-loop is stronger
|
|
@@ -52,14 +58,14 @@ This is a genuinely strong tool; pretending otherwise would make this page usele
|
|
|
52
58
|
|
|
53
59
|
bmad-loop can reach similar territory, but differently. Its default gate is checks on the spec and result artifacts, a proof-of-work diff (the commit must contain real changes since the story's baseline), and your test and lint commands; its bundled TEA plugin can add trace, NFR, and test-review steps before every commit. That plugin is opt-in, its gate steps ship advisory (non-blocking), and they fail open when an artifact is missing or unparseable. That gap narrowed in v0.9.0: at v0.8.1 bmad-loop's independent baseline-commit cross-check could not actually fire, because it read a spec key the dev skill does not write, so a spec claiming a stale or foreign baseline sailed through; v0.9.0 fixed it to accept either key and re-cut the test fixture that had been fabricating the missing one. The advisory-by-default and fail-open-on-missing-artifact properties of the TEA plugin's gate steps are unchanged. If you want acceptance-criterion-to-test traceability enforced by default, fail-closed, with nothing to configure, that is UCG's defining bet.
|
|
54
60
|
2. **ATDD-first.** UCG turns each story's acceptance criteria into executable acceptance tests (scaffolded as red-phase `test.skip` placeholders) before any code is written, then un-skips them and drives them to green. The acceptance tests are a first-class generated artifact, not a by-product. One scope note, about what the generator *emits* rather than what it accepts: the TEA release installed here does detect a backend stack, but its scaffolds are Playwright and TypeScript, and the browser-recording path loads only for a frontend or fullstack project, so a stack with no JS or TS harness still gets nothing runnable. UCG's preflight therefore steers those runs to `--light`, where the story's acceptance criteria (not generated tests) are the trace oracle, or you author the acceptance tests in the stack's own harness. bmad-loop's default pipeline relies on whatever tests the dev skill writes while implementing, plus the test commands you supply; TEA test generation exists there only as an opt-in plugin step that runs after dev, not as the default path.
|
|
55
|
-
3. **A planning-readiness gate that can refuse to launch.** UCG's preflight hands the PRD, the architecture, and the stories to a throwaway subagent that hunts for undecided product or architecture decisions, contradictions between the PRD and the architecture, and any story whose "done" cannot be pinned down. The scan grades what it finds, and any RED verdict stops the run rather than letting an unattended agent guess; the one way past a RED is an operator recording a `close` for it, since a `defer` does not clear one and an unreadable decisions file clears nothing. That scan is itself LLM judgment, the very thing bmad-loop keeps out of its loop; the difference is that it can only block a launch, never pass one, and the readiness kernel beside it is deterministic
|
|
56
|
-
4. **Almost no moving parts outside the agent.** The autonomous run is a skill: no daemon, no multiplexer, no session to attach to. For a Claude Code user that is a smaller operational surface, and it is also exactly why UCG cannot run anywhere else. Two qualifiers, added honestly. Three companion skills ship alongside the run and none is required by one: `ucg-formalize` (the standalone readiness gate), `ucg-status` (the read-only run view), and `ucg-resolve` (the decide-surface for a stopped run). And a long Epic accumulates every story's transcript in one session, so UCG ships an optional driver script that spawns one `claude -p` per story; use it and you are running a loop outside the agent after all, which is bmad-loop's model in miniature. The difference is that it is opt-in and about 900 lines, where bmad-loop's orchestrator is the product; skip it and the skill still runs standalone, since `--max-stories` is a flag on the skill rather than something the script provides.
|
|
61
|
+
3. **A planning-readiness gate that can refuse to launch.** UCG's preflight hands the PRD, the architecture, and the stories to a throwaway subagent that hunts for undecided product or architecture decisions, contradictions between the PRD and the architecture, and any story whose "done" cannot be pinned down. The scan grades what it finds, and any RED verdict stops the run rather than letting an unattended agent guess; the one way past a RED is an operator recording a `close` for it, since a `defer` does not clear one and an unreadable decisions file clears nothing. That scan is itself LLM judgment, the very thing bmad-loop keeps out of its loop; the difference is that it can only block a launch, never pass one, and the readiness kernel beside it is deterministic. That kernel has been the module's most defect-prone surface, and the honest reading is that it took three releases to make it fail closed: v1.0.0 closed three fail-opens where an Epic with no stories, a story with no acceptance criteria, and a partially seeded story set each scored `ready`, and v2.0.0 closed two more, where a present-but-unparseable sprint board emptied the in-scope set (silencing both guards that exist to catch exactly that), and where a citation in a story counted as its own declaration, so a dangling reference could never be reported and the judgment branch was unreachable. bmad-loop's preflight is mechanical and assumes the sprint's stories are already ready to build.
|
|
62
|
+
4. **Almost no moving parts outside the agent.** The autonomous run is a skill: no daemon, no multiplexer, no session to attach to. For a Claude Code user that is a smaller operational surface, and it is also exactly why UCG cannot run anywhere else. Two qualifiers, added honestly. Three companion skills ship alongside the run and none is required by one: `ucg-formalize` (the standalone readiness gate), `ucg-status` (the read-only run view), and `ucg-resolve` (the decide-surface for a stopped run). Worth recording rather than quietly fixing: until v2.0.0 all three shipped one directory too deep for the skill loader, which enumerates a single level, so every one of them returned `Unknown skill` when invoked. Every check the project had verified they were *present*, and they were; none tested whether they were *reachable*. And a long Epic accumulates every story's transcript in one session, so UCG ships an optional driver script that spawns one `claude -p` per story; use it and you are running a loop outside the agent after all, which is bmad-loop's model in miniature. The difference is that it is opt-in and about 900 lines, where bmad-loop's orchestrator is the product; skip it and the skill still runs standalone, since `--max-stories` is a flag on the skill rather than something the script provides.
|
|
57
63
|
5. **A self-improvement loop.** UCG's finalize step can file deduplicated GitHub issues about friction in its own workflow, so the tool reports its own rough edges.
|
|
58
64
|
|
|
59
65
|
## What they share
|
|
60
66
|
|
|
61
|
-
- A deterministic completion authority the model cannot talk its way past: bmad-loop's artifact, diff, and command checks; UCG's TEA gate read
|
|
62
|
-
- Proof that the commit is real work, not a claim about work. bmad-loop cross-checks the diff against the story's baseline commit; UCG enforces the equivalent one layer down, in a `PreToolUse` hook that denies the `git commit` outright unless a tests-ran marker exists whose recorded baseline SHA matches the story's character for character, and unless the staged index is non-empty. On a production run it also refuses a commit whose staged acceptance tests are still skipped, though that check reads `test.skip(` and so does nothing on the non-web stacks the ATDD note above steers to `--light`.
|
|
67
|
+
- A deterministic completion authority the model cannot talk its way past: bmad-loop's artifact, diff, and command checks; UCG's TEA gate read. One caveat on the UCG side, narrowed but not removed in v2.0.0: on a non-web stack, under either profile, the trace artifacts are agent-authored under strict honesty rules, so on that path the model writes the file the gate then reads and the guarantee is procedural rather than mechanical. What changed is that the substitution is no longer invisible: the gate now records `gate-provenance: tea` or `hand-authored` per story and the run report carries it, so a reader can tell which verdicts rested on artifacts the run produced for itself. Before that, an Epic could complete entirely on hand-authored gate files and read identically to one gated on TEA output.
|
|
68
|
+
- Proof that the commit is real work, not a claim about work. bmad-loop cross-checks the diff against the story's baseline commit; UCG enforces the equivalent one layer down, in a `PreToolUse` hook that denies the `git commit` outright unless a tests-ran marker exists whose recorded baseline SHA matches the story's character for character, and unless the staged index is non-empty. That hook is only as good as its command parsing, which is worth stating because until v2.0.0 it was not: a commit wrapped in any shell compound form (`if`, a loop body, a subshell, a brace group) or placed after a background `&` classified as carrying no git write at all, skipping the protected-branch, marker, freshness and empty-index gates in one go. On a production run it also refuses a commit whose staged acceptance tests are still skipped, though that check reads `test.skip(` and so does nothing on the non-web stacks the ATDD note above steers to `--light`.
|
|
63
69
|
- Fresh-context review separated from implementation, to kill self-review anchoring bias, on both defaults with a caveat each: bmad-loop's separate session is gated by `review.trigger`, which defaults to `recommended` (set it to `always` for every story), and UCG runs a code-review pass on its production profile but none under `--light`.
|
|
64
70
|
- Adversarial review passes, bounded so they cannot oscillate forever: bmad-loop by `max_review_cycles` (default 3), UCG by `max_turns_per_story`, where a re-loop that would exceed the budget escalates instead.
|
|
65
71
|
- Optional git worktree isolation.
|
|
@@ -81,4 +87,6 @@ Both tools change weekly, so re-check before you rely on anything above:
|
|
|
81
87
|
- bmad-loop: its [README](https://github.com/bmad-code-org/bmad-loop), [docs/FEATURES.md](https://github.com/bmad-code-org/bmad-loop/blob/main/docs/FEATURES.md), and [docs/ROADMAP.md](https://github.com/bmad-code-org/bmad-loop/blob/main/docs/ROADMAP.md).
|
|
82
88
|
- UCG: [How It Works](./how-it-works.md) and the [Gate Model](./gate-model.md).
|
|
83
89
|
|
|
84
|
-
This snapshot was re-cut on 2026-
|
|
90
|
+
This snapshot was re-cut on 2026-08-02 against bmad-loop v0.9.1 and UCG v2.0.0, both released that day. Earlier cuts: 2026-07-28 (bmad-loop v0.9.0, UCG v1.0.0), 2026-07-12 (bmad-loop v0.8.1, UCG v0.5.1), and 2026-06-28 (bmad-auto v0.7.4, UCG v0.4.0), which predates the bmad-auto rename.
|
|
91
|
+
|
|
92
|
+
One deliberate omission in this cut. Previous versions of this page stated a count of bmad-loop's registered `validate` checks. That number could not be reproduced from the v0.9.1 source without running their tool, so it has been replaced by the list of check families, which can be. A number nobody re-derives is a number that quietly goes stale, and this page has no business asserting a precise figure about someone else's project that its own author cannot check.
|
package/docs/gate-model.md
CHANGED
|
@@ -86,6 +86,21 @@ flowchart TD
|
|
|
86
86
|
|
|
87
87
|
Under `--profile light` none of this applies: the trace gate is the whole decision, and `--epic-level` is a no-op there.
|
|
88
88
|
|
|
89
|
+
## The sweep-scope cap
|
|
90
|
+
|
|
91
|
+
Independent of profile, a per-story gate is also handed the story's `.tests-ran-<story_id>` marker via `--tests-ran`. Execute writes a `scope=<full|scoped>` line into that marker beside `baseline=`, naming which sweep form the green run behind this gate was: the full three-axis sweep, or a re-loop iteration's affected-set sweep (changed packages plus their dependents, still cache-defeated, with the resolved package list printed and recorded on a `packages=` line). The script reads the line and applies one rule: **a story only moves forward off a full-scope sweep.** `scope=full` passes the verdict through; `scope=scoped` caps `advance` at `reloop`, and caps `defer` too, because defer's route advances the story after parking its concerns. A missing marker, a marker with no `scope=` line, or an unrecognised value gets the same cap, fail-closed, with a reason naming what was wrong.
|
|
92
|
+
|
|
93
|
+
Two boundaries:
|
|
94
|
+
|
|
95
|
+
- `--epic-level` refuses `--tests-ran` outright (an invocation error, exit 2): the epic roll-up gates no sweep of its own, since every story proved its own scope before reaching `done`.
|
|
96
|
+
- Omitting the flag skips the check. That is deliberate: making omission failing would change the verdict of documented invocations that predate the flag, which is exactly the 2.0.0 lesson in the [stability policy](https://github.com/armelhbobdad/bmad-module-ultracode-goal/blob/main/docs/_internal/STABILITY.md). The skill instructions require the flag on every per-story gate; the script does not retrofit that requirement onto older callers.
|
|
97
|
+
|
|
98
|
+
The verdict JSON carries the recognised value as `sweep_scope` (or `null`), so an advance that proved a full sweep is distinguishable from one that was never asked about its sweep.
|
|
99
|
+
|
|
100
|
+
## The delta cycle profile
|
|
101
|
+
|
|
102
|
+
A mid-loop re-gate may declare `--cycle-profile delta`: only the assessor dimension(s) whose findings produced the previous reloop re-run in full, while the other assessors re-check their prior artifact against the diff since the commit they assessed. The script caps a delta gate's verdict at `reloop` (defer too, for the sweep-cap reason): a delta gate can say "not yet, and here is why", never move the story. Advancing requires the full instrument, every assessor over a `scope=full` sweep, so the oracle's finality is untouched and a wrong guess costs one extra full gate rather than an unearned advance. The fallback is mechanical: any prior finding without a clean dimension attribution means the full gate runs. `--epic-level` refuses the flag (invocation error, exit 2); omitting it is the full behaviour, and the `cycle_profile` JSON key appears exactly when the flag was supplied.
|
|
103
|
+
|
|
89
104
|
## The thresholds
|
|
90
105
|
|
|
91
106
|
The P0/P1/overall percentage thresholds (**P0 = 100%, P1 >= 90%, overall >= 80%**) are decided **upstream by the TEA trace workflow** and written into the gate artifact; `gate_eval.py` reads the resulting `gate_status`, `p0_status`, `p1_status`, and `overall_status` rather than recomputing the percentages. The script's own production AND adds the two coarser signals above (NFR != FAIL, review score >= 80 and recommendation != Block). Do not restate or recompute the TEA percentages elsewhere; they are TEA-owned, and the test-design stage's job is only to assign the P0-P3 priorities honestly so those upstream thresholds key off real priorities.
|
|
@@ -109,10 +124,15 @@ The script prints one JSON object (`evaluate()` in the script):
|
|
|
109
124
|
"overall_status": "...",
|
|
110
125
|
"nfr_status": "...",
|
|
111
126
|
"review_score": 0,
|
|
127
|
+
"epic_level": false,
|
|
128
|
+
"sweep_scope": "full|scoped|null",
|
|
129
|
+
"cycle_profile": "full|delta",
|
|
112
130
|
"reasons": ["..."]
|
|
113
131
|
}
|
|
114
132
|
```
|
|
115
133
|
|
|
134
|
+
`epic_level` is always present. The `sweep_scope` and `cycle_profile` keys are conditional by the same contract: each is present exactly when its flag (`--tests-ran`, `--cycle-profile`) was supplied and absent otherwise, so an invocation that predates the flags prints the same shape it always did.
|
|
135
|
+
|
|
116
136
|
### Example: a clean production advance
|
|
117
137
|
|
|
118
138
|
A story whose slim gate file reads `PASS`, with an NFR audit of `PASS` and a test review scoring 92 with an Approve recommendation, produces:
|
|
@@ -126,6 +146,8 @@ A story whose slim gate file reads `PASS`, with an NFR audit of `PASS` and a tes
|
|
|
126
146
|
"overall_status": "PASS",
|
|
127
147
|
"nfr_status": "PASS",
|
|
128
148
|
"review_score": 92,
|
|
149
|
+
"epic_level": false,
|
|
150
|
+
"sweep_scope": "full",
|
|
129
151
|
"reasons": [
|
|
130
152
|
"gate read from gate-decision.json",
|
|
131
153
|
"gate_status PASS -> advance"
|
|
@@ -146,6 +168,8 @@ The same `PASS` gate, but with a test review scoring 74, downgrades to `reloop`;
|
|
|
146
168
|
"overall_status": "PASS",
|
|
147
169
|
"nfr_status": "PASS",
|
|
148
170
|
"review_score": 74,
|
|
171
|
+
"epic_level": false,
|
|
172
|
+
"sweep_scope": "full",
|
|
149
173
|
"reasons": [
|
|
150
174
|
"gate read from gate-decision.json",
|
|
151
175
|
"gate_status PASS -> advance",
|
package/docs/getting-started.md
CHANGED
|
@@ -45,7 +45,7 @@ From there the run is autonomous: it defines done with TEA, executes each story
|
|
|
45
45
|
| Flag | Effect |
|
|
46
46
|
|------|--------|
|
|
47
47
|
| `--light` | Trace-only gate. Downscopes from the full TEA chain to `bmad-testarch-trace` plus `gate_eval.py --profile light`: no NFR/test-review AND. |
|
|
48
|
-
| `--parallel` |
|
|
48
|
+
| `--parallel` | Retired. The flag is still accepted so an old invocation does not error: the run logs one note that it was accepted and ignored, then executes the sequential `/goal` spine. |
|
|
49
49
|
| `--yes` | Skips Stage 1's open-floor invite and the launch confirm. The launch briefing still prints. **Never** skips the hard preflight gate. |
|
|
50
50
|
| `-H` | Headless. Runs non-interactively, never prompts (an unresolvable secret becomes a red blocker, not a question), and emits one JSON object at every exit point. |
|
|
51
51
|
| `--retro` | Runs the close-out retrospective (`bmad-retrospective`). Interactive runs offer it at Epic close anyway; headless runs it only when `--retro` is passed. |
|
package/docs/how-it-works.md
CHANGED
|
@@ -78,11 +78,11 @@ Turn the Epic's acceptance criteria into **executable, red-phase acceptance test
|
|
|
78
78
|
|
|
79
79
|
### Stage 4: Execute
|
|
80
80
|
|
|
81
|
-
Drive each in-scope story from its red-phase tests to a green, committed state.
|
|
81
|
+
Drive each in-scope story from its red-phase tests to a green, committed state. Execution is the **sequential `/goal` spine**; per story, in sprint order: set the current story (so the PreToolUse hook can find its marker) → `bmad-dev-story` implements the feature and un-skips the story's ATDD tests → run tests/lint/build and **print the raw output** as evidence → (production) `bmad-testarch-test-review` then `bmad-code-review` → commit at green (one commit per green story) → **re-run the suite at this cycle's scope on the committed HEAD (a story only advances off a full-scope sweep)** and print it, because a story's new files are untracked until the commit, so a tracked-files conformance gate can only red once they land; a red here means the story is not done and must be remediated and re-committed before it advances. The loop is wrapped in a single `/goal` whose condition encodes the per-story Definition-of-Done and carries the literal "…or stop after N turns" escape clause. The printed evidence keeps the run judgeable mid-flight, but **passing the `/goal` condition is not completion**; the authoritative verdict is Stage 5. As the spine advances it overwrites a `run-status.json` heartbeat for pollers. See [`references/execute.md`](https://github.com/armelhbobdad/bmad-module-ultracode-goal/blob/main/skills/ultracode-goal/references/execute.md).
|
|
82
82
|
|
|
83
83
|
### Stage 5: Gate
|
|
84
84
|
|
|
85
|
-
Decide whether a story (or, after the last story, the Epic) advances, by a deterministic artifact read. In production, the skill first backfills the evidence in order: `bmad-testarch-automate`, `bmad-testarch-trace` (which writes the gate decision), `bmad-testarch-nfr`. Then it runs `gate_eval.py
|
|
85
|
+
Decide whether a story (or, after the last story, the Epic) advances, by a deterministic artifact read. In production, the skill first backfills the evidence in order: `bmad-testarch-automate`, `bmad-testarch-trace` (which writes the gate decision), `bmad-testarch-nfr`. Assessors that run or time anything measure a worktree of the commit under assessment, never the shared working tree. Then it runs `gate_eval.py`; a mid-loop re-gate may declare a delta profile (only the previously failed dimension re-runs in full) whose verdict is capped at reloop, so only the full instrument ever advances a story. The script reads TEA's `gate-decision.json` and returns a verdict the skill executes: `advance` (move to the next story), `defer` (append non-blocking items to the ledger and advance anyway), `reloop` (generalize each finding to its defect class against the Epic's class ledger, then run `bmad-correct-course` and re-run the story within the remaining budget), or `escalate` (stop). The invariant: **a P0/critical FAIL never defers**; it re-loops within budget or escalates. See the [gate model](./gate-model.md) and [`references/gate.md`](https://github.com/armelhbobdad/bmad-module-ultracode-goal/blob/main/skills/ultracode-goal/references/gate.md).
|
|
86
86
|
|
|
87
87
|
This is how the verdict is read deterministically; the conductor never grades the work itself, it runs the script and routes on what comes back:
|
|
88
88
|
|
|
@@ -170,4 +170,4 @@ case "$status" in
|
|
|
170
170
|
esac
|
|
171
171
|
```
|
|
172
172
|
|
|
173
|
-
The file is overwrite-in-place, and a headless run additionally clears any prior copy at startup, so a second run against the same artifacts path never leaves the first run's result readable once it begins.
|
|
173
|
+
The file is overwrite-in-place, and a headless run additionally clears any prior copy at startup, so a second run against the same artifacts path never leaves the first run's result readable once it begins. An attended run writes no file at all, and does not clear one either, since an operator reads the outcome from the conversation and the report and may still be consulting a previous result.
|
package/docs/index.md
CHANGED
|
@@ -55,7 +55,6 @@ The docs split into three buckets: **Why** (start here), **Try** (do stuff), and
|
|
|
55
55
|
|
|
56
56
|
- [Getting Started](./getting-started.md): prerequisites, install, the flags, and your first autonomous run.
|
|
57
57
|
- [How It Works](./how-it-works.md): the six stages, their routing conditions, and the headless emit shape.
|
|
58
|
-
- [Parallel Mode](./parallel-mode.md): the experimental worktree fan-out and its known limits.
|
|
59
58
|
|
|
60
59
|
**Reference**
|
|
61
60
|
|
package/docs/operating-tips.md
CHANGED
|
@@ -5,7 +5,7 @@ description: "Field notes from driving a real 22-story epic: giving Bash room fo
|
|
|
5
5
|
|
|
6
6
|
Everything here was learned by driving one real epic (22 stories, 12 landed across a single day, four of them split on contact, three of those consecutively) rather than from reading the scripts. Where a tip contradicts an intuition, the measurement is given. The numbers are one run on one codebase: treat them as something to measure your own against, not as properties of the tool.
|
|
7
7
|
|
|
8
|
-
For the designed behavior of the run's own failure modes (preflight, the gate, hooks, budget, resume
|
|
8
|
+
For the designed behavior of the run's own failure modes (preflight, the gate, hooks, budget, resume) see [troubleshooting](./troubleshooting.md). The driver's stop reasons are documented here and nowhere else in these docs; the full set is `drive_epic.py`'s `STOP_*` constants.
|
|
9
9
|
|
|
10
10
|
## Running the loop
|
|
11
11
|
|
|
@@ -150,7 +150,9 @@ The gate is a real verdict and worth trusting. The prose around it is not eviden
|
|
|
150
150
|
|
|
151
151
|
**Prefer executed mutation over a modeled mutant.** A hand-written mutant that differs from the real pre-fix code proves nothing about the real branch. Where a story claims a mutation-proof, re-run one yourself against the shipped code.
|
|
152
152
|
|
|
153
|
-
**
|
|
153
|
+
**Use the shipped runner rather than hand-rolling the harness.** `uv run <skill-root>/scripts/mutate_check.py --table <rows.json>` builds the properties every hand-rolled harness eventually lost in as refusals: a green-baseline precheck, per-row anchor uniqueness (a missing anchor is reported as STALE, the formatter-reflow signature, never silently skipped), an attributable red, a byte-identical restore, and a generated `mutation-ledger-<story_id>.md` that leads with GREEN survivors. The two tips below are what the runner automates; they remain worth knowing for reading its output and for the rare harness it cannot drive.
|
|
154
|
+
|
|
155
|
+
**Make any hand-rolled harness hard-error on a missing anchor.** Observed: a harness silently skipped its mutation twice when a refactor moved the anchor, and reported the suite's ordinary green as a passing twin.
|
|
154
156
|
|
|
155
157
|
**Back files up with `cp` and restore from the backup.** Never `git checkout -- <path>` or `git restore <path>` to undo a mutation: both restore from the *index*, and an intent-to-add entry (`git add -N`) holds the empty blob, so they truncate the file to zero bytes and exit 0 (measured on git 2.47). For a file that has a committed version, `git checkout HEAD -- <path>` is safe. For a file the story just created, nothing git offers is: `git checkout HEAD --` refuses, and `git restore --source=HEAD --` deletes the file with exit 0. The `cp` backup is the only restore that always works.
|
|
156
158
|
|
package/docs/troubleshooting.md
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
---
|
|
2
2
|
title: Troubleshooting
|
|
3
|
-
description: Maps the real failure modes of an autonomous Epic run (preflight refusals, gate escalations, silent hooks, budget overruns,
|
|
3
|
+
description: Maps the real failure modes of an autonomous Epic run (preflight refusals, gate escalations, silent hooks, budget overruns, and resume) to what the run does and what you do.
|
|
4
4
|
---
|
|
5
5
|
|
|
6
6
|
Real failure modes, sourced from the skill's stage files and scripts, with what the run does about each and what you do. For the design behind these behaviors see [how it works](./how-it-works.md), [the gate model](./gate-model.md), and [architecture](./architecture.md).
|
|
@@ -23,9 +23,9 @@ flowchart TD
|
|
|
23
23
|
R -->|"yes"| RES["See: Resume after an interruption"]
|
|
24
24
|
R -->|"no"| D{"A drive stopped and you cannot tell why"}
|
|
25
25
|
D -->|"yes"| OPS["See: operating tips, the driver's stop reasons"]
|
|
26
|
-
D -->|"no"|
|
|
26
|
+
D -->|"no"| LOG["Read the tail of .decision-log.md"]
|
|
27
27
|
classDef accent fill:#6366F1,stroke:#4F46E5,color:#fff
|
|
28
|
-
class PRE,GATE,HOOK,BUD,RES,OPS,
|
|
28
|
+
class PRE,GATE,HOOK,BUD,RES,OPS,LOG accent
|
|
29
29
|
```
|
|
30
30
|
|
|
31
31
|
## Preflight can't reach budget-zero
|
|
@@ -53,6 +53,10 @@ The decision log carries the full blocker list with what each needs to clear. Re
|
|
|
53
53
|
|
|
54
54
|
Note this is fail-closed on purpose: a missing or unreadable gate artifact escalates rather than being assumed green. The slim file's *absence alone* is not the problem: the script falls back to the summary, and that fallback is explicitly not a failure. See the [gate model](./gate-model.md) for how the artifact resolves into a `gate_status` and the full verdict mapping.
|
|
55
55
|
|
|
56
|
+
## Gate re-loops on a sweep-scope or delta cap
|
|
57
|
+
|
|
58
|
+
A per-story gate can return `reloop` with a `PASS` gate status when a cap fired rather than a finding: the `reasons` name either the sweep-scope cap (the `.tests-ran` marker says `scope=scoped`, or the marker/`scope=` line is missing) or the delta-profile cap (`--cycle-profile delta` was declared). Neither is an error; both mean "not yet, and here is why": a story only advances off a full-scope sweep judged by the full gate instrument. The remedy is the cap-only re-loop, which skips the generalize ceremony entirely: re-run the full three-axis sweep, refresh the marker with `scope=full`, and re-run the gate without `--cycle-profile`. See the cap sections in the [gate model](./gate-model.md).
|
|
59
|
+
|
|
56
60
|
## Hooks not firing
|
|
57
61
|
|
|
58
62
|
**Symptom.** A commit lands on a protected branch, or a commit lands before a story's tests ran: the invariants the PreToolUse hook should enforce did not block.
|
|
@@ -77,6 +81,6 @@ Note this is fail-closed on purpose: a missing or unreadable gate artifact escal
|
|
|
77
81
|
|
|
78
82
|
**What happens.** The run's `.decision-log.md` is canonical memory and recovers full state regardless of compaction. On resume the skill surfaces the existing log with its last session date and offers to resume. Execute re-enters at the **first story whose last logged gate verdict is not `advance`**; already-advanced stories are not re-run. The Epic branch, hooks, and allowlist are **re-asserted, not rebuilt**, before continuing. You do not need to reconstruct state by hand. Point the skill at the same Epic and accept the resume offer.
|
|
79
83
|
|
|
80
|
-
## `--parallel`
|
|
84
|
+
## The retired `--parallel` flag
|
|
81
85
|
|
|
82
|
-
`--parallel`
|
|
86
|
+
`--parallel` (the experimental worktree fan-out) is retired. The flag is still accepted so an old invocation does not error: the run logs one `.decision-log.md` note that it was accepted and ignored, then executes the sequential spine. The Epic still ships; it ships sequentially. `parallel_max_concurrency` in `customize.toml` is likewise deprecated and no-op.
|
|
@@ -11,7 +11,7 @@ Three intuitive shortcuts all push an unattended Epic toward false completion, a
|
|
|
11
11
|
|
|
12
12
|
**The evaluator only sees the transcript.** Claude Code's `/goal` mode drives a loop until a success condition is met, then asks an evaluator to confirm. But that evaluator reads the transcript; it cannot open a file on disk. It cannot read TEA's `gate-decision.json`. So if you let the `/goal` condition be the final word on "is this story done," you have asked the model to grade its own homework from its own notes. The model cannot be the judge of its own completion: the thing that decides "done" has to be something it cannot author.
|
|
13
13
|
|
|
14
|
-
**`/rewind` checkpoints miss Bash changes.** The obvious undo for a runaway agent is `/rewind`. But its checkpoints do not capture changes made through Bash, and an autonomous Epic run is mostly Bash: test commands, lint, build, and the git commits themselves. Rolling back to a checkpoint leaves the working tree's Bash-driven mutations in place. The real undo for this kind of run is git: an Epic branch off a protected branch, one commit per green story
|
|
14
|
+
**`/rewind` checkpoints miss Bash changes.** The obvious undo for a runaway agent is `/rewind`. But its checkpoints do not capture changes made through Bash, and an autonomous Epic run is mostly Bash: test commands, lint, build, and the git commits themselves. Rolling back to a checkpoint leaves the working tree's Bash-driven mutations in place. The real undo for this kind of run is git: an Epic branch off a protected branch, one commit per green story. See the [gate model](./gate-model.md) and [architecture](./architecture.md) for how this is wired.
|
|
15
15
|
|
|
16
16
|
**Memory is context, not enforcement.** It is tempting to encode the run's invariants ("never commit on `main`", "never commit before tests pass") into Auto Memory or a CLAUDE.md rule and trust the model to honor them. But memory is context the model may or may not weigh; it does not *block* a `git commit`. An invariant that lives only in memory is a suggestion. An invariant that must hold has to live somewhere the model cannot talk its way past.
|
|
17
17
|
|
package/package.json
CHANGED
|
@@ -1,7 +1,7 @@
|
|
|
1
1
|
{
|
|
2
2
|
"$schema": "https://json.schemastore.org/package.json",
|
|
3
3
|
"name": "bmad-module-ultracode-goal",
|
|
4
|
-
"version": "2.
|
|
4
|
+
"version": "2.2.0",
|
|
5
5
|
"description": "BMAD module — Run a BMAD Epic autonomously to a machine-checked, TEA-gated Definition-of-Done.",
|
|
6
6
|
"keywords": [
|
|
7
7
|
"bmad",
|
|
@@ -41,12 +41,12 @@
|
|
|
41
41
|
"lint:fix": "eslint . --ext .js,.cjs,.mjs,.yaml --fix",
|
|
42
42
|
"lint:md": "markdownlint-cli2 \"**/*.md\"",
|
|
43
43
|
"prepare": "husky || exit 0",
|
|
44
|
-
"quality": "
|
|
45
|
-
"test": "npm run
|
|
44
|
+
"quality": "run-p --print-label --aggregate-output format:check lint lint:md test:install test:cli test:python test:rehype test:docs-links-tool validate:skills validate:refs validate:fixtures validate:docs-links",
|
|
45
|
+
"test": "npm run quality",
|
|
46
46
|
"test:cli": "node test/test-cli-integration.js",
|
|
47
47
|
"test:docs-links-tool": "node test/test-validate-docs-links.js",
|
|
48
48
|
"test:install": "node test/test-installation-components.js",
|
|
49
|
-
"test:python": "uv run --with pytest pytest skills/ultracode-goal/scripts/tests/ -
|
|
49
|
+
"test:python": "uv run --with pytest==9.1.1 --with pytest-xdist==3.8.0 pytest skills/ultracode-goal/scripts/tests/ -n auto",
|
|
50
50
|
"test:rehype": "node test/test-rehype-markdown-links.js",
|
|
51
51
|
"ucg:install": "node tools/cli/ucg-cli.js install",
|
|
52
52
|
"ucg:status": "node tools/cli/ucg-cli.js status",
|
|
@@ -93,6 +93,7 @@
|
|
|
93
93
|
"husky": "^9.1.7",
|
|
94
94
|
"lint-staged": "^16.1.1",
|
|
95
95
|
"markdownlint-cli2": "^0.19.1",
|
|
96
|
+
"npm-run-all2": "^8.0.4",
|
|
96
97
|
"prettier": "^3.7.4",
|
|
97
98
|
"prettier-plugin-packagejson": "^2.5.19",
|
|
98
99
|
"unist-util-visit": "5.1.0",
|