@pmelab/gtd 1.6.1 → 1.8.0

package/README.md

@@ -17,7 +17,7 @@ merge-base with the default branch (whole-history fallback when there is no
 default branch, when HEAD equals the merge-base, or when there is no merge-base
 — i.e. budgets engage on the default branch too) plus the working tree, turns
 them into a `COMMIT[]` + single terminal `RESOLVE` event stream, and folds them
-through the machine. The fold lands on exactly **one** of 17 states, which
+through the machine. The fold lands on exactly **one** of 19 states, which
 selects the prompt. A single run resolves to a single state.
 
 `resolve()` returns that state plus an optional **`EdgeAction`** (a commit,
@@ -138,6 +138,11 @@ across runs:
 - **ERRORS.md** — the escalation gate: persistent test-failure output that stops
   the loop for a human (written instead of FEEDBACK.md once the fix-attempt cap
   is hit; never auto-consumed).
+- **HEALTH.md** — idle health-check failure output: written when `testCommand`
+  fails on a bare idle tree (no `.gtd`, no REVIEW.md, no FEEDBACK.md). Carries
+  the failure while the dedicated health-fix loop repairs it. Analogous to
+  FEEDBACK.md but lives on the default-branch idle path rather than inside a
+  build process. Never written while any other steering file is present.
 - **.gtd/** — ordered work packages (one numbered directory each) of
   parallelizable subtasks.
 
@@ -158,9 +163,11 @@ Every run derives the state in **three layers**:
 1. **Transport pre-pass** — if HEAD is `gtd: transport`, short-circuit to the
    Transport state (mixed-reset) before anything else is considered.
 2. **Steering-file precedence** — the presence of `ERRORS.md` / `FEEDBACK.md` /
-   `.gtd/` / `REVIEW.md` drives the decision, authoritative regardless of HEAD.
+   `HEALTH.md` / `.gtd/` / `REVIEW.md` drives the decision, authoritative
+   regardless of HEAD.
 3. **HEAD bucket** — with no steering files in play, the last-commit bucket plus
-   working-tree cleanliness selects New Feature / Grilling / Clean / Idle.
+   working-tree cleanliness selects New Feature / Grilling / Clean / Health
+   check / Idle.
 
 Within layers 2 and 3 the HEAD subject further disambiguates states the
 filesystem alone cannot separate (e.g. inside the `.gtd/` lifecycle, HEAD
@@ -173,8 +180,8 @@ The complete set:
 
 `gtd: new task` · `gtd: grilling` · `gtd: grilled` · `gtd: planning` ·
 `gtd: building` · `gtd: errors` · `gtd: feedback` · `gtd: fixing` ·
-`gtd: package done` · `gtd: awaiting review` · `gtd: done` — plus the hand-made
-`gtd: transport` (see below).
+`gtd: package done` · `gtd: awaiting review` · `gtd: done` · `gtd: health-check`
+· `gtd: health-fix` — plus the hand-made `gtd: transport` (see below).
 
 The last commit subject is bucketed two ways:
 
@@ -189,24 +196,28 @@ The last commit subject is bucketed two ways:
 1. **ERRORS.md present** → Escalate (human gate; STOP).
 2. **FEEDBACK.md present** → non-empty → Fixing; **empty** (clean agentic review
    = approval) → Close package.
-3. **.gtd present** → build lifecycle, routed by tree + HEAD:
+3. **HEALTH.md present** → Health Fixing (idle health-fix loop; no `.gtd`,
+   REVIEW.md, or FEEDBACK.md).
+4. **.gtd present** → build lifecycle, routed by tree + HEAD:
    - `.gtd` modified (package files added/edited) → Planning
    - code changes present → Testing
    - clean tree + HEAD `gtd: fixing` (no-op fixer) → Testing (re-test)
    - else clean, by HEAD: `gtd: planning` / `gtd: package done` → Building;
      `gtd: building` → Agentic Review (or Close package, if force-approved)
-4. **REVIEW.md present** → review lifecycle, routed by committed-ness + tree:
+5. **REVIEW.md present** → review lifecycle, routed by committed-ness + tree:
    committed + clean → Done; committed + checkbox-only edits (only `[ ]`↔`[x]`
    flips in REVIEW.md) → Done; committed + non-checkbox pending edits → Accept
    Review; uncommitted → Await Review (commits REVIEW.md and auto-advances to
-   Done). 4a. **HEAD `gtd: done` + `squash` enabled + squash base present + no
+   Done). 5a. **HEAD `gtd: done` + `squash` enabled + squash base present + no
    unrelated code dirty** (a lone untracked `SQUASH_MSG.md` is allowed) →
    Squashing; unrelated code dirty → New Feature.
-5. **Boundary HEAD + pending changes** (and no `.gtd`/REVIEW/FEEDBACK), or HEAD
+6. **Boundary HEAD + pending changes** (and no `.gtd`/REVIEW/FEEDBACK), or HEAD
    `gtd: new task` + clean tree (regenerate a lost seed) → New Feature.
-6. **TODO.md present** → Grilling / Grilled.
-7. **Boundary or `gtd: package done` HEAD + clean tree** → Clean (review the
-   work) or Idle (nothing to review).
+7. **TODO.md present** → Grilling / Grilled.
+8. **Boundary or `gtd: package done` HEAD + clean tree** → Clean (review the
+   work), **Health check** (run `testCommand` when there is nothing to review —
+   on any branch outside a process), or Idle (health check green, nothing to
+   do).
 
 Anything matching no rule is corruption — `gtd` **hard-errors** rather than
 guess.
@@ -221,7 +232,10 @@ flowchart TD
     P1 -->|no| P2{"FEEDBACK.md?"}
     P2 -->|"empty = approval"| Close["Close package — rm pkg dir, gtd: package done"]:::edge
     P2 -->|"non-empty"| Fixing["Fixing — rm FEEDBACK, fixer agent"]:::agent
-    P2 -->|absent| P3{".gtd/?"}
+    P2 -->|absent| P2b{"HEALTH.md?"}
+    P2b -->|"present"| HealthFix["Health Fixing — rm HEALTH.md, gtd: health-fix, fixer agent"]:::agent
+    HealthFix -.->|"re-resolve"| HealthCheck
+    P2b -->|absent| P3{".gtd/?"}
     P3 -->|"modified"| Planning["Planning — gtd: planning"]:::agent
     P3 -->|"code dirty / resume / no-op fixer"| Testing["Testing — gtd: building, run tests"]:::edge
     P3 -->|"clean, HEAD planning/package done"| Building["Building — pick & build one package"]:::agent
@@ -234,7 +248,7 @@ flowchart TD
     P4 -->|absent| P5{"boundary HEAD + dirty,<br/>or gtd: new task + clean?"}
     Done -->|"squash enabled"| Squashing["Squashing — reset --soft base, squash commit"]:::agent
     Done -->|"squash disabled"| Idle
-    Squashing --> Idle["Idle — nothing to do (STOP; review on next manual gtd run)"]:::gate
+    Squashing --> Idle["Idle — nothing to do (STOP)"]:::gate
     P5 -->|yes| NewFeature["New Feature — gtd: new task, revert, seed TODO"]:::edge
     P5 -->|no| P6{"TODO.md?"}
     P6 -->|"open markers"| GrillStop["Grilling — gtd: grilling, STOP for answers"]:::gate
@@ -242,7 +256,13 @@ flowchart TD
     P6 -->|"clean, no markers"| Grilled["Grilled — gtd: grilled, decompose"]:::agent
     P6 -->|absent| P7{"clean + boundary/package-done HEAD,<br/>reviewable diff?"}
     P7 -->|yes| CleanState["Clean — write REVIEW.md"]:::agent
-    P7 -->|no| Idle
+    P7 -->|"no (idle, outside a process)"| HealthCheck["Health check — run testCommand"]:::edge
+    HealthCheck -->|"green, no health-fix"| Idle
+    HealthCheck -->|"green + ≥1 health-fix, squash enabled"| Squashing
+    HealthCheck -->|"red, below cap"| HealthMd["write HEALTH.md, gtd: health-check"]:::edge
+    HealthMd -.->|"re-resolve"| HealthFix
+    HealthCheck -->|"red, at cap"| ErrorsMd["write ERRORS.md, gtd: health-check"]:::edge
+    ErrorsMd -.->|"re-resolve"| Escalate
     classDef edge fill:#1a4a6b,color:#fff
     classDef agent fill:#2d6a4f,color:#fff
     classDef gate fill:#7a3b1d,color:#fff
@@ -263,6 +283,10 @@ guessing:
 - FEEDBACK.md without .gtd
 - ERRORS.md + FEEDBACK.md
 - ERRORS.md without .gtd
+- HEALTH.md + .gtd (health check only runs from a bare idle tree)
+- HEALTH.md + REVIEW.md (same)
+- HEALTH.md + FEEDBACK.md (same)
+- HEALTH.md + ERRORS.md (escalation wins; HEALTH.md must not coexist)
 
 Legal coexistence: `.gtd` + TODO.md (plan kept alongside packages during
 **Planning** only — TODO.md is deleted at the first Building turn);
@@ -290,7 +314,7 @@ back into the working tree uncommitted, and re-derives state from scratch. If
 the transport commit is the repository's root commit (no parent), `gtd` fails
 immediately with a clear error instead of looping.
 
-## The 17 states
+## The 19 states
 
 Each state has a **condition** (when it wins), a deterministic **action**, the
 **commit(s)** it produces, and where it **advances**. States marked
@@ -298,34 +322,36 @@ Each state has a **condition** (when it wins), a deterministic **action**, the
 human; **edge-only** states render no prompt at all — the driver performs their
 action and re-resolves silently.
 
-| State              | Kind                             | Wins when                                                                                                                                                                   | Action & commit                                                                                                                                                                                                                                                                                                        | Advances to                                                  |
-| ------------------ | -------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------ |
-| **Transport**      | edge-only, auto                  | HEAD `gtd: transport` (hand-made handoff commit)                                                                                                                            | mixed-reset HEAD (`git reset HEAD~1`), keep work in tree; **no commit**                                                                                                                                                                                                                                                | re-derive from the restored tree                             |
-| **Escalate**       | STOP                             | ERRORS.md present                                                                                                                                                           | none                                                                                                                                                                                                                                                                                                                   | held until the human deletes ERRORS.md                       |
-| **Fixing**         | agent, auto                      | non-empty FEEDBACK.md present                                                                                                                                               | inline FEEDBACK into the prompt, remove FEEDBACK.md; commit its removal `gtd: fixing` (FEEDBACK was committed by Testing) or `gtd: feedback` (uncommitted, written by Agentic Review)                                                                                                                                  | fixer edits → Testing                                        |
-| **Close package**  | edge-only, auto                  | empty FEEDBACK.md present (clean review); also reached from Agentic Review force-approve                                                                                    | rm FEEDBACK.md, rm the first (finished) package dir (+ the now-empty `.gtd/`); commit `gtd: package done`                                                                                                                                                                                                              | more packages → Building; `.gtd` gone → Clean                |
-| **Planning**       | agent, auto                      | `.gtd` present **and modified**; HEAD `gtd: grilled` or `gtd: planning`                                                                                                     | commit the `.gtd/` changes `gtd: planning`                                                                                                                                                                                                                                                                             | continue decomposing, else → Building                        |
-| **Testing**        | edge-only, auto                  | `.gtd` present, no FEEDBACK/ERRORS, and a reason to test: code changes, a pending ERRORS.md deletion (human resume), or a clean tree under HEAD `gtd: fixing` (no-op fixer) | commit pending tree `gtd: building`, run `testCommand`; green → proceed; red → write FEEDBACK (below cap) or ERRORS (at cap), commit `gtd: errors`; if captured output is empty/whitespace, a sentinel string is written so the file is never empty (empty FEEDBACK remains reserved for agentic-review approval)      | green → Agentic Review; FEEDBACK → Fixing; ERRORS → Escalate |
-| **Building**       | agent, auto                      | `.gtd` present and clean, clean tree; HEAD `gtd: planning` or `gtd: package done`                                                                                           | if HEAD `gtd: planning` and TODO.md present, delete TODO.md and commit (prefix unchanged, fires once); select the first package, inline its tasks; agent leaves work **uncommitted**                                                                                                                                   | Testing                                                      |
-| **Agentic Review** | agent, auto                      | `.gtd` present and clean, clean tree; HEAD `gtd: building`                                                                                                                  | reviewer writes FEEDBACK.md (empty = approval), uncommitted — **unless** force-approved (kill-switch off or review-fix threshold hit), which routes straight to Close package                                                                                                                                          | empty FEEDBACK → Close package; non-empty → Fixing           |
-| **Done**           | edge-only, auto                  | REVIEW.md committed + clean tree, **or** committed + checkbox-only edits (only `- [ ]`→`- [x]` flips in REVIEW.md = approval)                                               | rm REVIEW.md, commit `gtd: done`                                                                                                                                                                                                                                                                                       | Squashing (if enabled) or Idle                               |
-| **Squashing**      | agent, auto                      | no steering files, HEAD `gtd: done`, `squash` enabled, squash base present, no unrelated code dirty (a lone untracked `SQUASH_MSG.md` is allowed)                           | agent authors a conventional-commits message from the full `<base>..HEAD` diff, then runs `git reset --soft <base>` + `git commit` — collapses all intermediate `gtd: *` commits (including any interleaved non-gtd commits) into one; **gtd then STOPs** — post-squash review fires only on the next manual `gtd` run | Idle (STOP)                                                  |
-| **Accept Review**  | edge-only, auto                  | REVIEW.md committed + pending **non-checkbox** edits (human annotated REVIEW.md with comments / edited code)                                                                | seed TODO.md from the changeset, `git checkout` to discard the code edits, rm REVIEW.md; **all uncommitted**                                                                                                                                                                                                           | Grilling                                                     |
-| **Await Review**   | edge-only, auto                  | REVIEW.md present and **uncommitted** (freshly written by Clean)                                                                                                            | commit REVIEW.md `gtd: awaiting review`                                                                                                                                                                                                                                                                                | Done (auto, same run)                                        |
-| **New Feature**    | edge-only, auto                  | boundary HEAD + pending changes (code and/or a new uncommitted TODO.md), **or** HEAD `gtd: new task` + clean tree (lost-seed regen)                                         | commit the raw input verbatim `gtd: new task` (unless already there), `git revert --no-commit` it back to a clean baseline, seed TODO.md from that diff — revert + seed left **uncommitted**                                                                                                                           | Grilling                                                     |
-| **Grilling**       | agent (iterate) / STOP (answers) | TODO.md present, not New Feature                                                                                                                                            | commit pending edits `gtd: grilling`. Open-question markers present → STOP for the human to answer inline; no markers but dirty → grilling agent iterates                                                                                                                                                              | converge (no markers, clean tree) → Grilled                  |
-| **Grilled**        | agent, auto                      | TODO.md present, no markers, clean tree                                                                                                                                     | commit pending `gtd: grilled`                                                                                                                                                                                                                                                                                          | decompose into `.gtd/` → Planning                            |
-| **Clean**          | agent                            | no steering files, clean tree, boundary or `gtd: package done` HEAD, and the review base yields a **non-empty** diff                                                        | compute the review base (four rules — see below); agent writes REVIEW.md **uncommitted** with `# Review: <short-hash>` heading, `<!-- base: <full-hash> -->` marker, and per-hunk `- [ ]` checkboxes (ticking them signals approval → Done)                                                                            | Await Review                                                 |
-| **Idle**           | STOP                             | no steering files, clean tree, and nothing to review (HEAD `gtd: done` with `squash` disabled or after Squashing, or no reviewable diff)                                    | none                                                                                                                                                                                                                                                                                                                   | —                                                            |
+| State              | Kind                             | Wins when                                                                                                                                                                                         | Action & commit                                                                                                                                                                                                                                                                                                        | Advances to                                                                     |
+| ------------------ | -------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------- |
+| **Transport**      | edge-only, auto                  | HEAD `gtd: transport` (hand-made handoff commit)                                                                                                                                                  | mixed-reset HEAD (`git reset HEAD~1`), keep work in tree; **no commit**                                                                                                                                                                                                                                                | re-derive from the restored tree                                                |
+| **Escalate**       | STOP                             | ERRORS.md present                                                                                                                                                                                 | none                                                                                                                                                                                                                                                                                                                   | held until the human deletes ERRORS.md                                          |
+| **Fixing**         | agent, auto                      | non-empty FEEDBACK.md present                                                                                                                                                                     | inline FEEDBACK into the prompt, remove FEEDBACK.md; commit its removal `gtd: fixing` (FEEDBACK was committed by Testing) or `gtd: feedback` (uncommitted, written by Agentic Review)                                                                                                                                  | fixer edits → Testing                                                           |
+| **Health Fixing**  | agent, auto                      | HEALTH.md present (no `.gtd`, REVIEW.md, or FEEDBACK.md)                                                                                                                                          | read HEALTH.md into the prompt, commit its removal `gtd: health-fix`                                                                                                                                                                                                                                                   | fixer edits → Health check                                                      |
+| **Close package**  | edge-only, auto                  | empty FEEDBACK.md present (clean review); also reached from Agentic Review force-approve                                                                                                          | rm FEEDBACK.md, rm the first (finished) package dir (+ the now-empty `.gtd/`); commit `gtd: package done`                                                                                                                                                                                                              | more packages → Building; `.gtd` gone → Clean                                   |
+| **Planning**       | agent, auto                      | `.gtd` present **and modified**; HEAD `gtd: grilled` or `gtd: planning`                                                                                                                           | commit the `.gtd/` changes `gtd: planning`                                                                                                                                                                                                                                                                             | continue decomposing, else → Building                                           |
+| **Testing**        | edge-only, auto                  | `.gtd` present, no FEEDBACK/ERRORS, and a reason to test: code changes, a pending ERRORS.md deletion (human resume), or a clean tree under HEAD `gtd: fixing` (no-op fixer)                       | commit pending tree `gtd: building`, run `testCommand`; green → proceed; red → write FEEDBACK (below cap) or ERRORS (at cap), commit `gtd: errors`; if captured output is empty/whitespace, a sentinel string is written so the file is never empty (empty FEEDBACK remains reserved for agentic-review approval)      | green → Agentic Review; FEEDBACK → Fixing; ERRORS → Escalate                    |
+| **Building**       | agent, auto                      | `.gtd` present and clean, clean tree; HEAD `gtd: planning` or `gtd: package done`                                                                                                                 | if HEAD `gtd: planning` and TODO.md present, delete TODO.md and commit (prefix unchanged, fires once); select the first package, inline its tasks; agent leaves work **uncommitted**                                                                                                                                   | Testing                                                                         |
+| **Agentic Review** | agent, auto                      | `.gtd` present and clean, clean tree; HEAD `gtd: building`                                                                                                                                        | reviewer writes FEEDBACK.md (empty = approval), uncommitted — **unless** force-approved (kill-switch off or review-fix threshold hit), which routes straight to Close package                                                                                                                                          | empty FEEDBACK → Close package; non-empty → Fixing                              |
+| **Done**           | edge-only, auto                  | REVIEW.md committed + clean tree, **or** committed + checkbox-only edits (only `- [ ]`→`- [x]` flips in REVIEW.md = approval)                                                                     | rm REVIEW.md, commit `gtd: done`                                                                                                                                                                                                                                                                                       | Squashing (if enabled) or Idle                                                  |
+| **Squashing**      | agent, auto                      | no steering files, HEAD `gtd: done` or green Health check with ≥1 `gtd: health-fix`, `squash` enabled, squash base present, no unrelated code dirty (a lone untracked `SQUASH_MSG.md` is allowed) | agent authors a conventional-commits message from the full `<base>..HEAD` diff, then runs `git reset --soft <base>` + `git commit` — collapses all intermediate `gtd: *` commits (including any interleaved non-gtd commits) into one; **gtd then STOPs** — post-squash review fires only on the next manual `gtd` run | Idle (STOP)                                                                     |
+| **Accept Review**  | edge-only, auto                  | REVIEW.md committed + pending **non-checkbox** edits (human annotated REVIEW.md with comments / edited code)                                                                                      | seed TODO.md from the changeset, `git checkout` to discard the code edits, rm REVIEW.md; **all uncommitted**                                                                                                                                                                                                           | Grilling                                                                        |
+| **Await Review**   | edge-only, auto                  | REVIEW.md present and **uncommitted** (freshly written by Clean)                                                                                                                                  | commit REVIEW.md `gtd: awaiting review`                                                                                                                                                                                                                                                                                | Done (auto, same run)                                                           |
+| **New Feature**    | edge-only, auto                  | boundary HEAD + pending changes (code and/or a new uncommitted TODO.md), **or** HEAD `gtd: new task` + clean tree (lost-seed regen)                                                               | commit the raw input verbatim `gtd: new task` (unless already there), `git revert --no-commit` it back to a clean baseline, seed TODO.md from that diff — revert + seed left **uncommitted**                                                                                                                           | Grilling                                                                        |
+| **Grilling**       | agent (iterate) / STOP (answers) | TODO.md present, not New Feature                                                                                                                                                                  | commit pending edits `gtd: grilling`. Open-question markers present → STOP for the human to answer inline; no markers but dirty → grilling agent iterates                                                                                                                                                              | converge (no markers, clean tree) → Grilled                                     |
+| **Grilled**        | agent, auto                      | TODO.md present, no markers, clean tree                                                                                                                                                           | commit pending `gtd: grilled`                                                                                                                                                                                                                                                                                          | decompose into `.gtd/` → Planning                                               |
+| **Clean**          | agent                            | no steering files, clean tree, boundary or `gtd: package done` HEAD, and the review base yields a **non-empty** diff                                                                              | compute the review base (three rules — see below); agent writes REVIEW.md **uncommitted** with `# Review: <short-hash>` heading, `<!-- base: <full-hash> -->` marker, and per-hunk `- [ ]` checkboxes (ticking them signals approval → Done)                                                                           | Await Review                                                                    |
+| **Health check**   | edge-only, auto                  | no steering files, clean tree, outside a process with no reviewable diff (any branch) — the `!reviewable` case from rule 8                                                                        | run `testCommand`: green + no prior `gtd: health-fix` → Idle (no commit); red below `fixAttemptCap` → write HEALTH.md, commit `gtd: health-check` → Health Fixing; red at cap → write ERRORS.md, commit `gtd: health-check` → Escalate; green + ≥1 `gtd: health-fix` → Squashing (if `squash`) or Idle                 | green → Idle or Squashing; red below cap → Health Fixing; red at cap → Escalate |
+| **Idle**           | STOP                             | no steering files, clean tree, health check passed with no prior `gtd: health-fix` commits, and nothing to review                                                                                 | none (no commit — the health check edge terminates the driver loop directly)                                                                                                                                                                                                                                           | —                                                                               |
 
 Every prompt also embeds the current `git diff HEAD` (untracked files included)
 inline, plus the last commit subject and working-tree status, so the agent has
 full context.
 
-### Review base — four rules
+### Review base — three rules
 
 The review base (the commit whose diff to HEAD forms the REVIEW.md) is chosen by
-four rules evaluated in priority order:
+three rules evaluated in priority order:
 
 1. **Within a process, first review** — a `gtd: grilling` commit exists after
    the last `gtd: done` (or task start), but no `gtd: awaiting review` yet →
@@ -334,18 +360,16 @@ four rules evaluated in priority order:
 2. **Within a process, incremental** — `gtd: awaiting review` also present in
    the current cycle (takes precedence over rule 1) → base = last
    `gtd: awaiting review`; `refDiff` spans only the post-review changes.
-3. **Outside a process, feature branch** — no `gtd: grilling` after the last
-   `gtd: done`, and HEAD is not on the default branch → base = merge-base with
-   the default branch; `refDiff` spans the whole branch.
-4. **Outside a process, default branch** — no process active and HEAD is on the
-   default branch → skip review; `reviewBase`/`refDiff` unset → Idle.
+3. **Outside a process (any branch)** — no `gtd: grilling` after the last
+   `gtd: done` → skip review; `reviewBase`/`refDiff` unset → Idle (the health
+   check runs instead).
 
 In all cases, if the diff from the chosen base to HEAD is empty,
 `reviewBase`/`refDiff` are left unset and the machine settles in Idle.
 
 ## The fix loops & counter folds
 
-Two derived counters drive the budgeted loops. Both are **folded in the
+Three derived counters drive the budgeted loops. All are **folded in the
 machine** from flags on the `COMMIT[]` stream — never recomputed at the edge:
 
 - **`testFixCount`** — `gtd: errors` commits (test-fix attempts) since the
@@ -355,6 +379,9 @@ machine** from flags on the `COMMIT[]` stream — never recomputed at the edge:
   round, and every human resume starts a **fresh budget**.
 - **`reviewFixCount`** — `gtd: feedback` commits (review-fix rounds) since the
   most recent package start.
+- **`healthFixCount`** — `gtd: health-check` commits since the most recent
+  commit that removed HEALTH.md (or the start of branch history if none). Reuses
+  `fixAttemptCap` — no separate config key.
 
 ### Test-fix loop (`fixAttemptCap`, default 3)
 
@@ -378,6 +405,31 @@ ERRORS.md — which **resets the fix-attempt budget** (the next run re-tests and
 grants a fresh `cap` attempts before escalating again). While ERRORS.md exists,
 every run resolves straight back to Escalate.
 
+### Health-fix loop (`fixAttemptCap`, `squash` — no new config)
+
+Outside a process (any branch), when there is no reviewable diff and no steering
+files, `gtd` runs `testCommand` instead of stopping. This reuses `fixAttemptCap`
+(default 3) and `squash` — no new config keys are introduced.
+
+```
+Idle path → Health check(red) → Health Fixing → Health check(red) → … → Health check(green)
+                  │                                                             │
+                  └── below cap: HEALTH.md, gtd: health-check ─────────────────┘
+                  └── at/over the cap: ERRORS.md, gtd: health-check → Escalate
+                                                              green + ≥1 health-fix → Squashing (if squash enabled) → Idle
+```
+
+- **green, no prior `gtd: health-fix`** → Idle immediately (no commit).
+- **red, below `fixAttemptCap`** → write test output to HEALTH.md, commit
+  `gtd: health-check` → **Health Fixing** agent fixes, commits removal as
+  `gtd: health-fix`, loops back to Health check.
+- **red, at or over `fixAttemptCap`** → write test output to ERRORS.md, commit
+  `gtd: health-check` → **Escalate** (human gate). Delete ERRORS.md to reset the
+  budget and resume.
+- **green, ≥1 `gtd: health-fix` present** → health-fix cycle converged: if
+  `squash` is enabled → **Squashing** (squash base = parent of the first
+  `gtd: health-check` of the current run); otherwise → Idle (no commit).
+
 ### Review-fix loop & agentic review (`reviewThreshold`, default 3)
 
 After a green test run, **Agentic Review** reviews the package's accumulated
@@ -484,11 +536,13 @@ built-in defaults apply. Supported filenames (searched in this order):
 ### Schema
 
 - **`testCommand`** (string, default `npm run test`) — the command the edge runs
-  in the Testing state to verify a built package.
+  in the Testing state to verify a built package, and in the Health check state
+  on the default-branch idle path.
 - **`fixAttemptCap`** (non-negative integer, default `3`) — the test-fix budget:
   how many `gtd: errors` attempts are allowed per sub-loop before the failure is
   escalated to ERRORS.md (Escalate). `0` disables the cap (escalates immediately
-  on the first red run).
+  on the first red run). Also reused as the health-fix budget (no separate
+  config key).
 - **`reviewThreshold`** (integer ≥ 1, default `3`) — the review-fix budget: how
   many `gtd: feedback` rounds are allowed per package before Agentic Review
   force-approves.

package/dist/gtd.bundle.mjs

@@ -368497,7 +368497,8 @@ var EDGE_ONLY_STATES = /* @__PURE__ */ new Set([
   "accept-review",
   "close-package",
   "done",
-  "await-review"
+  "await-review",
+  "health-check"
 ]);
 var MODEL_STATE = {
   grilling: "grilling",
@@ -368505,6 +368506,7 @@ var MODEL_STATE = {
   planning: "decompose",
   building: "building",
   fixing: "fixing",
+  "health-fixing": "fixing",
   "agentic-review": "agentic-review",
   clean: "clean",
   squashing: "clean"
@@ -368545,7 +368547,8 @@ var STATE_TEMPLATE = {
   clean: "@clean",
   squashing: "@squashing",
   escalate: "@escalate",
-  idle: "@idle"
+  idle: "@idle",
+  "health-fixing": "@fixing"
 };
 var buildPrompt = (result, resolveModel = builtinResolveModel, output = "plain") => {
   const { state, context: context10 } = result;
@@ -388261,8 +388264,11 @@ var GTD_DIR = ".gtd";
 var REVIEW_FILE = "REVIEW.md";
 var FEEDBACK_FILE = "FEEDBACK.md";
 var ERRORS_FILE = "ERRORS.md";
+var HEALTH_FILE = "HEALTH.md";
 var EMPTY_FAILURE_SENTINEL = "Test command failed with no output (exit code non-zero).";
 var UNANSWERED_MARKER = "<!-- user answers here -->";
+var HEALTH_CHECK_SUBJECT = "gtd: health-check";
+var HEALTH_FIX_SUBJECT = "gtd: health-fix";
 var NEW_TASK_SUBJECT = "gtd: new task";
 var GRILLING_SUBJECT = "gtd: grilling";
 var PLANNING_SUBJECT = "gtd: planning";
@@ -388279,6 +388285,7 @@ var STEERING_FILES = [
   REVIEW_FILE,
   FEEDBACK_FILE,
   ERRORS_FILE,
+  HEALTH_FILE,
   SQUASH_MSG_FILE
 ];
 var WORKFLOW_FILE_EXCLUDES = [...STEERING_FILES, GTD_DIR];
@@ -388468,7 +388475,9 @@ var gatherEvents = () => (
           isFeedback: subject === FEEDBACK_SUBJECT,
           isPackageStart: subject === PLANNING_SUBJECT || subject === PACKAGE_DONE_SUBJECT,
           isWorkflowCommit: subject.startsWith("gtd: "),
-          removedErrors
+          removedErrors,
+          isHealthCheck: subject === HEALTH_CHECK_SUBJECT,
+          isHealthFix: subject === HEALTH_FIX_SUBJECT
         };
       }
     );
@@ -388542,10 +388551,6 @@ var gatherEvents = () => (
           candidate = firstGrilling.hash ?? EMPTY_TREE;
         }
       } else {
-        const mergeBaseCandidate = Option_exports.isSome(base) && base.value !== headHash ? base.value : void 0;
-        if (mergeBaseCandidate !== void 0) {
-          candidate = mergeBaseCandidate;
-        }
       }
       if (candidate !== void 0 && hasCommitsAfterLastDone) {
         const candidateDiff = yield* git.diffRef(candidate, WORKFLOW_FILE_EXCLUDES).pipe(Effect_exports.catchAll(() => Effect_exports.succeed("")));
@@ -388601,6 +388606,31 @@ var gatherEvents = () => (
     }
     const squashMsgPresent = yield* fs9.exists(resolve5(SQUASH_MSG_FILE));
     const squashMsgContent = squashMsgPresent ? yield* fs9.readFileString(resolve5(SQUASH_MSG_FILE)) : "";
+    const healthPresent = yield* fs9.exists(resolve5(HEALTH_FILE));
+    const healthContent = healthPresent ? yield* fs9.readFileString(resolve5(HEALTH_FILE)) : "";
+    const healthCommitted = healthPresent && !isUncommitted(HEALTH_FILE);
+    let healthFixBase;
+    if (config2.squash) {
+      const subjectOf = (c7) => (c7.message.split("\n")[0] ?? "").trim();
+      let firstHealthCheckHash;
+      let healthCheckCount = 0;
+      for (const commit3 of history) {
+        const s5 = subjectOf(commit3);
+        const isPackageStart = s5 === PLANNING_SUBJECT || s5 === PACKAGE_DONE_SUBJECT;
+        if (isPackageStart || commit3.removedErrors) {
+          firstHealthCheckHash = void 0;
+          healthCheckCount = 0;
+        }
+        if (s5 === HEALTH_CHECK_SUBJECT) {
+          healthCheckCount++;
+          if (healthCheckCount === 1) firstHealthCheckHash = commit3.hash;
+        }
+      }
+      if (healthCheckCount > 0 && firstHealthCheckHash !== void 0) {
+        const base2 = yield* git.resolveRef(`${firstHealthCheckHash}~1`).pipe(Effect_exports.catchAll(() => Effect_exports.succeed(EMPTY_TREE)));
+        healthFixBase = base2;
+      }
+    }
     const payload = {
       todoExists,
       todoCommitted,
@@ -388632,7 +388662,11 @@ var gatherEvents = () => (
       ...squashBase !== void 0 ? { squashBase } : {},
       ...squashDiff !== void 0 ? { squashDiff } : {},
       squashMsgPresent,
-      squashMsgContent
+      squashMsgContent,
+      healthPresent,
+      healthContent,
+      healthCommitted,
+      ...healthFixBase !== void 0 ? { healthFixBase } : {}
     };
     const resolveEvent = { type: "RESOLVE", payload };
     return [...commitEvents, resolveEvent];
@@ -388662,7 +388696,7 @@ var perform = (action) => (
       // work in the tree, then re-derive. (No producer command — consume only.)
       case "transportReset": {
         yield* git.mixedResetHead();
-        return;
+        return { stop: false };
       }
       // New Feature: capture the raw input as `gtd: new task` (unless HEAD is
       // already there — the lost-seed regenerate case), revert it back to a
@@ -388670,7 +388704,7 @@ var perform = (action) => (
       case "seedNewFeature": {
         const captured = yield* captureAndRevert(git, NEW_TASK_SUBJECT, Effect_exports.void);
         yield* fs9.writeFileString(resolve5(TODO_FILE), seedTodo(captured));
-        return;
+        return { stop: false };
       }
       // Accept Review: capture the human's pending changeset durably as
       // `gtd: review feedback` (annotations, code edits, and new files alike),
@@ -388682,7 +388716,7 @@ var perform = (action) => (
         const captured = yield* captureAndRevert(git, REVIEW_FEEDBACK_SUBJECT, git.resetHard());
         yield* fs9.remove(resolve5(REVIEW_FILE)).pipe(Effect_exports.catchAll(() => Effect_exports.void));
         yield* fs9.writeFileString(resolve5(TODO_FILE), seedTodo(captured));
-        return;
+        return { stop: false };
       }
       // Grilling capture: the plan is already committed and the user sketched
       // code during the round. Fold the code diff (untracked included, steering
@@ -388705,7 +388739,7 @@ var perform = (action) => (
         }
         yield* fs9.writeFileString(resolve5(TODO_FILE), appendCapturedInput(todoNow, captured));
         yield* git.commitAllWithPrefix(GRILLING_SUBJECT);
-        return;
+        return { stop: false };
       }
       // Testing: commit the pending tree `gtd: building` (nothing pending in the
       // no-op-fixer case), run tests; on red write FEEDBACK (below cap) or ERRORS
@@ -388722,13 +388756,46 @@ var perform = (action) => (
           if (!committedBuilding) {
             yield* git.commitAllWithPrefix(BUILDING_SUBJECT);
           }
-          return;
+          return { stop: false };
         }
         const target = action.capReached ? ERRORS_FILE : FEEDBACK_FILE;
         const body = /\S/.test(result.output) ? result.output : EMPTY_FAILURE_SENTINEL;
         yield* fs9.writeFileString(resolve5(target), body);
         yield* git.commitAllWithPrefix(ERRORS_SUBJECT);
-        return;
+        return { stop: false };
+      }
+      // Health check: run tests on an idle/clean tree.
+      // Green, no prior fixes → stop immediately (no commit).
+      // Green, fixes exist → stop immediately (squash handled via healthFixBase
+      //   when gatherEvents sets it; the machine resolves squashing state).
+      // Red below cap → write HEALTH.md (uncommitted); resolveHealth will
+      //   commit it as `gtd: health-check` via `commitPending removeHealth`.
+      // Red at cap → write ERRORS.md and commit `gtd: health-check` immediately
+      //   so the Escalate state fires on the next resolve.
+      case "runHealthCheck": {
+        if (action.commitErrorsReset === true) {
+          yield* git.commitAllWithPrefix(HEALTH_FIX_SUBJECT);
+        }
+        const runner = yield* TestRunner;
+        const result = yield* runner.run();
+        if (result.exitCode === 0) {
+          if (action.healthFixBase !== void 0 && action.commitErrorsReset !== true) {
+            yield* fs9.writeFileString(
+              resolve5(SQUASH_MSG_FILE),
+              "chore: health-check cycle squash\n"
+            );
+            return { stop: false };
+          }
+          return { stop: true };
+        }
+        const body = /\S/.test(result.output) ? result.output : EMPTY_FAILURE_SENTINEL;
+        if (action.capReached) {
+          yield* fs9.writeFileString(resolve5(ERRORS_FILE), body);
+          yield* git.commitAllWithPrefix(HEALTH_CHECK_SUBJECT);
+        } else {
+          yield* fs9.writeFileString(resolve5(HEALTH_FILE), body);
+        }
+        return { stop: false };
       }
       // Grilling / Grilled / Planning / Fixing: commit the pending tree under a
       // fixed phase prefix. Fixing sets `removeFeedback` so FEEDBACK.md's removal
@@ -388742,11 +388809,14 @@ var perform = (action) => (
         if (action.removeTodo === true) {
           yield* fs9.remove(resolve5(TODO_FILE)).pipe(Effect_exports.catchAll(() => Effect_exports.void));
         }
+        if (action.removeHealth === true) {
+          yield* fs9.remove(resolve5(HEALTH_FILE)).pipe(Effect_exports.catchAll(() => Effect_exports.void));
+        }
         if (action.removeTodo !== true) {
           yield* formatFile(resolve5(TODO_FILE)).pipe(Effect_exports.catchAll(() => Effect_exports.void));
         }
         yield* git.commitAllWithPrefix(action.prefix);
-        return;
+        return { stop: false };
       }
       // Close package: remove the (maybe-empty / maybe-absent) FEEDBACK.md, rm
       // the first (finished) package dir (+ the now-empty `.gtd/`), commit
@@ -388759,19 +388829,19 @@ var perform = (action) => (
           yield* git.removePackageDir(`${GTD_DIR}/${first2.name}`);
         }
         yield* git.commitAllWithPrefix(PACKAGE_DONE_SUBJECT);
-        return;
+        return { stop: false };
       }
       // Await Review: commit REVIEW.md as `gtd: awaiting review`.
       case "commitReview": {
         yield* formatFile(resolve5(REVIEW_FILE)).pipe(Effect_exports.catchAll(() => Effect_exports.void));
         yield* git.commitAllWithPrefix(AWAITING_REVIEW_SUBJECT);
-        return;
+        return { stop: false };
       }
       // Done: rm REVIEW.md, commit `gtd: done`.
       case "done": {
         yield* fs9.remove(resolve5(REVIEW_FILE)).pipe(Effect_exports.catchAll(() => Effect_exports.void));
         yield* git.commitAllWithPrefix(DONE_SUBJECT);
-        return;
+        return { stop: false };
       }
       // Squash: rm SQUASH_MSG.md, soft-reset to squashBase, commit everything
       // under the provided commit message.
@@ -388779,7 +388849,7 @@ var perform = (action) => (
         yield* fs9.remove(resolve5(SQUASH_MSG_FILE)).pipe(Effect_exports.catchAll(() => Effect_exports.void));
         yield* git.softResetTo(action.squashBase);
         yield* git.commitAllWithPrefix(action.commitMessage);
-        return;
+        return { stop: false };
       }
     }
   }).pipe(Effect_exports.mapError((e7) => e7 instanceof Error ? e7 : new Error(String(e7))))
@@ -388797,14 +388867,17 @@ var GtdStateError = class extends Error {
 var foldCounters = (events) => {
   let testFixCount = 0;
   let reviewFixCount = 0;
+  let healthFixCount = 0;
   for (const event of events) {
     if (event.type !== "COMMIT") continue;
     if (event.isPackageStart || event.isFeedback || event.removedErrors) testFixCount = 0;
     if (event.isErrors) testFixCount += 1;
     if (event.isPackageStart) reviewFixCount = 0;
     if (event.isFeedback) reviewFixCount += 1;
+    if (event.isPackageStart || event.removedErrors) healthFixCount = 0;
+    if (event.isHealthCheck) healthFixCount += 1;
   }
-  return { testFixCount, reviewFixCount };
+  return { testFixCount, reviewFixCount, healthFixCount };
 };
 var isBoundary = (subject) => !subject.startsWith("gtd: ") || subject === "gtd: done";
 var DEFAULT_PAYLOAD = {
@@ -388834,7 +388907,10 @@ var DEFAULT_PAYLOAD = {
   reviewThreshold: 3,
   squashEnabled: false,
   squashMsgPresent: false,
-  squashMsgContent: ""
+  squashMsgContent: "",
+  healthPresent: false,
+  healthContent: "",
+  healthCommitted: false
 };
 var buildContext = (p4, counters, grillingCase) => ({
   testFixCount: counters.testFixCount,
@@ -388847,7 +388923,7 @@ var buildContext = (p4, counters, grillingCase) => ({
   ...p4.squashDiff !== void 0 ? { squashDiff: p4.squashDiff } : {},
   lastCommitSubject: p4.lastCommitSubject,
   workingTreeClean: p4.workingTreeClean,
-  feedbackContent: p4.feedbackContent,
+  feedbackContent: p4.feedbackContent !== "" ? p4.feedbackContent : p4.healthContent,
   ...grillingCase !== void 0 ? { grillingCase } : {}
 });
 var assertLegal = (p4) => {
@@ -388861,7 +388937,32 @@ var assertLegal = (p4) => {
   if (p4.feedbackPresent && p4.reviewPresent) fail20("illegal combination: FEEDBACK.md + REVIEW.md");
   if (p4.feedbackPresent && !p4.gtdDirExists) fail20("illegal combination: FEEDBACK.md without .gtd");
   if (p4.errorsPresent && p4.feedbackPresent) fail20("illegal combination: ERRORS.md + FEEDBACK.md");
-  if (p4.errorsPresent && !p4.gtdDirExists) fail20("illegal combination: ERRORS.md without .gtd");
+  const isHealthCapEscalation = p4.lastCommitSubject === "gtd: health-check" || p4.lastCommitSubject === "gtd: health-fix";
+  if (p4.errorsPresent && !p4.gtdDirExists && !isHealthCapEscalation)
+    fail20("illegal combination: ERRORS.md without .gtd");
+  if (p4.healthPresent && p4.gtdDirExists) fail20("illegal combination: HEALTH.md + .gtd");
+  if (p4.healthPresent && p4.reviewPresent) fail20("illegal combination: HEALTH.md + REVIEW.md");
+  if (p4.healthPresent && p4.feedbackPresent) fail20("illegal combination: HEALTH.md + FEEDBACK.md");
+  if (p4.healthPresent && p4.errorsPresent) fail20("illegal combination: HEALTH.md + ERRORS.md");
+};
+var resolveHealth = (p4, counters) => {
+  const hasPendingWork = !p4.healthCommitted || !p4.workingTreeClean;
+  const prefix = p4.healthCommitted ? "gtd: health-fix" : "gtd: health-check";
+  return {
+    state: "health-fixing",
+    autoAdvance: true,
+    ...hasPendingWork ? {
+      edgeAction: {
+        kind: "commitPending",
+        prefix,
+        // Always remove HEALTH.md: on gtd: health-check this clears it so
+        // the next run re-enters resolveCleanOrIdle; on gtd: health-fix it
+        // clears the marker left by a prior health-check run.
+        removeHealth: true
+      }
+    } : {},
+    context: buildContext(p4, counters)
+  };
 };
 var resolveFeedback = (p4, counters) => {
   if (p4.feedbackEmpty) {
@@ -388995,7 +389096,13 @@ var resolveGrilling = (p4, counters, head7) => {
   };
 };
 var resolveCleanOrIdle = (p4, counters, head7) => {
-  if (!p4.workingTreeClean || !isBoundary(head7) && head7 !== "gtd: package done") return null;
+  const isHealthHead = head7 === "gtd: health-check" || head7 === "gtd: health-fix";
+  if (!p4.workingTreeClean && !p4.pendingErrorsDeletion) return null;
+  if (!p4.workingTreeClean && p4.pendingErrorsDeletion && p4.gtdDirExists) return null;
+  if (!p4.workingTreeClean && p4.pendingErrorsDeletion && !isBoundary(head7) && head7 !== "gtd: package done" && !isHealthHead)
+    return null;
+  if (p4.workingTreeClean && !isBoundary(head7) && head7 !== "gtd: package done" && !isHealthHead)
+    return null;
   if (head7 === "gtd: done" && p4.squashEnabled && p4.squashBase !== void 0) {
     if (p4.squashMsgPresent) {
       return {
@@ -389012,9 +389119,20 @@ var resolveCleanOrIdle = (p4, counters, head7) => {
     return { state: "squashing", autoAdvance: true, context: buildContext(p4, counters) };
   }
   const reviewable = p4.hasCommitsAfterLastDone && p4.reviewBase !== void 0 && (p4.refDiff ?? "").trim().length > 0;
+  if (reviewable) {
+    return { state: "clean", autoAdvance: false, context: buildContext(p4, counters) };
+  }
+  const squashHealth = p4.squashEnabled && counters.healthFixCount > 0 && p4.healthFixBase !== void 0;
   return {
-    state: reviewable ? "clean" : "idle",
-    autoAdvance: false,
+    state: "health-check",
+    autoAdvance: true,
+    edgeAction: {
+      kind: "runHealthCheck",
+      errorCount: counters.healthFixCount,
+      capReached: counters.healthFixCount >= p4.fixAttemptCap,
+      ...squashHealth ? { healthFixBase: p4.healthFixBase } : {},
+      ...p4.pendingErrorsDeletion ? { commitErrorsReset: true } : {}
+    },
     context: buildContext(p4, counters)
   };
 };
@@ -389041,6 +389159,7 @@ var resolve4 = (events) => {
   }
   if (p4.errorsPresent)
     return { state: "escalate", autoAdvance: false, context: buildContext(p4, counters) };
+  if (p4.healthPresent) return resolveHealth(p4, counters);
   if (p4.feedbackPresent) return resolveFeedback(p4, counters);
   if (p4.gtdDirExists) return resolveGtdLifecycle(p4, counters, head7, corrupt);
   if (p4.reviewPresent) return resolveReviewLifecycle(p4, counters, head7);
@@ -389056,6 +389175,18 @@ var resolve4 = (events) => {
       context: buildContext(p4, counters)
     };
   }
+  if (p4.squashEnabled && p4.healthFixBase !== void 0 && p4.squashMsgPresent && !p4.codeDirty) {
+    return {
+      state: "squashing",
+      autoAdvance: false,
+      edgeAction: {
+        kind: "squashCommit",
+        squashBase: p4.healthFixBase,
+        commitMessage: p4.squashMsgContent
+      },
+      context: buildContext(p4, counters)
+    };
+  }
   if (isBoundary(head7) && !p4.workingTreeClean && !p4.todoCommitted || head7 === "gtd: new task" && p4.workingTreeClean) {
     return {
       state: "new-feature",
@@ -389076,7 +389207,8 @@ var EDGE_ONLY_STATES2 = /* @__PURE__ */ new Set([
   "await-review",
   "accept-review",
   "close-package",
-  "done"
+  "done",
+  "health-check"
 ]);
 var isEdgeOnly = (state) => EDGE_ONLY_STATES2.has(state);
 var detect = () => Effect_exports.gen(function* () {
@@ -389088,6 +389220,19 @@ var detect = () => Effect_exports.gen(function* () {
 });
 
 // src/program.ts
+var IDLE_RESULT = {
+  state: "idle",
+  autoAdvance: false,
+  context: {
+    testFixCount: 0,
+    reviewFixCount: 0,
+    packages: DEFAULT_PAYLOAD.packages,
+    diff: DEFAULT_PAYLOAD.diff,
+    lastCommitSubject: DEFAULT_PAYLOAD.lastCommitSubject,
+    workingTreeClean: DEFAULT_PAYLOAD.workingTreeClean,
+    feedbackContent: DEFAULT_PAYLOAD.feedbackContent
+  }
+};
 var MAX_EDGE_HOPS = 100;
 function makeProgram(opts = {}) {
   const argv = opts.argv ?? process.argv;
@@ -389138,7 +389283,22 @@ function makeProgram(opts = {}) {
       }
       const result = yield* detect();
       if (result.edgeAction !== void 0) {
-        yield* perform(result.edgeAction);
+        const { stop: stop2 } = yield* perform(result.edgeAction);
+        if (stop2) {
+          const builtPrompt2 = buildPrompt(IDLE_RESULT, config2.resolveModel, json2 ? "json" : "plain");
+          if (json2) {
+            write4(
+              JSON.stringify({
+                state: "idle",
+                autoAdvance: false,
+                prompt: builtPrompt2
+              }) + "\n"
+            );
+          } else {
+            write4(builtPrompt2);
+          }
+          return;
+        }
       }
       if (isEdgeOnly(result.state)) {
         continue;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pmelab/gtd",
-  "version": "1.6.1",
+  "version": "1.8.0",
   "private": false,
   "description": "Git-aware CLI that emits the next prompt for an autonomous coding agent based on the current repository state",
   "bin": {