vinta-ai-workflows 0.7.0-alpha13 → 0.7.0-alpha14

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-alpha14 on 2026-09-16 -->
 <!-- pre-release: 0.7.0-alpha13 on 2026-09-16 -->
 <!-- pre-release: 0.7.0-alpha12 on 2026-09-15 -->
 <!-- pre-release: 0.7.0-alpha11 on 2026-09-15 -->
@@ -23,6 +24,18 @@ the project follows [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ### Added
 
+- **`vinta-ai-maestro gate <gate-id>` runs a declared gate from inside an agent
+  turn.** A phase used to run its full gate suite five or six times a round —
+  implementer, reviewer, fixer, reviewer again, then the authoritative `gate`
+  node — and only the last of those consulted the gate cache or the resource
+  pool. Agents now ask the daemon for a gate by id: the result is cached on the
+  same `(gate id, lane tree hash)` key the `gate` node reads, the gate's
+  resources are held by the daemon rather than by whichever agent remembered to
+  wrap the command, and the id resolves to the plan's own command so a scoped
+  approximation cannot be reported as the gate. Each run is journalled as a
+  `gate_result` event and a `gate_run` transcript entry under the GATE band,
+  whoever asked for it.
+
 - **A project declares what makes a lane runnable.** `project.env_files` copies
   ignored configuration into each worktree, `project.setup_cmd` runs an
   idempotent setup hook on provisioning and recycle, and the fixed
@@ -185,10 +198,33 @@ the project follows [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
     claimed per review turn rather than per phase — it has one session ledger and
     two concurrent reviews would collide over it — so one reviewer on a three-lane
     plan is a queue at the review step and not a serialised run.
+    - **"Cheapest qualified" has one exception, and it is about sessions.** A
+      member who already holds a session this phase would genuinely resume takes
+      it ahead of a cheaper member who would have to start cold — even when they
+      are more senior than the phase needs, and even when the member the plan
+      named is free. What it buys is the context a cold session spends its first
+      turn rebuilding; what it costs is the dearer model for that phase, which is
+      the smaller of the two bills. **The tier floor is untouched**: warmth
+      reorders the members who already qualify and never widens them, so a warm
+      junior still cannot take a Tier 3 phase.
+    - **Only when a session is genuinely already up.** "Warm" means the scheduler
+      asked its own session-reuse rules and got a yes — same pinned lane, same
+      harness, under the turn ceiling, not poisoned by a failed phase. A member
+      who has merely run before is not warm, because a promotion bought on a
+      resume that is then refused pays the senior's rate *and* cold-starts
+      anyway. With nobody warm, staffing is exactly what it was: a session is
+      being opened either way, and the plan's own level wins.
+    - An operator who picks the member by hand on a retry gets that member. A
+      saving nobody asked for does not overrule an explicit answer.
   - The run view reports who actually worked against who the plan said would.
     `substituted` is the figure to read beside a cost that overran: every
     substitution ran at or above the budgeted tier, so a run can be entirely green
-    and still have been staffed dearer than planned.
+    and still have been staffed dearer than planned. The phases promoted to reuse
+    a warm session are counted **within** that figure and reported apart from it —
+    a peer covering for a busy member costs what the plan budgeted, while a warm
+    promotion is the scheduler deliberately trading model rate against cold
+    starts, and folded together a run that promoted everything to the top tier
+    would read as an ordinary busy wave.
 
 - **`implement-plan` runs independent phases in parallel.** The plan now carries a
   dependency graph and the conductor schedules against it: a phase starts as soon as
@@ -303,10 +339,43 @@ the project follows [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
   it rather than only in a log beside it. The operator's own steering stays the
   operator's (§7), even though the adapter echoes it back on the agent's event
   stream. Transcripts written before this render exactly as they did, with no
-  bands.
+  bands. The band stays pinned to the top of the scroller while its own run of
+  rows goes past, so the agent you are reading is named without scrolling back
+  to where it started — in the phase transcript and in the monitor conversation
+  alike.
 
 ### Changed
 
+- **A session cannot inherit a machine's decision to stop compacting.** All
+  three harnesses compact automatically when their context fills — there was
+  never a flag to turn on — but each honours an environment variable that turns
+  it off, and an agent spawned on a machine carrying one would run a long phase
+  straight into a wall it was supposed to be able to survive. Those variables
+  are now stripped from every child the daemon spawns, and claude-code's own
+  setting is reasserted in the per-lane file beside its permission rules. The
+  window itself is left alone: an operator who narrowed theirs compacts earlier,
+  which is not the failure this guards against. A harness that compacts declares
+  it, and a compaction the harness reports is a transcript row like any other.
+
+  One consequence worth knowing: `max_session_turns` used to be a proxy for "this
+  session is nearing a context window it will die on". That death no longer
+  happens, so the ceiling now guards a different thing — a session whose memory
+  was replaced by a summary of itself, and which answers just as confidently.
+
+- **Agent prompts name gates by id rather than printing their commands.** The
+  implementer's step 4 was descriptive — "Outer gate… These run against your
+  lane:" followed by the gate commands — and implementers were observed reading
+  it as a note about what would run later, finishing the scoped inner loop and
+  never running a gate at all. It is imperative now, and every role that runs a
+  gate (implementer, reviewer, fixer, and the continuation of each) is pointed
+  at `vinta-ai-maestro gate <id>`. The fixer prompts no longer say to re-run the
+  gates "until they are green", which contradicted the commit protocol directly
+  below them and left fixers running out the turn with the work uncommitted;
+  they now say to commit and report FAILURE when a gate cannot be turned green.
+  Implementers and fixers report which gates they ran and what each returned —
+  a record for the reviewer to check against, explicitly not a licence for the
+  reviewer to skip running them itself.
+
 - **Phase branches base on their dependencies, not on the previous phase.** A phase
   with no dependencies cuts from the default branch; one with a single dependency
   cuts from that phase's branch; one with several cuts from a
@@ -360,8 +429,57 @@ the project follows [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
   is only as good as the `healthcheck` a service declares: without one, compose
   returns as soon as the container starts and `createdb` races the server.
 
+- **A merge conflict goes to the most senior member who wrote one of its
+  sides.** The conflict fixer was staffed from `defaults` and ignored the roster
+  entirely, so on a tiered crew a collision between two Tier 4 phases was handed
+  to a default-tier agent that had read neither of them — the hardest merge in
+  the run going to the least contextualised agent available, and resolved by
+  guessing which side looked more finished.
+
+  `Integrator` already knows which nodes own the contested paths, and `node_crew`
+  already records who took each one; this is the join. Highest tier among them
+  wins, on that member's own `model` and `harness`, and a tier tie breaks on
+  member id the way roster substitution breaks its own. An unstaffed workflow
+  still resolves through `defaults`, unchanged, and so does a conflict whose
+  nodes cannot be resolved to a member.
+
+  What is carried is the member's **capability, not their session**. A phase's
+  session ran in that phase's lane; the fixer runs in the integration worktree,
+  where the files in dispute are half-merged and unlike anything that session
+  saw — resuming there would give the agent confident, false memories of exactly
+  the files it is merging. The prompt tells the fixer which side is its own, and
+  in the same breath that it is a fresh session and must read rather than
+  recall.
+
 ### Fixed
 
+- **An agent taking a lease left the resource panel showing the one before it.**
+  The scheduler's own gate-pool transitions are journalled as `gate_pool`
+  events, so the browser re-reads the snapshot when one lands. An agent's lease,
+  taken through `vinta-ai-maestro with`, was only a row in the `leases` table —
+  correct in the daemon's projection and announced to nobody. A projection
+  nobody is told changed is a projection nobody sees change, so the panel showed
+  whatever holders it had last time some unrelated event happened to arrive, and
+  the waits it was stalest about were the agent ones, which are the long ones.
+  The broker now journals `agent_lease` on both edges. A renewal writes nothing:
+  it is a heartbeat on a lease already reported, and journalling it would bury
+  the two rows that are transitions under a liveness log.
+
+- **An agent waiting for a semaphore could be overtaken without bound.** A
+  `vinta-ai-maestro with` wait is served in fifteen-second hops so no client
+  timeout has an opinion about it, and each hop used to abort the underlying
+  `pools.acquire`. Aborting leaves the pool queue, and the next POST re-entered
+  it — at the tail, behind every waiter that had arrived in the meantime. Since
+  a gate run holds a capacity-1 semaphore for minutes, an agent lost that race
+  on hop after hop while the scheduler's own in-process waiters, which never
+  leave the queue, did not. The pool's aging rule could not help: aging reserves
+  against waiters *behind* the aged one, and the waiters that overtook it are in
+  front of it. A `202` now carries a `waitToken` naming the wait, the client
+  sends it back, and the daemon keeps the one queue entry — one arrival time,
+  one place in line — across the whole wait. A parked wait whose client stops
+  hopping is reaped after a minute, releasing the slot if one was granted to it
+  while nobody was watching.
+
 - **The monitor's conversation could never be written on Windows.** It is kept
   under a reserved node id that becomes a directory, and that id was
   `monitor:conversation` — a colon, chosen because no phase id may contain one,

package/package.json

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