mandrel 1.71.0 → 1.72.0

package/.agents/scripts/lib/orchestration/lifecycle/listeners/automerge-predicate.js

@@ -26,6 +26,15 @@
  * "clean sprint" retro trailer), emit `epic.merge.ready`. Otherwise emit
  * `epic.merge.blocked` with a non-empty reason.
  *
+ * Code-review parse-miss policy (Story #4222): a code-review comment that is
+ * present but whose severity bullets cannot be parsed is treated as a DISTINCT
+ * condition — surfaced via the `codeReviewUnparseable` signal — and FAILS OPEN
+ * rather than blocking. Failing closed on a format miss is indistinguishable,
+ * to the operator and to downstream telemetry, from a real disqualifying
+ * finding; a parser miss must never masquerade as "the signal said no" inside
+ * a generic `epic.merge.blocked`. Genuine critical/high findings still block,
+ * because those require the counts to have parsed.
+ *
  * Critical contract:
  *   - The verdict for any given input set is byte-identical to the
  *     pre-inlining legacy module's output — this file is its
@@ -229,11 +238,30 @@ function evaluateCodeReviewSignals(codeReview, reasons) {
     : { critical: null, high: null, medium: null, suggestion: null };
   if (!codeReviewFound) {
     reasons.push('code-review structured comment not found on Epic');
-    return { codeReviewFound, severity };
+    return { codeReviewFound, codeReviewUnparseable: false, severity };
   }
-  if (severity.critical === null || severity.high === null) {
-    reasons.push('code-review severity bullets could not be parsed');
-    return { codeReviewFound, severity };
+  // "Present but unparseable" is a DISTINCT condition from "present and says
+  // no" (Story #4222). The canonical renderer
+  // (`review-providers/findings-renderer.js`) always emits all four severity
+  // bullets, so a body whose critical/high counts we cannot extract is a
+  // FORMAT MISS, not a disqualifying signal. Failing closed here — pushing a
+  // generic block reason — is indistinguishable, to the operator and to
+  // downstream telemetry (the mandrel-bench Autonomy dimension), from a real
+  // critical finding: it stalls an otherwise-clean unattended run for a
+  // non-reason.
+  //
+  // Chosen policy: FAIL OPEN on an unparseable code-review body. We surface
+  // the condition explicitly via the `codeReviewUnparseable` signal so
+  // telemetry can tell a parser miss from a true HITL hand-off, but we do NOT
+  // add a disqualifying `reasons[]` entry — the absence of a parseable
+  // critical/high count cannot, on its own, block a run whose other signals
+  // are clean. Genuine disqualifying review findings (critical > 0 /
+  // high > 0) still block below, because those require the counts to have
+  // parsed successfully.
+  const codeReviewUnparseable =
+    severity.critical === null || severity.high === null;
+  if (codeReviewUnparseable) {
+    return { codeReviewFound, codeReviewUnparseable, severity };
   }
   if (severity.critical > 0) {
     reasons.push(`code-review has ${severity.critical} 🔴 Critical Blocker(s)`);
@@ -241,7 +269,7 @@ function evaluateCodeReviewSignals(codeReview, reasons) {
   if (severity.high > 0) {
     reasons.push(`code-review has ${severity.high} 🟠 High Risk finding(s)`);
   }
-  return { codeReviewFound, severity };
+  return { codeReviewFound, codeReviewUnparseable, severity };
 }
 
 function evaluateRetroSignals(retro, reasons) {
@@ -287,6 +315,7 @@ function evaluateRetroSignals(retro, reasons) {
  *     storyStatuses: string[],
  *     storyBlockers: number,
  *     severity: { critical: number|null, high: number|null, medium: number|null, suggestion: number|null },
+ *     codeReviewUnparseable: boolean,
  *     retroCompact: boolean,
  *     codeReviewFound: boolean,
  *     retroFound: boolean,
@@ -308,6 +337,7 @@ export function deriveAutoMergeVerdict({ state, codeReview, retro }) {
       storyStatuses: stateSig.storyStatuses,
       storyBlockers: stateSig.storyBlockers,
       severity: reviewSig.severity,
+      codeReviewUnparseable: reviewSig.codeReviewUnparseable,
       retroCompact: retroSig.retroCompact,
       codeReviewFound: reviewSig.codeReviewFound,
       retroFound: retroSig.retroFound,

package/.agents/workflows/helpers/plan-epic.md

@@ -74,14 +74,22 @@ Phase 5 (Re-Plan Detection).
    one-pager feeds the scope-triage gate below, whose verdict folds into
    the **same** Phase 1 HITL confirmation. Do not stop twice.
 
-3. **HITL stop — confirm the sharpened one-pager**: Display the one-pager
-   to the operator and **STOP**. Do not proceed to Phase 2 until the
-   user explicitly confirms the direction. This is the same gate the
-   skill's own Phase 3 enforces; surfacing it here makes the wait
+3. **HITL stop — confirm the sharpened one-pager** (**gate #1**): Display
+   the one-pager to the operator and **STOP**. Do not proceed to Phase 2
+   until the user explicitly confirms the direction. This is the same gate
+   the skill's own Phase 3 enforces; surfacing it here makes the wait
    contract visible to `/plan` callers. When the Phase 1.5 verdict is
    `story` or `borderline`, this stop carries the three-way choice the
    triage gate defines (below) instead of a plain confirm.
 
+   > **`--yes` (headless) auto-proceed.** When `/plan` was invoked with
+   > `--yes`, this gate does **not** STOP: the one-pager confirm resolves as
+   > **approved** and the run continues to Phase 2. A `story` / `borderline`
+   > triage verdict resolves to its **Recommended** branch (below) rather
+   > than prompting the three-way choice. Display the one-pager and the
+   > verdict line for the record, then proceed without waiting. See
+   > [`plan.md` § Headless / non-interactive mode](../plan.md#headless--non-interactive-mode---yes).
+
 ## Phase 1.5: Scope Triage (ideation path only)
 
 This phase runs **only** on the ideation path, immediately after Phase 1
@@ -124,6 +132,15 @@ skill states once).
    avoid the ceremony tax of pushing a story-sized scope through the full Epic
    pipeline.
 
+   > **`--yes` (headless) exception.** "Never auto-route" is the interactive
+   > contract. Under `--yes` the operator has *pre-authorized* the
+   > recommendation: the three-way choice resolves to its **Recommended**
+   > branch deterministically — `single Story` hands off to
+   > `/plan --from-notes <path>` (carrying `--yes` so the receiving story
+   > path also auto-proceeds), and an `epic` verdict simply continues to
+   > Phase 2. No operator wait. This is the only sanctioned auto-route, and it
+   > exists solely to make `/plan` driveable headlessly.
+
 ## Phase 2: Cross-Epic Duplicate Search
 
 Runs immediately after Phase 1 (and only on the s-plan-ideation path).
@@ -396,6 +413,19 @@ for the scoring logic.
    permission") is honored — no `gh issue edit` call until the
    operator confirms.
 
+   > **`--yes` (headless) auto-proceed.** This refinement-diff confirm is the
+   > clarity-gate face of `/plan`'s **gate #1** on the existing-Epic
+   > (`/plan <epicId>`) path — it is an operator *wait*, not a deterministic
+   > validator (the deterministic half is the section-presence *scoring* in
+   > step 1, which always runs). When `/plan` was invoked with `--yes`, this
+   > confirm does **not** STOP: the sharpened body is auto-**approved** and the
+   > run proceeds to step 6 (persist). The blast-radius note is still displayed
+   > for the record; only the operator wait is suppressed. This keeps
+   > `/plan <epicId> --yes` driveable headlessly even when the Epic body needs
+   > refinement (`gh issue edit` still runs only via the step 6 persist call,
+   > which the auto-approval authorizes). See
+   > [`plan.md` § Headless / non-interactive mode](../plan.md#headless--non-interactive-mode---yes).
+
 6. **Persist**: On approval, run the persist mode:
 
    ```bash
@@ -556,18 +586,31 @@ for the scoring logic.
      `planningRisk.requiresReview` unless the operator passed
      `--force-review`:
      - **High risk** (`requiresReview === true`) or **operator override**
-       (`--force-review`): **STOP**. Ask the USER to review the generated
-       PRD, Tech Spec, and Acceptance Spec on GitHub. Approval is the
-       user's verbal OK in this session — the three context tickets stay
+       (`--force-review`) — **gate #2**: **STOP**. Ask the USER to review the
+       generated PRD, Tech Spec, and Acceptance Spec on GitHub. Approval is
+       the user's verbal OK in this session — the three context tickets stay
        **open** through delivery and are closed automatically by
        `/deliver` when the Epic PR opens. Do NOT proceed
        to decomposition until the user confirms the plan is accurate.
+
+       > **`--yes` (headless) auto-proceed.** When `/plan` was invoked with
+       > `--yes`, this review gate does **not** STOP, even when
+       > `requiresReview === true` or `--force-review` was also passed: the
+       > review resolves as **approved** and the run **continues directly to
+       > Phase 8**, exactly as the low-risk auto-proceed branch below. The
+       > three context tickets stay **open** through delivery as usual; only
+       > the operator *wait* is suppressed. This is `/plan`'s **gate #2** —
+       > the second and last HITL STOP `--yes` suppresses. `--yes` does
+       > **not** alter risk routing or the review criteria themselves; it
+       > only forces a proceed where this gate would otherwise STOP. See
+       > [`plan.md` § Headless / non-interactive mode](../plan.md#headless--non-interactive-mode---yes).
      - **Low risk** (`requiresReview === false` and no `--force-review`):
        Emit the auto-proceed message from the persist stdout
        (`reviewRouting.operatorMessage`) and **continue directly to Phase 8**
        without an extra review stop. The Epic still carries
        `agent::review-spec` until decomposition completes; the routing
-       decision is recorded in the `epic-plan-state` checkpoint.
+       decision is recorded in the `epic-plan-state` checkpoint. (`--yes` is
+       a no-op on this branch — there is no STOP to suppress.)
 
 5. **Tech Spec freshness check (advisory)**: After the Tech Spec issue
    is created, `epic-plan-spec.js` runs

package/.agents/workflows/helpers/plan-story.md

@@ -68,6 +68,9 @@ to authoring the standalone Story body from the handed-off one-pager.
 
 # Inspect the draft body without creating an Issue:
 /plan --dry-run --body temp/single-story-draft.md
+
+# Headless / non-interactive (auto-proceeds the draft-confirm gate):
+/plan --idea "rip out the unused TaskBodyMigrator export" --yes
 ```
 
 ## Phase 1 — Emit Context
@@ -153,8 +156,18 @@ add a second stop.
 
 Display the draft to the operator and **STOP**. Do not call the persist phase
 until the operator explicitly confirms the draft. This mirrors the HITL gate
-`/plan` Phase 3 enforces before opening the Epic Issue. The scope-triage
-verdict folds into this same stop:
+`/plan` Phase 3 enforces before opening the Epic Issue. This is the
+story-path face of `/plan`'s **gate #1** (the ideation one-pager /
+scope-triage confirm). The scope-triage verdict folds into this same stop:
+
+> **`--yes` (headless) auto-proceed.** When `/plan` was invoked with `--yes`,
+> this gate does **not** STOP: the draft confirm resolves as **approved** and
+> the run proceeds to Phase 3 (persist). An `epic` verdict resolves to its
+> **Recommended** branch — escalate to `/plan --idea` (carrying `--yes`),
+> abandoning the draft — rather than prompting the three-way choice. Display
+> the draft and the verdict line for the record, then proceed without
+> waiting. See
+> [`plan.md` § Headless / non-interactive mode](../plan.md#headless--non-interactive-mode---yes).
 
 - **`story` verdict (or gate skipped via handoff)** → no extra prompt. The
   operator confirms the draft as usual and the run proceeds to Phase 3
@@ -177,6 +190,9 @@ verdict folds into this same stop:
 
   **Never auto-route.** The verdict is advisory; the operator always decides,
   and no `agent::*` / label transition happens on either side of the choice.
+  (**`--yes` exception:** headless mode pre-authorizes the **Recommended**
+  branch deterministically — see the `--yes` note above — the only sanctioned
+  auto-route, present solely to make `/plan` driveable without an operator.)
 
 ## Phase 3 — Persist (`gh issue create`)
 

package/.agents/workflows/plan.md

@@ -44,6 +44,7 @@ forwards them to the active path helper:
 | `--force` | Epic | Close + recreate an existing ticket tree on re-plan. |
 | `--force-review` | Epic | Force the operator review gate even when risk routing would skip it. |
 | `--allow-over-budget` | Epic | Permit a decomposition that exceeds the framework `maxTickets` reviewability budget. |
+| `--yes` | both | **Non-interactive / headless mode.** Deterministically auto-proceeds the two `/plan` HITL STOP gates — the ideation one-pager / scope-triage confirm (gate #1) and the Phase-7 Epic operator review gate (gate #2) — without waiting for operator input. Parallel to [`/deliver --yes`](deliver.md). Composes with `--allow-over-budget` and with the risk-routed Phase-7 skip (it forces a proceed where those do not apply). Default (flag absent) behavior is unchanged: both gates still STOP for interactive use. |
 | `--steal` | Epic | Forcibly transfer a foreign Epic-lease. |
 | `--dry-run` | both | Author + validate without GitHub writes. |
 | `--body <path>` | Story | Pre-authored Story body file; validate (and create, unless `--dry-run`) without re-authoring. |
@@ -58,6 +59,71 @@ commands (story-sized Epic ↘ Story; epic-sized Story draft ↗ Epic) is now
 an **internal branch switch** inside this router: same skills, same
 helpers, no command hop and no operator re-entry.
 
+### Headless / non-interactive mode (`--yes`)
+
+`--yes` is the headless escape hatch for an unattended driver (CI, a
+benchmark harness, or any `claude -p` run with no human at the keyboard). It
+is the `/plan`-side parallel of [`/deliver --yes`](deliver.md), which
+suppresses that command's segment-plan confirmation. `/plan` has exactly
+**two** HITL STOP gates, and `--yes` deterministically auto-proceeds **both**
+without waiting for operator input:
+
+1. **Gate #1 — the ideation one-pager / scope-triage / clarity confirm.**
+   This single conceptual gate has three faces depending on the entry form,
+   and `--yes` auto-proceeds **all three**:
+   - On the `--idea` Epic path,
+     [`helpers/plan-epic.md`](helpers/plan-epic.md) Phase 1 (folding in the
+     Phase 1.5 scope-triage verdict) STOPs to confirm the sharpened one-pager.
+   - On the `--idea` Story path,
+     [`helpers/plan-story.md`](helpers/plan-story.md) Phase 2 STOPs to
+     confirm the drafted Story body.
+   - On the existing-Epic (`/plan <epicId>`) path, the Phase 6 Epic Clarity
+     Gate's **needs-refinement** branch STOPs to confirm the refined-body
+     diff before persisting it.
+
+   Under `--yes` each auto-proceeds: the one-pager / draft / refined-body
+   confirm resolves as **approved**, and a `story` / `borderline` triage
+   verdict resolves to its **recommended** branch (the one the gate prose
+   marks "Recommended") rather than prompting the three-way choice. The
+   verdict / clarity scoring is still recorded in chat (one line); only the
+   *wait* is suppressed. The clarity-gate *scoring* itself (deterministic
+   section-presence in Phase 6 step 1) still runs — `--yes` suppresses only
+   the operator confirm of the proposed refinement.
+2. **Gate #2 — the Phase-7 Epic operator review gate.** When risk routing
+   forces a review (`planningRisk.requiresReview === true`, or the operator
+   also passed `--force-review`),
+   [`helpers/plan-epic.md`](helpers/plan-epic.md) Phase 7 STOPs for operator
+   approval of the PRD / Tech Spec / Acceptance Spec before decomposition.
+   Under `--yes` this review auto-proceeds straight to Phase 8 — the three
+   context tickets stay **open** through delivery exactly as on the low-risk
+   auto-proceed path.
+
+**Composition.** `--yes` is orthogonal to the other planning flags and
+composes cleanly:
+
+- With **`--allow-over-budget`**: `--yes` suppresses the gate *waits* while
+  `--allow-over-budget` still governs the `maxTickets` over-budget persist —
+  passing `--yes` alone does **not** waive the budget gate.
+- With the **risk-routed Phase-7 skip**: when risk routing already skips the
+  Phase-7 review (low-risk, no `--force-review`), `--yes` is a no-op for that
+  gate — it only *forces a proceed where the gate would otherwise STOP*, it
+  never *adds* a stop or relaxes any non-HITL validator.
+
+**`--yes` suppresses only the HITL operator *waits* above.** It does **not**
+relax any deterministic gate — the Phase 6 Epic Clarity Gate **scoring**
+(section-presence), the Phase 7.5 Tech Spec Section Gate, the file-assumption
+/ DAG validators, the Phase 10 readiness healthcheck, and the `agent::blocked`
+runtime pause all behave exactly as without the flag. A `--yes` run that hits
+one of those still fails closed; the flag is an operator-input suppressor, not
+a validation override. The other operator-input *waits* in the pipeline also
+auto-proceed under `--yes` — the non-blocking Phase 2 duplicate-search pause
+(distinct-Epic confirmed), the Phase 6 clarity refinement-diff confirm
+(refined body approved), and the advisory Phase 8.3/8.4/8.5
+consolidation/critic diffs (consolidated/critic output applied) — since they
+are operator-input waits, not validators. The two *named* HITL STOP gates the
+Story tracks (gate #1, gate #2) are the load-bearing pair; these additional
+waits are auto-proceeded for the same headless reason.
+
 ## First-run preflight
 
 Before routing to a path helper, run a **first-run preflight** to catch
@@ -109,9 +175,11 @@ stubbed docs, or an unready doctor verdict).
    [`core/scope-triage`](../skills/core/scope-triage/SKILL.md) skill on the
    seed. Record the verdict in chat (one line).
 4. **Delegate.** Read the selected path helper **in full** and execute it
-   from its entry phase, forwarding the absorbed flags. The helper's phase
-   numbering, HITL gates, and scripts are unchanged — this router adds no
-   phase content.
+   from its entry phase, forwarding the absorbed flags (including `--yes`).
+   The helper's phase numbering, HITL gates, and scripts are unchanged — this
+   router adds no phase content. When `--yes` is present, the two HITL STOP
+   gates auto-proceed per [Headless / non-interactive mode](#headless--non-interactive-mode---yes)
+   above; every deterministic gate still runs.
 5. **Internal returns.** When a path helper would historically have handed
    off to the other planning command, switch helpers in-place and continue;
    surface the switch to the operator as a one-line note.

package/docs/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 All notable changes to this project will be documented in this file.
 
+## [1.72.0](https://github.com/dsj1984/mandrel/compare/mandrel-v1.71.0...mandrel-v1.72.0) (2026-06-17)
+
+
+### Added
+
+* **plan:** add a headless/non-interactive flag to suppress the ideation one-pager + Phase-7 review gate ([#4223](https://github.com/dsj1984/mandrel/issues/4223)) ([#4226](https://github.com/dsj1984/mandrel/issues/4226)) ([9ffa355](https://github.com/dsj1984/mandrel/commit/9ffa35543f897199c096ad45a568de39b0424ba7))
+
+
+### Fixed
+
+* **deliver:** fail open on unparseable code-review severity bullets in auto-merge gate (refs [#4222](https://github.com/dsj1984/mandrel/issues/4222)) ([#4224](https://github.com/dsj1984/mandrel/issues/4224)) ([ca949bd](https://github.com/dsj1984/mandrel/commit/ca949bd7d98eea440571db6636f8be2f2128c3b9))
+
 ## [1.71.0](https://github.com/dsj1984/mandrel/compare/mandrel-v1.70.0...mandrel-v1.71.0) (2026-06-16)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mandrel",
-  "version": "1.71.0",
+  "version": "1.72.0",
   "description": "Claude Code-first opinionated workflow framework: instructions, personas, skills, and SDLC workflows that govern AI coding assistants.",
   "files": [
     ".agents/",