vinta-ai-workflows 0.7.0-alpha33 → 0.7.0-alpha34

package/CHANGELOG.md

@@ -7,6 +7,7 @@ the project follows [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [0.7.0] — YYYY-MM-DD
 
+<!-- pre-release: 0.7.0-alpha34 on 2026-10-16 -->
 <!-- pre-release: 0.7.0-alpha33 on 2026-10-16 -->
 <!-- pre-release: 0.7.0-alpha31 on 2026-10-09 -->
 <!-- pre-release: 0.7.0-alpha30 on 2026-10-09 -->
@@ -33,6 +34,34 @@ the project follows [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ### Added
 
+- **`vinta-ai-maestro`: `accept` on an unapproved review.** The review-budget
+  question offered `continue` or `stop`, and operators answered `stop` meaning
+  "take it as it is" — which fails the attempt and, under `--on-failure
+  retry`, starts the phase over. It now offers `continue`, `accept` and `stop`
+  and says what each does. `accept` ends the review loop and keeps the work:
+  the polish chores, the gates and integration still run, and the answer is
+  journalled. The unattended answer is unchanged (`continue` once, then
+  `stop`); the coordinator cannot answer `accept`.
+- **`vinta-ai-maestro validate` warns about parallel phases adding migrations
+  to one app**, and `plan-feature` treats them as real overlap. Two phases
+  that neither depends on the other, each adding a migration under the same
+  directory (Django `<app>/migrations/`, Alembic `…/versions/`, Rails
+  `db/migrate/`, Prisma `prisma/migrations/`), start from the same latest
+  migration; merged, the graph has two leaves and every gate on the merged
+  tree fails. Their Touch Lists name different files, so nothing flagged it.
+  `validate --json` gains a `warnings` list, printed as `warning:` lines in
+  text mode, and the review page shows them in their own panel; neither
+  changes the exit code or `valid`. `plan-feature` now says to add the edge,
+  or to name the phase whose integration writes the merge migration.
+- **`vinta-ai-maestro node resume <run> <phase>`**, the undo of `node pause`:
+  it withdraws a pause not yet taken, releases a phase parked on the pause, or
+  gives a held phase its `--retry-after` timer back. It used to take
+  answering an undocumented "The operator paused this node. Resume it?"
+  question, or answering a held phase's question by hand.
+- **`vinta-ai-maestro status` shows the question each phase is asking**, with
+  its choices, and `status --json` carries it per node as `question`
+  (`effectId`, `question`, `kind`, `choices`, `askedAt`). `asking: true` alone
+  sent operators into `flow.db` to read it.
 - **`vinta-ai-maestro`: ways past a stale gate verdict.** `gate <id>
   --no-cache` runs a gate past its cached result and keeps the new one in its
   place; a cached red now says so. `gate-cache invalidate <run-id> <gate-id>
@@ -957,6 +986,51 @@ the project follows [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ### Fixed
 
+- **`vinta-ai-maestro`: a claude-code turn the CLI calls "blocked" no longer
+  fails unless a tool was refused in it.** The CLI's own turn summary marks a
+  turn `blocked` whenever its last message names a next step for a person —
+  a review ending "Nothing was pushed." over `VERDICT: pass`, an implementer
+  listing an open point — and each such turn was recorded as failed
+  ("claude-code: the turn ended blocked"), an approving review included. One
+  observed phase had 43 of them. The summary now fails a turn only alongside a
+  `permission_denied` in the same turn, the case it was added for; whether
+  the rest did their job is for verdicts, gates and the agent's questions. A
+  turn's errors no longer outlive it in a session held open for background
+  work.
+- **`vinta-ai-maestro`: a merge git stopped with nothing unmerged no longer
+  starts a fixer.** `rerere.autoupdate` replaying a recorded resolution, or a
+  `pre-merge-commit` / `commit-msg` hook refusing the merged code, leaves
+  `git merge` non-zero with no unmerged path, and the integrator handed the
+  conflict fixer an empty file list — nineteen rounds in one observed phase,
+  each told to resolve nothing. With no conflict markers left, the merge now
+  goes to `verify` and is committed, recorded as resolved in 0 rounds; a hook
+  that refuses that commit gets the refused-commit question (commit, commit
+  past the hooks, or abort), worded for a clean merge. Only a red gate sends it
+  to the fixer. A merge git refused before merging anything (an untracked file
+  in the way) fails with git's own error.
+- **`vinta-ai-maestro`: a merge finished by hand survives the next attempt.**
+  A conflict the fixer could not settle fails the phase with "finish the merge
+  by hand … and commit it", and the next attempt's `mergeWave` cut
+  `wave-<N>` again from `wave-<N-1>` and re-merged every member, throwing the
+  resolution away and hitting the same conflict on every attempt. A wave or
+  `integ-<id>` branch that still contains its starting point, and whose merges
+  all brought in work still in the members' current tips, is now kept, and only
+  the members it lacks are merged. A member redone after it was merged still
+  forces a rebuild. The error now says the branch is kept.
+- **`vinta-ai-maestro`: a merged tree that fails its gates is no longer
+  reported as an unresolved conflict with no paths.** Two sibling phases that
+  each added a Django migration on the same parent merged cleanly and failed
+  `verify` together, and the phase failed "unresolved conflict: p4a both
+  changed , …". Each fix round is now told which gate the merged tree failed
+  and where its log is, and the rounds end in `IntegrationVerifyError`, naming
+  the gate and its log path (`nodes/_integration/gates/<gate>.log`).
+- **`vinta-ai-maestro`: `exec` accepts a lane's short name or its phase, and
+  `with` / `gate` work inside it.** `exec <run> crew-3-tier2-2` and
+  `exec <run> p1` were refused `unknown_target`; only the full
+  `<run-id>-crew-3-tier2-2` worked. Both now resolve, and a refusal lists the
+  run's targets. Inside `exec`, `with test-suite -- make test` said "no live
+  run is available" while the run was live: the command now holds leases as the
+  phase running in the lane, or as itself on an idle one, until it exits.
 - **`vinta-ai-maestro`: a fix loop that changes nothing now stops and asks.**
   A typecheck red because of ignored files left in a lane kept coming back
   from the gate cache after they were gone, and twenty fixers in a row found

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vinta-ai-workflows",
-  "version": "0.7.0-alpha33",
+  "version": "0.7.0-alpha34",
   "description": "Bootstrap AI tooling (AGENTS.md, skills, sub-agents) across Claude Code, Codex, Cursor, and VS Code + GitHub Copilot.",
   "type": "module",
   "bin": {

package/skills/vinta-derive-skills/resources/foundation-skills/plan-feature/SKILL.md

@@ -254,6 +254,7 @@ Before publishing the plan, cross-check the **Touch List**: for every pair of ph
 
 - **Trivial overlap** (a shared `__init__.py`, a settings registry, a route table) — fine. Note it under the graph table so the reviewer isn't surprised.
 - **Real overlap** (the same use case, the same serializer, the same view) — **add the dependency edge** and let one phase build on the other. A serialized pair that merges cleanly beats a parallel pair that needs a human to untangle.
+- **Migrations in one app count as real overlap, even in different files.** Two phases that run in parallel and each add a migration to the same app both start from the same latest migration. Each is green alone; merged, the migration graph has two leaves (Django) or two heads (Alembic), and every gate on the merged tree fails. Their Touch Lists name two different new files, so path overlap never shows it. Prefer the edge — usually by folding both schema changes into the foundation phase — or, when the two must stay parallel, say in the later phase's body that the integration step writes the merge migration. `vinta-ai-maestro validate` warns about such a pair; put the migrations directory in each phase's Touch List so it can.
 
 ### Design *for* parallelism when it's cheap
 
@@ -1071,6 +1072,8 @@ Fix each issue by its `source`:
 - **`workflow`**: the document's shape or graph, such as an unknown node, a cycle, an undeclared pool, a crew member that cannot take its phase, a gate entry with neither `cmd` nor `type`, a phase with no gates, or an id that does not match the filename. Re-derive the field from the plan. A gate `"has no cmd"` is an override that forgot its `"type"`. A phase that `"has no gates"` is a node carrying `"gates": []` — remove the key so it takes `defaults.gates`, name its gates, or, for a plan whose phases genuinely have nothing to run, set `defaults.allow_ungated_phases: true`. If the plan itself is wrong (a cycle in its `**Depends on**:` lines), fix the plan first.
 - **`config`**: `.vinta-ai-workflows.yaml` does not parse. That file is the project's, not the plan's. Do not edit it to make the plan pass. Tell the human what is wrong and where.
 
+**`warnings` do not change the exit code, and each still gets an answer.** Today the one warning is two phases that run in parallel and both add migrations to the same app (see "Same-wave phases must not fight over the same files"). Add the dependency edge, or keep the pair parallel and say in the later phase's body that the merge migration is written at integration. Either way, name the choice when you hand the plan over. An older maestro prints no `warnings` key.
+
 ## Review the plan with the human
 
 A plan is cheapest to change before anything runs. Once both files are written and the workflow validates, hand the plan over for review. Ask with `AskUserQuestion`: header `Review`, question "The plan and its workflow are written — `<plan path>` and `<workflow path>`. How do you want to review it?"