mandrel 2.58.0 → 2.60.0

package/.agents/workflows/mandrel-deliver.md

@@ -33,7 +33,7 @@ you read:
 | --- | --- | --- |
 | `/mandrel-deliver` | bare | List the open `agent::ready` Stories and ask which to deliver. Deliver nothing until answered. |
 | `/mandrel-deliver 4712` | ids | One Story via `helpers/deliver-story.md`, **inline in this session** — no `story-worker` spawn. |
-| `/mandrel-deliver 4712 4713 …` | ids | Resolve the set, sequence by the discovered graph via `stories-wave-tick.js`, dispatch sub-agents. |
+| `/mandrel-deliver 4712 4713 …` | ids | Resolve the set, then beat `deliver-run.js` — it sequences by the discovered graph and hands back the spawns and closes. |
 | `/mandrel-deliver 4712 - 4716` | ids | A **range** — every id in the inclusive span. |
 | `/mandrel-deliver 4700` (a `type::epic`) | ids | The Epic's **open** child Stories. Mixes with Story ids. |
 | `/mandrel-deliver add a --json flag to doctor` | prompt | Unplanned work: gate, author a receipt Story, land it — [`helpers/deliver-light.md`](helpers/deliver-light.md). |
@@ -42,10 +42,10 @@ you read:
 id, and `^#?\d+\s*[-–—]\s*#?\d+$` an inclusive **range** — pass one on as a
 single unspaced token, never hand-expanded (reference). Either shape
 means ids; anything else means a prompt. A **mixed** invocation (ids *and*
-prose) is a **hard error** — refuse it and ask which was meant. A ticket that
-is neither `type::story` nor `type::epic`, or that carries an `Epic: #N`
-footer, is a hard error too — container Epics link parent→child only, so that
-footer stays refused.
+prose) is **ambiguous, not fatal** — disambiguate it rather than refusing:
+ask which was meant, or, when the reading is obvious, name the one you
+inferred before acting on it. A ticket that is neither `type::story` nor
+`type::epic` is a **hard error**.
 
 ## Saying what you want
 
@@ -67,41 +67,51 @@ to an attended run.
 1. **Resolve the set.** One command, one Story or many:
    `node .agents/scripts/resolve-stories.js --ids <id,id,...>`. It validates the
    set and shows what will run: read `stories[]`, `dag[]` and `done[]` to
-   present the order in step 2, but do **not** thread them into step 3 — the
-   tick re-resolves the graph every beat. An Epic id expands to its open child
+   present the order in step 2, but do **not** thread them into step 3 — every
+   beat re-resolves the graph. A one-id run comes back `dispatchMode: "inline"`
+   and runs [`helpers/deliver-story.md`](helpers/deliver-story.md) in this
+   session; step 3 is the multi-Story path. An Epic id expands to its open child
    Stories first — **announce it**. It hard-errors (exit 1) on an id that is
-   neither a Story nor an Epic, on an `Epic: #N` footer, on an Epic with no
-   open children, or on edges it cannot read — a missing gate would co-dispatch
-   against an unlanded blocker.
+   neither a Story nor an Epic, on an Epic with no open children, or on edges
+   it cannot read — a missing gate would co-dispatch against an unlanded
+   blocker.
 
 2. **Confirm (N>1).** Present the order; wait unless `--yes`.
 
-3. **Sequence.** Loop until the tick reports `epilogueDue: true`:
+3. **Run the beat.** One command per beat, repeated until the envelope reports
+   the run `done`:
 
    ```bash
-   node .agents/scripts/stories-wave-tick.js \
-     --stories <id,id,...> --probe-live \
-     --dispatched <every id you have dispatched so far>
+   node .agents/scripts/deliver-run.js \
+     --stories <id,id,...> [--handoff <id>]...
    ```
 
    **Do not add `--concurrency` unless the operator explicitly asked for a
    per-run cap** — an explicit value wins over config, so a literal defeats a
    `.agentrc.local.json` override.
 
-   Each beat re-probes live state to derive done / in-flight itself; you never
-   compute them. `--dispatched` is the one thing you must supply — the
-   append-only list of every id you spawned this run. Cross-run de-confliction
-   via the assignee lease is automatic. Branch on the exit code:
-   - **0** — dispatch each `ready` id (already capped and overlap-free); an
-     empty `ready` with work in flight means "waiting", so keep looping;
-     `epilogueDue: true` means every Story is done — step 4.
+   Each beat re-probes live state and keeps its own accounting: the run ledger
+   under `<tempRoot>/run-<id>/` records every id it hands out, so **nothing is
+   maintained across beats by you**. Cross-run de-confliction via the assignee
+   lease is automatic. Branch on the exit code:
+   - **0** — spawn one `story-worker` per `ready[]` entry, **all in one turn**,
+     each with that entry's `promptPath` file as its prompt; run each `close[]`
+     entry's command foreground and serialized as hand-offs arrive. An empty
+     `ready` with work in flight means "waiting", so beat again — **unless
+     `stalledDispatch[]` is non-empty**: those ids were dispatched but still
+     read `agent::ready`, which is a live init window the first beats or two
+     and a spawn that never started one after that. Beating again cannot
+     clear it. Relay `stalledDispatchReason` — it carries the recovery — and
+     let the operator decide; never edit the ledger for them.
+     `done: true` means every Story is landed — step 4.
    - **2 / 3 / 4** — `cycleError` / `wedged` / `blocked`: stop the loop and
      route per reference. **4** is the protocol's HITL pause
      ([`instructions.md` § 1.J](../instructions.md)) — surface it and wait for
      the operator; never poll.
 
-4. **Close each hand-off** (§ Closing what the workers hand back), then, with
-   every Story landed, run the **per-run epilogue (N>1)**:
+4. **Land what the workers hand back** (§ Closing what the workers hand back —
+   the beat renders each command), then, with every Story landed, run the
+   **per-run epilogue (N>1)**:
    `node .agents/scripts/plan-run-epilogue.js --stories 101,102`; N=1 has none
    ([reference](helpers/deliver-reference.md)). Every close rolls its container
    Epic up from its children.
@@ -117,7 +127,10 @@ to an attended run.
 **The tail is the orchestrator's, not the worker's.** A dispatched
 `story-worker` stops at a pushed branch and returns a hand-off; **you** run
 [`helpers/deliver-story.md`](helpers/deliver-story.md) Step 3
-(`single-story-close.js`) for it, foreground, and relay its envelope.
+(`single-story-close.js`) for it, foreground, and relay its envelope. Pass the
+id as `--handoff` on the next beat and run the `close[]` command it prints
+verbatim — the beat knows the run topology, so it decides
+`--merge-watch-mode async` for you.
 
 **Serialize the tail.** Implementation runs in parallel; closing does not.
 Close one Story at a time — closes contend on the base branch, the merge queue
@@ -133,9 +146,11 @@ envelope — `landed` | `pending` | `blocked` | `failed`; statuses, exits and
 fields are digest § 5. `pending` is **not** a failure — run its `nextCommand`.
 
 **Branch model (authoritative).** `story-<id>` → PR → `main` (squash +
-required checks), per digest § 2; dependent Stories land sequentially. Ceremony
-depth (profiles + the derived level via `ceremony-routing.js`, which review
-depth reads): reference § Ceremony.
+required checks), per digest § 2; dependent Stories land sequentially. The
+acceptance verdict owner follows the ceremony profile alone
+(`ceremony-routing.js`); the **derived level** feeds review depth instead
+(`review-depth.js`). The rule and its one home are digest § 3; the profile
+table is reference § Ceremony.
 
 ## Constraints
 
@@ -143,10 +158,11 @@ depth reads): reference § Ceremony.
   default to close-and-land (`delivery.routing.closeAndLand: true`); rest at
   `agent::closing` only when a human owns the merge.
 - **`/mandrel-deliver` never plans.** Planned tickets come from
-  [`/mandrel-plan`](mandrel-plan.md), and an over-scope prompt **escalates and
-  ends** — never invoke `/mandrel-plan` in this session to rescue it
-  ([`helpers/deliver-light.md`](helpers/deliver-light.md) § Escalation is
-  terminal).
+  [`/mandrel-plan`](mandrel-plan.md), and a refused prompt **escalates**: the
+  light path ends, and the escalation's `nextCommand` is what owns the work —
+  seeded with `escalation.reasons`, in this session or a fresh one
+  ([`helpers/deliver-light.md`](helpers/deliver-light.md) § Continuing into
+  `/mandrel-plan`).
 
 ## See also
 

package/.agents/workflows/mandrel-plan.md

@@ -11,7 +11,7 @@ description:
 
 ## Inputs
 
-Single planning path — there is no Epic/Story router, no scope-triage
+Single planning path — there is no Epic/Story router, no split-triage
 `epic|story` verdict (Gate #3's container groups, never routes). **Derive the
 mode from what the operator typed, announce it, act**:
 
@@ -47,14 +47,14 @@ checkpoints, not sibling tickets ([ref](helpers/plan-reference.md)).
 ### 1. Interrogate
 
 ```bash
-node .agents/scripts/plan-context.js --seed "<seed>" \
-  --out temp/plan-<slug>/plan-context.json
+node .agents/scripts/plan-context.js --seed "<seed>"
 # or: --seed-file <path> | --tickets 123,456 | --amends #<id>
 ```
 
-**Always pass `--out`.** Persist auto-discovers the envelope from `--plan-dir`
-and derives source ids from its `sourceTickets[]`; it also writes
-**`stories.template.json`**, step 2's skeleton.
+It writes the envelope and **`stories.template.json`** (step 2's skeleton) to
+`<tempRoot>/plan-<slug>/` and prints a digest naming both; `--out` overrides
+the path. Persist auto-discovers the envelope from `--plan-dir` and derives
+source ids from its `sourceTickets[]`.
 
 The envelope carries docs context, the story-author prompt (`systemPrompts.story`,
 plus `systemPrompts.storySplitRules` for an N>1 draft and
@@ -87,18 +87,18 @@ persist parses either, serializes canonical markdown and syncs top-level
 `acceptance[]` / `verify[]` in — never dual-author them.
 
 **Grounding = your reads + Phase 8.** Nothing inventories the repo: read each
-file you cite; persist hard-errors on any `{path, assumption}` absent from the
-tree — a `refactors-existing` on a path the base branch **deleted or renamed**
-included. One rescue: a **never-tracked** one normalises to `creates`. Fields:
-[ref](helpers/plan-reference.md).
+file you cite. A `changes[]` entry is a **bare path** by default — persist
+derives its assumption by probing the base branch and reports the derivation;
+pin `{path, assumption}` only when the probe would get it wrong, and always
+for a `deletes`, which is the one shape still refused on an absent path.
+Fields: [ref](helpers/plan-reference.md).
 
 Artifacts under `temp/plan-<slug>/`: `stories.json` (**length 1 by default**;
-a Spec is as long as the work needs, inline, never under `docs/`); optional
-`techspec.md` (**N===1 only**, folded into `## Spec`) and
-`acceptance-manifest.json` (N>1 — `--plan-acceptance`). Use the envelope
+a Spec is as long as the work needs, inline, never under `docs/`) and optional
+`techspec.md` (**N===1 only**, folded into `## Spec`). Use the envelope
 `systemPrompts.story`; split only under the policy above, and when you do,
-read `systemPrompts.storySplitRules` too — it carries the schedule and
-partition rules the core omits. In **tickets mode** also read
+read `systemPrompts.storySplitRules` too — it carries the schedule rules and
+the same-wave collision refusal the core omits. In **tickets mode** also read
 `systemPrompts.storyTicketsRules`: the source ticket is evidence, not a
 template — re-derive `acceptance[]` rather than carrying its list, handles
 and tier suffixes forward.
@@ -112,32 +112,36 @@ The maker-blind **pre-mortem** critic is not a step of this spine: run
 
 ### 3. Persist
 
-**Gate #2** — STOP for approval before persist **only** when the operator asked
-to review (`--force-review`). Under `--yes`, auto-proceed.
+**Gate #2** — STOP for approval before persist when the draft carries **more
+than one Story** (a split always earns operator eyes, `--force-review` or
+not), or when the operator asked to review (`--force-review`).
+Under `--yes`, auto-proceed.
 
 **Gate #3 — adopt, else create.** Offer the top `epicCandidates[]` Epic at
 **any N** (`--epic <id>`); else, at **N>2**, a new container (`--epic-title` /
 `--epic-goal`). Never unasked ([ref](helpers/plan-reference.md)).
 
-Run persist `--dry-run` **first** — same command, writes suppressed; every gate
-runs before the first `createIssue`, and the run **lists its warnings**
-(a `creates` / `refactors-existing` the base branch disagrees with, a goal or
-acceptance path absent at base, an open question in a body) and the
-`changes[]` repairs it applied ([list](helpers/plan-reference.md)). Read
-them; they never stop the persist:
+**One command.** Persist runs every gate write-free first — including the
+**same-wave collision refusal**, which rejects an N>1 draft whose siblings
+declare a common path (merge them, or order them with `depends_on`) — and,
+when the gate list comes back clean, creates the issues in the same
+invocation:
 
 ```bash
 node .agents/scripts/plan-persist.js \
   --stories temp/plan-<slug>/stories.json \
   --plan-dir temp/plan-<slug> \
-  [--plan-acceptance temp/plan-<slug>/acceptance-manifest.json] \
   [--tech-spec temp/plan-<slug>/techspec.md] \
   [--source-tickets 123,456] \
   [--epic <id> | --epic-title "<name>" --epic-goal "<one paragraph>"]
 ```
 
-`--chain-on-clean` folds a clean dry-run into the persist for **any** plan —
-the dry-run's warning list is the review.
+The run **lists its warnings** (a `creates` / `refactors-existing` the base
+branch disagrees with, a goal or acceptance path absent at base, an empty
+`verify[]`, a source id assigned to the primary Story by default, an open
+question in a body) and the `changes[]` repairs it applied
+([list](helpers/plan-reference.md)). Read them; they never stop the persist.
+Add `--dry-run` to validate without creating anything.
 
 Persist creates `type::story` issue(s), a **metadata-only** `plan-run::<id>`
 label, `blocked by #<id>` footers for every `depends_on` edge, and on a Gate #3
@@ -152,12 +156,10 @@ also comments on and closes each source id ([ref](helpers/plan-reference.md)).
 - Duplicate search targets open Stories (`type::story`), not Epics; and
   deterministic gates still fail closed under `--yes`.
 - A container Epic is never a work item and only an **open** one is adoptable;
-  no Story body gains an `Epic: #N` footer (linkage is parent→child only).
+  linkage is parent→child only.
 - `depends_on` takes a sibling slug or `#<id>` (open Story).
 
 ## See also
 
 [`/mandrel-deliver`](mandrel-deliver.md), [`/audit-to-stories`](audit-to-stories.md),
-[`helpers/plan-reference.md`](helpers/plan-reference.md) (on-demand detail),
-[`core/scope-triage`](../skills/core/scope-triage/SKILL.md) — optional
-split-advisory notes only (no routing verdict).
+[`helpers/plan-reference.md`](helpers/plan-reference.md) (on-demand detail).

package/.agents/workflows/mandrel-update.md

@@ -7,7 +7,7 @@ description: >-
   leaves unowned: reconcile `.agentrc.json`, install the stabilized
   quality-gate surface, refresh the harness permission allowlist, reconcile
   the consumer's `AGENTS.md` / runbooks against the surfaced changelog, and
-  stage + commit the staged lockfile bump.
+  stage + commit the dependency bump the CLI's closing report describes.
 ---
 
 # /mandrel-update
@@ -19,14 +19,15 @@ description: >-
 > **distribution-agnostic judgment steps** the CLI deliberately does **not**
 > perform — config reconciliation, the quality-gate installs, the
 > permission-allowlist refresh, the consumer-side changelog reconciliation,
-> and the stage-and-commit of the staged lockfile bump.
+> and the stage-and-commit of the dependency bump.
 
 The upgrade contract, in brief: the version only moves on explicit
 invocation (no `postinstall` drift — teammates track the committed
 lockfile pin, and CI's `npm ci` honours it); majors apply like any other
 bump (Mandrel ships hard cutovers — the surfaced changelog is the
-migration guide); the CLI **never commits** (the lockfile bump is left
-staged for operator review); and the only authoritative writer of the
+migration guide); the CLI **never mutates git** — it reads the index and
+**reports** whether the bump is staged, so the operator follows that
+report rather than an assumption; and the only authoritative writer of the
 generated `.claude/commands/` tree is
 [`sync-claude-commands.js`](../scripts/sync-claude-commands.js), invoked by
 the CLI's sync step.
@@ -80,22 +81,32 @@ npx mandrel update
 The dry run resolves the newest published version and prints the ordered
 step plan (`npm-update → runSync → runMigrations → doctor → surface
 changelog`) without touching anything — read the planned target version
-before applying. The live run drives those phases in order, leaves the
-lockfile bump **staged** (never committed), and finishes by printing the
-`docs/CHANGELOG.md` sections covering the applied range `(current, target]`.
-**Capture that changelog output** — Step 4 reconciles the consumer's own
-instructions against it. Already-newest is a clean no-op (`Already up to
-date`, exit 0).
+before applying. The live run drives those phases in order, never commits,
+and finishes by printing the `docs/CHANGELOG.md` sections covering the
+applied range `(current, target]`. **Capture that changelog output** —
+Step 4 reconciles the consumer's own instructions against it.
+Already-newest is a clean no-op (`Already up to date`, exit 0).
+
+**Read the closing line — it reports the real index state.** Staging is
+package-manager-specific (`npm install` may stage; `pnpm add` / `yarn add`
+stage nothing), so the CLI probes git read-only and tells you which of three
+states you are in rather than asserting one:
+
+| Closing line | What it means | What you do |
+| --- | --- | --- |
+| `The dependency bump is staged for review (package.json, <lockfile>).` | The index already carries both. | Go to Step 2. |
+| `The dependency bump is NOT staged. … Review and stage it: git add …` | Nothing (or only half) is staged. | Run the exact `git add` the line prints — it names `.agents/` too when this consumer tracks the materialized tree. |
+| `Review the working tree and commit the bump (git not available to report staging state).` | The probe could not read git; the update still succeeded (exit 0). | Inspect `git status` yourself before Step 5. |
 
 ## Step 2.5 — Partial-upgrade recovery (**blocker — resolve before Step 5**)
 
-The install phase stages the lockfile bump *before* the later phases run,
+The install phase writes the dependency bump *before* the later phases run,
 and by deliberate design the CLI **never rolls back the install on
 failure**. So when a post-install phase (`sync` / `sync-commands` /
 `migrate` / `doctor`) exits non-zero you land in a **partially-upgraded
-state**: the bump is already staged while `.agents/` may be
-half-materialized, the command tree out of sync, or a migration partially
-applied — and the operator is one `git commit` away from recording a broken
+state**: the bump is already on disk (and possibly in the index) while
+`.agents/` may be half-materialized, the command tree out of sync, or a
+migration partially applied — and the operator is one `git commit` away from recording a broken
 half-upgrade as "done". **Treat any post-install phase failure as an
 explicit blocker: do not proceed to Step 5 until the failed phase is
 recovered and a clean re-run reports success.**
@@ -203,22 +214,25 @@ between the installed and target versions:
    workflows for renamed flags / changed exit codes / removed scripts.
 
 Do not invent updates — silence is a valid review outcome. Stage every
-consumer-side edit alongside the staged lockfile bump so the upgrade and
-the reconciliation land in one reviewable commit.
+consumer-side edit alongside the dependency bump so the upgrade and the
+reconciliation land in one reviewable commit.
 
 ## Step 5 — Commit the bump
 
-> **Blocker check before you commit.** The staged lockfile bump is only safe
+> **Blocker check before you commit.** The dependency bump is only safe
 > to commit once every post-install phase has gone green. If `npx mandrel
 > update` exited non-zero, resolve it via
 > [Step 2.5 — Partial-upgrade recovery](#step-25--partial-upgrade-recovery-blocker--resolve-before-step-5)
 > **before** the `git commit` below. Committing over a half-upgrade records
 > a broken state as "done".
 
-Stage and commit the bump plus everything the wraparound touched:
+Stage and commit the bump plus everything the wraparound touched. Start from
+the `git add` the CLI's closing report printed (it names the detected
+lockfile, and `.agents/` when this consumer tracks it), then add the
+wraparound paths:
 
 ```bash
-git add package.json package-lock.json .agentrc.json .claude/settings.json AGENTS.md  # plus any runbook files touched in Step 4
+git add package.json package-lock.json .agentrc.json .claude/settings.json AGENTS.md  # lockfile per the CLI report; plus any runbook files touched in Step 4
 git commit -m "chore: update mandrel to v<NEW_VERSION>
 
 Upgraded v<OLD_VERSION> → v<NEW_VERSION> via mandrel update.
@@ -239,8 +253,9 @@ materialized tree.
 
 - **Idempotent.** A second `mandrel update` after a successful run hits the
   no-op short-circuit — exit 0, nothing bumped.
-- **No auto-commit.** The CLI leaves the lockfile bump staged and never runs
-  git; the operator writes the commit (Step 5).
+- **No auto-commit.** The CLI never stages and never commits — it reads git
+  only to report whether the bump is staged; the operator writes the commit
+  (Step 5).
 - **No framework-side version bump.** This workflow advances the
   *consumer's* pinned version; framework releases remain the maintainer's
   call via release-please.

package/README.md

@@ -86,9 +86,9 @@ time to confirm the install is healthy.
 >
 > Prefer a surgical alternative? Replace `shamefully-hoist` with a scoped
 > `public-hoist-pattern[]=` line per package listed in
-> `.agents/runtime-deps.json` (`ajv`, `ajv-formats`, `js-yaml`, `minimatch`,
-> `picomatch`, `typhonjs-escomplex`). If `mandrel doctor`
-> reports `runtime-deps missing: …`, this is the fix.
+> `.agents/runtime-deps.json` — read the file rather than copying a list from
+> here, since the complexity kernel's closure is several packages. If
+> `mandrel doctor` reports `runtime-deps missing: …`, this is the fix.
 
 `bootstrap.js` is interactive on a TTY and auto-accepts the
 owner/repo/base branch/operator handle it can infer from your local

package/docs/CHANGELOG.md

@@ -15,6 +15,49 @@ All notable changes to this project will be documented in this file.
 -->
 <!-- markdownlint-disable-file MD004 MD012 MD037 -->
 
+## [2.60.0](https://github.com/dsj1984/mandrel/compare/mandrel-v2.59.0...mandrel-v2.60.0) (2026-09-18)
+
+
+### ⚠ BREAKING CHANGES
+
+* `delivery.feedbackLoop.auditResultsAutoFile` is no longer a valid `.agentrc.json` key. `mandrel update` strips it automatically.
+* deliver-light.js no longer accepts --kinds, --magnitude, --uncertainty or --route; STORY_SHAPE_CEILINGS and the four ceiling SHAPE_CODES are removed, and no gate envelope carries warnings[].
+* under delivery.routing.ceremonyProfile standard the acceptance verdict is authored inline; set strict to keep a fresh-context critic.
+* plan-persist.js persists on a clean dry-run by default — pass --dry-run to validate only; the "Commit subject begins with '<prefix>:'" acceptance validator is removed; an empty verify[] is a warning, not a refusal.
+* delivery.feedbackLoop.retroProposals and delivery.feedbackLoop.auditResultsAutoFile now default to false; a consumer that relied on auto-filed follow-up issues sets both to true in .agentrc.json.
+
+### Added
+
+* add deliver-run.js so a multi-Story run is one script beat plus spawns and closes, not a hand-driven protocol ([#5345](https://github.com/dsj1984/mandrel/issues/5345)) ([#5354](https://github.com/dsj1984/mandrel/issues/5354)) ([591dad7](https://github.com/dsj1984/mandrel/commit/591dad75923133bef9e3a9d095ac47442464943b))
+* clamp deliver-runner concurrency to one when worktree isolation resolves off, so two workers can never share a checkout ([#5357](https://github.com/dsj1984/mandrel/issues/5357)) ([#5360](https://github.com/dsj1984/mandrel/issues/5360)) ([1f3f651](https://github.com/dsj1984/mandrel/commit/1f3f6515e4a7a4fd2c730001dc6dd4cdb44f251e))
+* close fails fast with a named blocker when GitHub GraphQL is unavailable, instead of a raw 403 after the full gate chain ([#5355](https://github.com/dsj1984/mandrel/issues/5355)) ([#5359](https://github.com/dsj1984/mandrel/issues/5359)) ([b46c263](https://github.com/dsj1984/mandrel/commit/b46c26329dd7cc1e968e607ccaae9d51a9f1ef84))
+* collapse the ceremony decision to what it decides and delete the inert layer around it ([#5366](https://github.com/dsj1984/mandrel/issues/5366)) ([#5375](https://github.com/dsj1984/mandrel/issues/5375)) ([54d0ece](https://github.com/dsj1984/mandrel/commit/54d0ece864d8cb3ec824228dc097999781f7b29f))
+* collapse the light path to one gate and let an escalation continue in-session ([#5344](https://github.com/dsj1984/mandrel/issues/5344)) ([#5353](https://github.com/dsj1984/mandrel/issues/5353)) ([c09acd6](https://github.com/dsj1984/mandrel/commit/c09acd69a8525dd33073922a7541bb9488929249))
+* cut the restated delivery rules, the v1 refusals and the sibling-coherence step, and turn auto-filing off by default ([#5341](https://github.com/dsj1984/mandrel/issues/5341)) ([#5350](https://github.com/dsj1984/mandrel/issues/5350)) ([349d346](https://github.com/dsj1984/mandrel/commit/349d3468c11a23504b510ac80d0716b5dd709853))
+* delivery ceremony diet: one inline verdict per Story, opt-in fresh critics and audit roster, fewer Story comments, and one CI rerun after a recorded verdict ([#5343](https://github.com/dsj1984/mandrel/issues/5343)) ([#5352](https://github.com/dsj1984/mandrel/issues/5352)) ([1ac35c4](https://github.com/dsj1984/mandrel/commit/1ac35c40745bd1d6f0945f9a5ffd3f975452dbff))
+* loosen plan authoring: one persist command, bare paths in changes[], empty verify[] as a warning, and the fossil validators removed ([#5342](https://github.com/dsj1984/mandrel/issues/5342)) ([#5351](https://github.com/dsj1984/mandrel/issues/5351)) ([c7534a5](https://github.com/dsj1984/mandrel/commit/c7534a523cf39b24324d26f2cad81b2ec4fb22df))
+* make a dispatch that never reached init visible in the beat envelope ([#5363](https://github.com/dsj1984/mandrel/issues/5363)) ([#5370](https://github.com/dsj1984/mandrel/issues/5370)) ([ab3c755](https://github.com/dsj1984/mandrel/commit/ab3c7553975ef5dce8c60112d7f8c278c5dd0d8d))
+
+
+### Fixed
+
+* `mandrel update` reports whether the bump is actually staged instead of asserting it ([#5339](https://github.com/dsj1984/mandrel/issues/5339)) ([#5349](https://github.com/dsj1984/mandrel/issues/5349)) ([07f63c7](https://github.com/dsj1984/mandrel/commit/07f63c79bdb19a532e82d413de719a194c170504))
+* anchor pre-push coverage capture and the CRAP preview on one resolved ref ([#5365](https://github.com/dsj1984/mandrel/issues/5365)) ([#5373](https://github.com/dsj1984/mandrel/issues/5373)) ([cb189e3](https://github.com/dsj1984/mandrel/commit/cb189e3a005749305cc0ce2075ea17793493bb0e))
+* capture coverage before the pre-push quality preview (refs [#5356](https://github.com/dsj1984/mandrel/issues/5356)) ([#5358](https://github.com/dsj1984/mandrel/issues/5358)) ([14ef1dd](https://github.com/dsj1984/mandrel/commit/14ef1dde384455f16f3ddd502881c132fd6ae056))
+* close the three correctness holes the plan-authoring loosening left in persist ([#5361](https://github.com/dsj1984/mandrel/issues/5361)) ([#5372](https://github.com/dsj1984/mandrel/issues/5372)) ([aef03bd](https://github.com/dsj1984/mandrel/commit/aef03bd90e14cc2dac68ea4d7a04f0f262e2494e))
+* delete the write-only plan checkpoint payload and the three unreachable modules ([#5367](https://github.com/dsj1984/mandrel/issues/5367)) ([#5374](https://github.com/dsj1984/mandrel/issues/5374)) ([4c0c835](https://github.com/dsj1984/mandrel/commit/4c0c835d9eded8e993bb7ebd3e66e86bec4d2377))
+* demote the workflow prose ratchets to reports and delete the reference sections that describe retired mechanisms ([#5340](https://github.com/dsj1984/mandrel/issues/5340)) ([#5347](https://github.com/dsj1984/mandrel/issues/5347)) ([8d76329](https://github.com/dsj1984/mandrel/commit/8d76329e3aacc726e39d1839f01e618fb7361662))
+* report the index mandrel update actually observes, from one read ([#5364](https://github.com/dsj1984/mandrel/issues/5364)) ([#5371](https://github.com/dsj1984/mandrel/issues/5371)) ([12af953](https://github.com/dsj1984/mandrel/commit/12af95383f7ddbfe137715aa10bce3b25a7b95a3))
+* treat a rate-limited GraphQL probe as fail-open rather than unreachable (refs [#5362](https://github.com/dsj1984/mandrel/issues/5362)) ([#5369](https://github.com/dsj1984/mandrel/issues/5369)) ([db6a9e0](https://github.com/dsj1984/mandrel/commit/db6a9e08441baf40281962e0b226575f9c7b1846))
+
+## [2.59.0](https://github.com/dsj1984/mandrel/compare/mandrel-v2.58.0...mandrel-v2.59.0) (2026-09-14)
+
+
+### Added
+
+* planning stops fragmenting cohesive work: the acceptance band goes, the dispatcher's own collision predicate becomes the split gate, and the audit seed stops pre-cutting the partition ([#5332](https://github.com/dsj1984/mandrel/issues/5332)) ([#5334](https://github.com/dsj1984/mandrel/issues/5334)) ([e6408e4](https://github.com/dsj1984/mandrel/commit/e6408e44d3f9a7fcbdf8c9a7df4a1b68fdffd88b))
+* replace the complexity kernel's parse and dispatch layers and declare the runtime closure it leaves behind, so the framework's dependency guards describe what actually loads ([#5336](https://github.com/dsj1984/mandrel/issues/5336)) ([#5337](https://github.com/dsj1984/mandrel/issues/5337)) ([821c4f5](https://github.com/dsj1984/mandrel/commit/821c4f55fe3fe9b91b83a4ef9fe9ddee5da9db8f))
+
 ## [2.58.0](https://github.com/dsj1984/mandrel/compare/mandrel-v2.57.0...mandrel-v2.58.0) (2026-09-12)
 
 

package/lib/cli/registry.js

@@ -41,6 +41,8 @@ import {
 } from '../../.agents/scripts/lib/bootstrap/project-bootstrap.js';
 import { isCommandExcluded } from '../../.agents/scripts/lib/command-header.js';
 import { getDeliveryRouting } from '../../.agents/scripts/lib/config/delivery-routing.js';
+import { isResolvable } from '../../.agents/scripts/lib/runtime-deps/dep-resolution.js';
+import { describeParserMajorError } from '../../.agents/scripts/lib/runtime-deps/parser-major.js';
 import {
   defaultResolvePackageRoot,
   listFiles as listPayloadFiles,
@@ -519,6 +521,30 @@ function runAgentsInSync({
 // check: runtime-deps
 // ---------------------------------------------------------------------------
 
+/**
+ * The verdict when every required package is present.
+ *
+ * Presence is not the whole contract: `.agents/` resolves from the consumer's
+ * node_modules, so a declared range cannot enforce which `@babel/parser` major
+ * the complexity kernel actually gets, and the wrong major fails scoring
+ * mid-scan with an opaque plugin-list error. Reporting it here puts it where a
+ * consumer is already looking for what to fix.
+ *
+ * @param {() => string|null} parserMajorError
+ * @returns {{ ok: boolean, detail: string, remedy?: string }}
+ */
+function allPresentVerdict(parserMajorError) {
+  const parserProblem = parserMajorError();
+  if (parserProblem === null) {
+    return { ok: true, detail: 'all dependencies found' };
+  }
+  return {
+    ok: false,
+    detail: 'dependency version unsupported',
+    remedy: parserProblem,
+  };
+}
+
 /**
  * Verify that the framework's required runtime dependencies are resolvable
  * from the project's node_modules.
@@ -536,6 +562,8 @@ function runAgentsInSync({
  *   is missing.
  * - `manifestRequired` — array of required package names, skips the
  *   filesystem read of `runtime-deps.json`.
+ * - `parserMajorError()` — replaces the resolved-parser-major probe, so the
+ *   unsupported-major report is assertable without installing one.
  *
  * @param {{ projectRoot?: string, resolve?: (dep: string) => string, manifestRequired?: string[] }} [opts]
  * @returns {{ ok: boolean, detail: string, remedy?: string }}
@@ -544,6 +572,7 @@ function runRuntimeDeps({
   projectRoot,
   resolve: resolveSeam,
   manifestRequired,
+  parserMajorError = describeParserMajorError,
 } = {}) {
   // Anchor at process.cwd() (the consumer root), not resolveProjectRoot() (the
   // package root). Under pnpm isolated-mode the consumer's node_modules are not
@@ -569,33 +598,24 @@ function runRuntimeDeps({
 
   const missing = [];
 
-  if (resolveSeam) {
-    for (const dep of required) {
-      try {
-        resolveSeam(dep);
-      } catch {
-        missing.push(dep);
-      }
-    }
-  } else {
-    // Anchor resolution to the consumer project root so it mirrors the context
-    // in which the framework scripts run (they free-ride on the consumer's
-    // node_modules). Under pnpm isolated-mode the consumer's node_modules are
-    // not reachable from inside node_modules/mandrel/; anchoring at process.cwd()
-    // finds them correctly.
-    const req = createRequire(path.join(root, 'package.json'));
-    for (const dep of required) {
-      try {
-        req.resolve(dep);
-      } catch {
-        missing.push(dep);
-      }
-    }
+  // Anchor resolution to the consumer project root so it mirrors the context
+  // in which the framework scripts run (they free-ride on the consumer's
+  // node_modules). Under pnpm isolated-mode the consumer's node_modules are
+  // not reachable from inside node_modules/mandrel/; anchoring at process.cwd()
+  // finds them correctly.
+  //
+  // `isResolvable` is shared with the framework-side preflight rather than
+  // reimplemented here: it probes the bare specifier AND `<name>/package.json`,
+  // because a dependency with no `main` and no `exports` cannot be resolved by
+  // name at all. Probing only the bare name reports such a package missing
+  // while it sits installed, and this check gates `mandrel doctor`.
+  const resolve =
+    resolveSeam ?? createRequire(path.join(root, 'package.json')).resolve;
+  for (const dep of required) {
+    if (!isResolvable(dep, resolve)) missing.push(dep);
   }
 
-  if (missing.length === 0) {
-    return { ok: true, detail: 'all dependencies found' };
-  }
+  if (missing.length === 0) return allPresentVerdict(parserMajorError);
   return {
     ok: false,
     detail: `missing: ${missing.join(', ')}`,