vinta-ai-workflows 0.7.0-alpha31 → 0.7.0-alpha32

package/CHANGELOG.md

@@ -32,6 +32,35 @@ the project follows [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ### Added
 
+- **`vinta-ai-maestro`: a busy crew member is replaced, not borrowed
+  (`defaults.max_spare_crew`, default 2).** When the member a phase is planned
+  for — or the one an operator picked with `retry with <member>` — is busy, or
+  is planned for a phase still to come, the run takes on a spare in that
+  member's image (same tier, model and harness) with a worktree provisioned for
+  it there and then, instead of borrowing a member another pending phase is
+  waiting for, or waiting. A member nobody is planned for is still borrowed, an
+  idle spare is reused first, and a member busy only with a finished phase's PR
+  chores is waited for. Journalled as `node_crew` `reason: spare_crew` and shown
+  in the post-mortem's `crew_substitutions`. Set `0` in the plan or under
+  `maestro.defaults` to keep the roster to the plan's. One observed run left a
+  phase on its critical path idle for 17 minutes while a retry held the member
+  it was planned for.
+- **`vinta-ai-maestro`: `defaults.pull_requests: plan` opens one PR for the
+  run.** The default, `phase`, is unchanged: a PR per phase, per integration
+  branch, and the plan PR. `plan` opens the plan PR alone, from the last wave
+  branch, and skips the phases' `after_pr` chores (there is no phase PR for
+  them). Also accepted under `maestro.defaults` in `.vinta-ai-workflows.yaml`.
+- **`vinta-ai-maestro doctor` warns when a phase gate will run its full command
+  every time** (`gate-scope:<gate>`), and every run prints it at start: a
+  `test` or `lint` gate a phase uses has no `scoped_cmd` under
+  `gate_scope: scoped`. It says whether `commands.test_unit_scoped` /
+  `lint_scoped` was passed over for having no `{changed_files}` / `{touches}`
+  placeholder — a skill-era line such as `pytest <app>/tests/` is not inherited
+  — or nothing is configured, and names the key to set (e.g.
+  `pytest --testmon {changed_files}`), or `maestro.defaults.gate_scope: full`
+  to accept it. One observed run spent two of its five hours running a
+  6,500-test suite on every phase gate and fix round.
+
 - **`vinta-ai-maestro`: `run` now shows what a slow start is doing.** Until
   now `run` printed "starting in the background…" and nothing else until the
   run was up, which can take minutes (`prepare_cmd`, preflight, database
@@ -523,6 +552,70 @@ the project follows [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ### Changed
 
+- **`vinta-ai-maestro`: agents wait for background work the way a normal
+  Claude Code session does.** A headless session no longer ends at the first
+  turn that leaves background work running. It stays open, the agent is woken
+  in the same session when that work reports, and the session ends on the
+  first turn that leaves nothing running. A held session ends after 30 minutes
+  with no output, and any work still running is cleaned up. Harnesses declare
+  this as a new `backgroundWork` capability:
+  - **claude-code:** the CLI wakes the agent itself. A resumed session also no
+    longer ends on the empty turn the CLI replays first.
+  - **codex:** the adapter wakes the agent itself (see below).
+  - **opencode:** on servers the adapter starts, background `task` sub-agents
+    are enabled through `OPENCODE_EXPERIMENTAL_BACKGROUND_SUBAGENTS`. A
+    configured `baseUrl` reports `false`.
+
+  This fixes the slow review loop. The reviewer, resumed with a message, was
+  killed with the turn. Every round after the first ended "waiting on the
+  reviewer" with no verdict, went to the operator as `unapproved`, and
+  restarted with a cold reviewer. Every turn's prompt now says how to wait on
+  its harness (end the turn, never sleep or poll), naming that harness's own
+  tools. The review starts each round's gates alongside the reviewer's next
+  pass; on opencode, which has no background shell, the reviewer runs in the
+  background and the gates run beside it.
+
+- **`vinta-ai-maestro`: codex runs on `codex app-server` instead of
+  `codex exec`, and needs codex-cli 0.147.0 or later.** `exec` killed
+  background work when the turn ended. App-server keeps it, and the adapter
+  starts the next turn naming, by id, what finished. Codex now also supports
+  `inject`, so steering a running codex node is a message, no longer an
+  interrupt and resume. Each thread is started and resumed with an explicit
+  sandbox, approval policy and reviewer, so `~/.codex/config.toml` can no
+  longer widen `--permission`. Under `--permission ask`, a request for approval
+  is now recorded as a `permission_request` and declined; before, the model
+  could not ask at all. A logged-out codex is refused at spawn instead of
+  failing mid-turn.
+
+- **`vinta-ai-maestro`: an opencode review can no longer pass on its own
+  prompt.** The adapter echoed the user's prompt back as the agent's text. The
+  review prompt contains the line `VERDICT: pass`, so a review that stated no
+  verdict could read as approved. opencode 1.19's `permission.asked` event is
+  now mapped too.
+- **`vinta-ai-maestro`: an unattended run answers `exhausted` and `unapproved`
+  with `continue` once, then `stop`.** It answered `stop` straight away, which
+  failed the phase; the unattended retry then re-drove it from `implement` on
+  a cold session, gates and review from scratch, to reach the same question —
+  twelve failed attempts in one observed run. A plan question's
+  `unattended_answer` may now be a list, one answer per unattended answer
+  within an attempt, the last repeating.
+- **`vinta-ai-maestro`: a phase's dependents start once it has merged, pushed
+  and opened its PR**, when only `after_pr` chores that cannot fail it are left
+  (a review canvas, a PR comment). They used to wait for those too — up to four
+  minutes a phase on the critical path.
+- **`vinta-ai-maestro`: an agent's `gate <id>` is refused while an earlier gate
+  of the phase is red on the same tree**, naming that gate, and runs once the
+  tree moves. A `for g in lint typecheck test` loop no longer runs the suite
+  against a tree its typecheck already failed.
+- **`vinta-ai-maestro`: a crew member woken on a new phase is told the
+  objective changed** before anything else — the previous phase is finished
+  and nothing in flight for it is owed — ahead of the brief and the note about
+  what moved in its worktree.
+- **`vinta-ai-maestro`: the coordinator's gate-cost wake scales with the run**:
+  more than 15 minutes of uncached gate time per phase that ran it, never less
+  than 30 minutes, instead of every 30 minutes; it says how many phases the
+  time is spread over and whether the gate lacks a scoped form.
+
 - **`vinta-ai-maestro`: lane database names stay within Postgres's 63-character
   identifier limit, with room for test-runner affixes.** A forked lane database
   or template whose `<name>_wt_<lane>` form was too long was silently truncated
@@ -798,6 +891,24 @@ the project follows [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ### Fixed
 
+- **`vinta-ai-maestro`: a turn the agent never took part in is no longer read
+  as work.** A session that ended with no text and no tool call — observed when
+  a resumed claude-code session closed a replay of killed background tasks
+  before reading the prompt — counted as a failed review with no reviewer
+  behind it, or, on a crew member's first turn of a new phase, swallowed the
+  new phase's brief so every later turn carried on with the old phase. Such a
+  turn is now retried once, cold, with the whole brief (`node_session`
+  `reason: empty_turn`), and a cold one that is empty too fails the turn.
+
+- **Maestro: an amended gate re-runs instead of returning its old result.**
+  The gate cache matched only the gate's command, so changing a gate's
+  `timeout_s` (the monitor's `retime_gate`) or its `requires` partway through
+  a run reused the result from the old settings on an unchanged tree. The
+  cache now matches every setting that affects the run. Edits to
+  `description` or `tuning` still reuse the result, and so does a
+  `scoped_cmd` edit for runs that use the full `cmd`. Existing
+  `gate-cache.db` entries are dropped once, at the first start after
+  upgrading.
 - **Maestro: PRs say how the plan lands.** Every phase and integration PR is
   marked as a review unit that lands through the plan PR, and the plan PR says
   to merge it alone; it used to offer two landing paths, and a 36-PR landing

package/package.json

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

package/schemas/postmortem.v1.schema.json

@@ -593,9 +593,10 @@
                 "type": "string",
                 "enum": [
                   "peer_busy",
-                  "warm_session"
+                  "warm_session",
+                  "spare_crew"
                 ],
-                "description": "`peer_busy`: the planned member was working. `warm_session`: promoted to reuse an open session."
+                "description": "`peer_busy`: the planned member was working. `warm_session`: promoted to reuse an open session. `spare_crew`: the planned member was working, and a spare was taken on in their image."
               },
               "attempts": {
                 "type": "integer",

package/schemas/vinta-ai-workflows-config.v1.schema.json

@@ -339,7 +339,7 @@
       "additionalProperties": false,
       "properties": {
         "defaults": {
-          "description": "Run defaults a plan's `defaults` overrides field by field: `harness`, `model`, `pipeline`, `chores`, `gates` (the gate ids every phase runs unless it names its own), `gate_scope` (`scoped` | `full`), `wave_gates` (`off` | `final` | `every`), `substitution` (`same_tier` | `up_one_tier` | `any`), `allow_ungated_phases`, `model_fallbacks`, `max_session_turns`.",
+          "description": "Run defaults a plan's `defaults` overrides field by field: `harness`, `model`, `pipeline`, `chores`, `gates` (the gate ids every phase runs unless it names its own), `gate_scope` (`scoped` | `full`), `wave_gates` (`off` | `final` | `every`), `substitution` (`same_tier` | `up_one_tier` | `any`), `allow_ungated_phases`, `model_fallbacks`, `max_session_turns`, `max_spare_crew`, `pull_requests` (`phase` | `plan`).",
           "type": "object",
           "properties": {
             "harness": {
@@ -412,6 +412,19 @@
             "max_session_turns": {
               "type": "integer",
               "minimum": 1
+            },
+            "pull_requests": {
+              "type": "string",
+              "enum": [
+                "phase",
+                "plan"
+              ],
+              "description": "Which pull requests a run opens. `phase` (the default): one per phase, one per integration branch, and the plan PR that lands them. `plan`: the plan PR alone, from the last wave branch; phases' `after_pr` chores are then skipped."
+            },
+            "max_spare_crew": {
+              "type": "integer",
+              "minimum": 0,
+              "description": "Crew members a run may take on beyond the plan's roster (default 2). When the member a phase was planned for is busy, the phase gets a new member at that member's tier and model, with its own worktree, instead of borrowing a member another pending phase is planned for or waiting. `0` keeps the roster to the plan's."
             }
           },
           "additionalProperties": false

package/schemas/workflow.v1.schema.json

@@ -423,6 +423,22 @@
             "any"
           ]
         },
+        "pull_requests": {
+          "default": "phase",
+          "description": "Which pull requests a run opens. `phase` — the default — one per phase, one per integration branch, and the plan PR that lands them all: the phase PRs are review units stacked in merge order. `plan` opens the plan PR alone, from the last wave branch, which already holds every phase and every conflict resolution; review happens there. One observed ten-phase refactor opened fifteen PRs that nobody was going to merge. Under `plan` a phase has no PR of its own, so its `after_pr` chores are skipped.",
+          "type": "string",
+          "enum": [
+            "phase",
+            "plan"
+          ]
+        },
+        "max_spare_crew": {
+          "default": 2,
+          "description": "Crew members a run may take on beyond the roster. When the member a phase was planned for is busy, the phase does not borrow a member another pending phase is planned for, and does not wait: it gets a new member at the planned member’s tier and model, with a worktree of its own provisioned there and then. A member nobody plans for is borrowed as before. The spare stays on the roster for the rest of the run, is never planned for, and covers later phases at its tier. `retry with <member>` takes a spare in that member’s image the same way when the member is needed elsewhere. A worktree, its databases and its compose stack each, so this is bounded; `0` keeps the roster to the plan’s and restores waiting and covering. One observed run left a phase on the critical path idle for 17 minutes while a retry held the member it was planned for.",
+          "type": "integer",
+          "minimum": 0,
+          "maximum": 9007199254740991
+        },
         "wave_gates": {
           "default": "final",
           "description": "When the phases’ gates run in full on a merged wave, in the integration worktree. Each phase passes its gates on its own branch, and two parallel phases can each be green and disagree with each other — a sender and a receiver of one signal, say — which only a merged tree shows. `final` — the default — runs every gate of the plan once on the last wave before the plan PR opens, and the wave’s phases’ gates on any wave whose merge needed a conflict resolution. `every` runs the wave’s phases’ gates on every wave as well, which costs one full suite per wave and catches a disagreement at the wave that introduced it. `off` runs none of these. Under `gate_scope: scoped` the full form of a narrowed gate still runs on each wave whatever this says: that is where the suite the phases skipped is paid back.",