v5.0.0-beta.42

Your plan, your spend, your call. This release rebuilds autopilot's execution
model around billing trust. The orchestration loop now runs its workers inside
the driving session by default — billed to the subscription you already pay
for, never a separate metered surface. Every launch declares each role's
billing surface in plain color — green for your own plan, blue for free
external capacity, red for real spend — with the signed-in account shown, and
red surfaces refuse to run without an explicit consent flag plus a
confirmation, with an audible cue so a spending run is never silent. The
research behind the classifier (how each supported platform actually bills
headless work) ships with it.

Skills that remember. Skills now keep their accumulated learned notes in a
sidecar that survives reinstall and update — what your agents learn on your
project stays yours.

Installer fixes from the field. Installing overlays for more than one IDE
no longer collides (per-platform capability-gap files), the framework guide is
provisioned at install, and fresh setups build the current project layout.

Also in this cut: a one-command multi-app install plan, a live view of
running agent streams, run-shape advice from your own run history, a portable
flash-drive mode that keeps state across machines, faster duplicate-work
detection in the dispatch path, guarded agent record edits, and per-cut backlog
health stats published right in the repo.

v5.0.0-beta.41

release: v5.0.0-beta.28

v5.0.0-beta.40

Theme: the loop grows judgment.

Hours after the last beta, this one lands the reliability batch that a day of live field runs
asked for — plus the first slice of the biggest architectural change the autopilot has had.

• A pre-review gate with zero model cost. Before any reviewer is spawned, a deterministic
  gate checks the obvious: does the branch build, does the diff exist, is a release-note entry
  required and present (now computed from the diff itself, not assumed). Bad handoffs are bounced
  in milliseconds instead of burning a review.
• Finish gates before credit. A harvested implementation only counts once its gate commands
  pass on the exact commit being credited; failures are cached by commit so an unchanged failure
  is never re-run, and the credited count can no longer be inflated by rescue commits.
• One family tree, one author. The supervisor's spawn ledger is now the only authority on
  the agent family topology — contradictory records are dropped and logged, seeds are atomic,
  and a torn or oversized ledger fails closed to a flat family instead of guessing.
• Single-writer board, slice one. Per the newly ratified design, reviewer verdicts can now be
  emitted as structured outcomes for the orchestrator to apply — the first step toward children
  that never write the board at all (off by default while it soaks).
• Interrupted bug fixes resume. The one-shot continuation that already rescued interrupted
  task branches now covers bug fixes too, and a busy checkout defers a merge instead of
  discarding a finished fix.
• Issue harvest, both halves. A pull consumer fetches classified inbound issues from the
  server with local persistence and dedup, and an absorb step routes them: defects become
  inbox bug drafts, enhancements arrive gated for a human decision — nothing self-starts.
• Knowledge ingestion revived. The scheduled backlog ingestion system (status, tick, seed,
  schedule enablement, health check) is live, with a data-restoration follow-up tracked.
• Database rebuild coverage. Rebuild and per-kind index regeneration now cover every record
  class, and the doctor diagnoses board-ingest drift with a matching heal.
• Honest costs. Cache reads are surfaced on the priced cost path, and search no longer pays
  a full-repository walk when given a path.
• Containment hardening. Worktree-sandboxed workers are refused git writes outside their own
  worktree; an acceptance criterion phrased as a human decision can no longer be ticked by an
  implementer; and the push-lock posture is generalized beyond the main repository.

v5.0.0-beta.39

Theme: an autopilot you can leave running.

This beta is mostly about the autopilot loop finishing what it starts. Two days of monitored
multi-lane runs surfaced a family of boundary failures — work lost between runs, verified work
demoted because of a merge hiccup, fixes dying at rebase for reasons that were never content
conflicts — and each one is closed in this release:

• Interrupted work resumes. An implementation branch interrupted by a stop or a run boundary
  gets one automatic continuation on its own branch instead of being parked or re-implemented from
  scratch.
• A reviewed PASS is never demoted. If the merge can't land yet (dirty checkout, ordinary
  main-branch drift, a policy question), the verified work waits with its branch intact and the
  merge is retried or escalated — never rolled back for another implementer lap. Ordinary drift
  now merges automatically (replay, then merge-commit fallback).
• Bug fixes no longer die at rebase. The board record synced into a worktree could block the
  rebase onto main; the loop now restores it before any tree switch.
• Merge gates are scoped correctly. Retired constraints are never enforced; the record-integrity
  check only looks at the branch's own commits; workspace-internal Go module wiring is recognized as
  in-scope (third-party dependency additions are still refused without explicit scope); and the
  slim-layout subdirectory rule no longer fires on full controllers.
• Release notes survive the pipeline. Each landed change's changelog entry now rides its branch
  through review and is transplanted onto main at merge — nothing is silently dropped.
• Operator controls. autopilot stop drains in-flight work cleanly (--now aborts); per-role
  --effort levels; providers explain prints a per-role provider/model resolution receipt; epics
  are never dispatched unexpanded; the hot inbox is absorbed before every spawn.

Also new in this beta:

• Backup and restore for the project database and markdown tree, plus automatic pre-migration
  snapshots with a tested restore path.
• Record-mutation core: typed update functions and MCP update tools for every record class, so
  agents change records through code rather than by editing markdown.
• Memory and vault: sharing brackets (private/team/company/global) with scope-aware recall;
  a retrieval-trajectory ledger for vault search; salience decay and dedup for learned facts;
  layered abstract overviews for skill catalogs and research sections.
• Coordination: inbound messages delivered into a running autopilot session; a phone-originated
  steering prompt relayed into a live session and its reply back; typed session handoff records;
  typed path locks with a crash-resumable operation queue.
• Throne: a live Backlog Momentum panel on the project display; email OAuth wiring.
• Tooling: gald3r shutdown stops the MCP server and resident daemon gracefully; gald3r xreview
  cross-vendor review; a code-graph subsystem scaffold with Go extraction; format-preserving
  platform install/uninstall of native agent configs.

v5.0.0-beta.38

This release closes the most expensive failure mode reported from live autonomous runs: work that fails review over and over, silently burning budget with no human ever told.

Autonomous runs now know when to stop and ask. An item that fails review three times is parked for human attention instead of being sent back to the AI again -- and a reviewer that gives up mid-review now counts as a failed review instead of leaving the item stuck in the review queue forever. Records that exist only in the database with no backing file can no longer be offered to reviewers at all, ending the loop where one broken entry starved every other piece of work.

v5.0.0-beta.37

This release closes the second wave of field reports from live multi-agent runs — every fix below was reproduced from a real field failure and shipped with a regression test.

Autonomous runs can no longer hang, lie, or burn silently. A vendor CLI that stops producing output is now detected within minutes and its process tree is cleaned up, instead of holding a work claim for hours. Every run — including crashes — now ends with a final summary block, and any leftover child processes are reaped at run end. Cost telemetry reports honest numbers: usage that cannot be priced is labeled as unpriced instead of rendering $0.00, and a new safety breaker halts a run that accumulates too much unpriced usage. Dry-run mode is a true no-op again — it can no longer release live claims or create commits. And the status view no longer claims lanes are "running" hours after the run ended.

The project board is harder to corrupt. Editing a constraint no longer destroys its definition text; constraint entries land in the right sections with correct, never-reused IDs. Task dependencies, titles, and descriptions are now editable straight from the CLI, with renames preserving identity and history. Every record move now regenerates the file at its destination and verifies nothing was lost before removing the original — a record can never be lost or fall out of version control mid-move. Deleting a record works even when git's index has drifted, and database rows can no longer be orphaned by a delete — an audit flag plus a prune verb keep the database and files agreeing.

Work drops in faster. Task and bug drafts dropped into the hot inbox are now picked up before every agent spawn during an autonomous run — not just once per cycle — so new work becomes dispatchable the moment a slot opens.

Upgrades and health checks tell the truth. Project upgrades now stamp the version they migrated to (not from), and heal files stamped with mixed values on the next run. The doctor now warns loudly when the coordination folder is invisible to git — the precursor to silent data loss a field site hit.

Cross-project messaging is more resilient. Inbox message ages render correctly instead of always showing zero, malformed subjects can no longer break the inbox table, and sends fall back to direct file delivery when the central transport is unavailable — the message arrives either way.

v5.0.0-beta.36

This release hardens the autonomous pipeline based on the first wave of beta.35 field reports — every fix below came from watching real multi-agent runs at three field sites.

Review gate integrity. Implemented work is now held off your main branch until the independent review actually passes. A failed review leaves main exactly as it was and keeps the work aside for the retry — rejected changes can no longer slip onto main or become the base for the next attempt. Loaded project constraints are also enforced as a hard pre-merge gate, so a change that steps outside its declared scope is refused at merge time instead of merely being mentioned in context.

Smarter dispatch, less waste. The autopilot now recognizes when an open bug was already fixed in code and closes it with provenance instead of spending an implementation slot proving there is nothing to do. Field runs were losing roughly a third of their budget to these no-ops; that waste is gone.

Cleaner operations. Parallel agent sessions no longer collide over shared editor configuration on Windows. A crashed run no longer leaves a stale coordination lock that blocks later housekeeping — dead locks are reclaimed automatically, with a manual --break-lock escape hatch. Status history now records what the agent actually said rather than raw protocol output. And bugs waiting on something external can now be marked Blocked, with their own section in the bug index.

v5.0.0-beta.35

5.0.0-beta.35 -- the tight-ship build. Every leak, lie, and blind spot the
field found in the loop this week is closed -- eleven verified fixes, shipped
the morning after the reports came in.

The dispatcher obeys its own math. Excluded or ineligible work can no
longer be spawned anyway: the scheduler consumes exactly the eligible list it
computed, so an empty queue spawns nothing and a named skip means what it says.

Failures can never masquerade as successes. A failed attempt that left no
commits can no longer be mistaken for already-merged work; the run narration
and final tallies always derive from the recorded verdict (with a loud warning
if anything ever disagrees); and a pass whose evidence lives only in files the
installer regenerates -- or whose own review admits nothing changed live -- is
refused outright.

Hangs are caught in minutes, not hours. Liveness now watches the vendor
tool's own progress counter instead of the wrapper's chatter, and a session
producing no thoughts trips its own alarm.

Money is governed everywhere. Providers that report usage without prices
now surface real measured tokens (never a silent zero), and any provider the
cost meter cannot read fails closed by default -- an unattended run cannot burn
unmetered.

State stays true. Multi-line notes no longer desync the database from the
files (one normalization at the single write seam); a teardown-instant race can
no longer steal a work item's slot (the gate retries once and names transient
faults honestly, and any slot genuinely lost is counted in the summary); and
the loop now picks up queued drafts and cross-project messages at every
iteration boundary instead of leaving them stranded.

A clean, fast, honest patch train -- exactly what week-two hardening should be.

v5.0.0-beta.34

5.0.0-beta.34 -- the safe-hands build. Your money, your work, and your
results are all handled with surer hands this release.

Idle never burns. An autopilot run with nothing dispatchable no longer
pays a coordinator to rediscover an empty queue -- the loop skips the spend
outright and halts cleanly under a new idle-iteration limit (default 1).
Startup summaries now count ready work with the same rules the dispatcher
uses, so "eligible" always means "dispatchable."

Success is never punished. A fix that legitimately requires no code
change -- already-fixed items, documentation-only defects, duplicates --
now counts as the success it is: the resolve action itself is first-class
evidence, so no more false failures, phantom capacity violations, or
throughput downgrades for doing the right thing.

Crashed work lands safely. When an agent session dies mid-task, its
in-progress work is preserved on a dedicated rescue branch -- never merged
onto your working branch unreviewed. The run names the rescue ref so you
can cherry-pick once it has been looked at.

Coordination messages never vanish. Rebuilding the cross-project inbox
now unions the message files on disk with the database -- file-only messages
survive, newer statuses win with a warning, and line endings round-trip
byte-for-byte.

Voice, in preview. A new local voice layer: push-to-talk chat against
your existing setup, with the full transcript always on screen -- spoken
content is never audio-only, by construction.

Sharper agent messaging. Messages can be scoped to a subsystem so only
the agents working that area receive them, and held messages gain an
approve step before delivery.

Plus: run summaries surface requires-attention and skipped-work counts,
test-infrastructure reliability fixes on Windows, platform hook-path
corrections, and a deep round of maintenance that cleared forty
long-standing test failures and the product defects hiding behind them.
Under the hood, this release also lays the complete backend foundation for
the next generation of the desktop experience.

v5.0.0-beta.33

The honest-numbers build. Every number the loop reports is now true,
and every dollar it spends is governed.

• The cost governor is real. The loop now reads each agent's actual
  reported spend (the data was always there -- now it's parsed), so the
  final cost figure is truthful and the spending ceiling actually stops
  a runaway. Budgets are hard: retries and resumes count as spends, and
  a run can never start more agents than you budgeted.
• Health gates can't self-deadlock. The loop's own database files
  are guaranteed ignored at every surface -- setup, upgrade, doctor,
  medic, and the pre-run gate -- and the housekeeping classifier treats
  them as the local caches they are. The first-run deadlock a tracked
  database caused is structurally gone, and automated rescue commits
  can never sweep a database or unsafe file into your history again.
• Verification can't be falsely emptied. A review that never ran --
  blocked by a gate, a failed spawn -- no longer counts against any
  task; only reviews that actually rendered no verdict do. And items
  detected as already-landed get their free review the same run,
  ending with a real verdict instead of parking unverified.
• Diagnostics tell the truth. Capacity messages report what the
  dispatcher actually did ('2 dispatched, 0 landed' vs 'none
  dispatched'), name the real blocker when items were refused before
  launch, and the final summary's numbers all derive from the run's
  own event ledger -- one source, no contradictions. Tasks whose
  acceptance criteria live in ignored paths are flagged at queue time
  instead of burning an agent to discover it.

To verify a download: each release asset ships with a SHA-256 checksum file;
compare with certutil -hashfile <asset> SHA256 (Windows) or
shasum -a 256 <asset> (macOS/Linux).