Release notes

What changed in each release that a person or an agent using Stoat would notice. The GitHub releases at https://github.com/JasperFx/stoat/releases carry the same notes.

0.6.0

The second public preview. Stoat is still free on its own machine, and the licence check for other machines is still off. Upgrade with dotnet tool update -g Stoat, then run stoat setup again in each repository you wired: it adds the new session-context hook and changes nothing else of yours.

The plan page

• Five classes on every card: ✋ you, ⨯ broken, ⏸ held, ⟳ moving and waiting, from the server, so a card, the needs panel and plan_status agree. A waiting card names what it is ultimately waiting on, across plans: waits on p0-sdk (✋ your go-ahead). See Reading the plan page.
• A lens: All · ✋ You · ⨯ Stuck · ⟳ Moving mutes everything else, and a muted waiting card traces its path to its blocker. A stalled plan opens in ✋ You.
• Bands per repository, upstream repositories first, each headed by that repository's runner, CI toggle, hold, ready count and approve all N. Bands lay out only the columns they use, and fold.
• What the plan needs from you at the top of the page, grouped by action, with a "stalled" banner when work waits and nothing runs, kept reachable as a one-line bar while you scroll.
• Views: Graph, Table, Activity and YAML. The table lists what needs you first and gives or withdraws go-aheads in bulk.
• Keyboard shortcuts for the whole loop: move by reading order or by what needs you, jump to a card's root blocker, search by id, title or PR number, act on a card, and ? for the list.
• Merge order: merges are listed in the order they should land, and a dependent's says what it waits on (after #790 (weasel-tfm): this depends on it).
• Cards read at a glance: two-line titles, 🔎 / 🤖 for the merge policy, ⛰ heavy and 🔒 exclusive toggles, 👤 for a person's step, and each need names its repository.
• Repository icons: a repository with a favicon of its own (in its tree, its docs site's preferred) shows it beside its name everywhere: band headers, cards, needs chips, plan pills, the Table, the Repositories and Agents pages and the ready board. Found through the GitHub token once a day per repository. See Repository icons.
• Rename a plan from its title's ✎ (the title only).
• The machine's controls (agents working now, the machine's hold, its session limit) moved to the top bar, and the top bar fits a 1,024-pixel window.
• Work through what waits on you one item at a time, from the ⚑ menu.
• The zoom's merge-policy button uses the card's 🔎 manual review / 🤖 merge on green, and the / card picker takes typing as soon as it opens.

The Agents page

• Rebuilt around the plan's own cards: every live agent once, as a runner's worker (its kind, attempt, model, how long, how recently its session did anything, a running gate step), a plan's lead (alive or not, its questions, how many it escalated), a session holding claims (an ended one still holding reads "gone, still holding"), a live session holding nothing, or an ended one.
• quiet 47m marks an agent at work with no tool call for ten minutes; a resume command is offered only for a session that is gone. See Watching the agents work.

The runner

• Start a runner from the plan page: a band with no runner has Start…, which shows the exact stoat run-plan … --watch command and runs it, detached, on the server's machine. Only Stoat's own page on this machine can start one. See Starting a runner from the page.
• Every worktree starts fresh, from a fetched base, never the checkout's HEAD; a retried worktree with nothing of its own is fast-forwarded first. The launch line names the base and its commit.
• Fix budgets by cause: a rebase another PR's merge forced spends --max-rebases (default 5); the agent's own trouble spends --max-fix-attempts. Both are kept on the node, shown on the card's PR line (rebase 1/5, fix 2/2), and survive a runner restart.
• A reply on a fix callout resumes the agent with your words and one more attempt, recorded as yours.
• A resolve worker rebases a PR on the runner's own branch when its agent cannot be resumed.
• Questions are kept on the plan: what an agent's attempt ended on survives a runner restart, holds the node until answered or dismissed, and an attempt that ends on a question spends no attempt.
• The runner keeps a running agent's claim renewed, so a long task never loses its node.
• One runner per plan, host and checkout; a plan across repositories has a runner per band.
• The local package train: a publish on a local folder feed is packed by the runner (with the repository's recorded declare_repository_pack recipe, or an agent that works one out), pins are promoted on the branch without touching a working copy, and rehearses: replays them to the real release. A real release due on a default branch gets one pin-bump PR per repository; bumped_by names a node that moves a pin itself. See Local packs.
• Partial work is held: a worker reports what it left out (report_node leftOut), the node reads partial and its dependents wait until a person accepts it, and an acceptance can be sent back.
• Nodes a person does: kind: person or assignee: person. No agent claims one, and only a person's node can be marked done.
• Runners create issues (a plan toggle, off by default) for an approved unbound node.
• Which skills a node uses (skills: on the node or the plan), named in every worker's prompt.
• Cost and tokens per model, per node and per plan (plan_usage).

The machine

• Session limits and holds per repository and for the machine, kept by the server across every plan and runner, from the page or stoat limit.
• Heavy work (uses: [heavy], or a resource with scope: machine) runs one at a time across every plan, enforced on every claim and stoat gate exec.
• Exclusive nodes (exclusive: machine) keep the machine to themselves once it drains.
• A plan's agent cap across every runner and every agent working by hand.

Gates

• A red step says what kind of red: build ✕, tests ✕ 12, timeout ✕, gone ✕, with the failing tests named on the chip's tooltip and listed in the zoom.
• A red gate becomes findings: its worker diagnoses the failures by cause with submit_review, and a person accepts each as an issue or a person step the gate then waits on.
• A gate says what it proved: proven at 96b9202 · dirty · 22 behind main. A dirty pass, or one behind its release branch while something waits on it, reads stale, not done; a person may accept it as it stands.
• ⟲ re-verify resets every step to pending until it runs again.
• A green stoat gate exec run is never outvoted by the Bobcat runs it launched, and a running gate is never read as finished.
• A gate with no steps reads the units of a Bobcat Gate under its tag.
• Local gates stand in for CI: a repository gate declared with role: commit or push, run with stoat gate run, and, where a person allows it, read by merge-on-green in place of CI.

Merging and CI

• CI off on purpose, per repository: workers prove their change locally and stop at the open PR, and your review stays yours. A conflict resolved while CI is off waits for the commit gate on its head.
• Landing: an issue done with its PR still open (done · landing #790) is not done for its dependents.
• Merge-on-green waits for every dependency of its node.
• A PR attaches to its node however it is worded: report_node's pr links a Part of #n PR.
• The node whose merge turned main red says so, and the runner proposes a fix node for it (or a person adds it) that waits for a go-ahead; the PRs red only because of main wait on it.
• A consume is measured against the newest release, and a version diamond is said on the pin.
• An open PR is the card's next action, and says whose move it is.

MCP and the lead

• 91 tools (71 in 0.5.0). A plan's live lead may relay a person's decisions with 18 new tools (approve_for_agents, set_merge_policy, accept_partial, accept_stale_gate_pass, decide_review, set_session_limit and the rest), each naming the person in relayFor and recorded as theirs with the lead beside it. See Relaying a person's decision.
• New: plan_usage, declare_repository_pack, propose_base_fix. add_plan_node documents the person kind.
• The await_* tools default to 240 seconds (await_dependencies, await_package_version, await_memories, await_run_completion, await_questions), under a client's usual tool-call timeout, so a client never cuts a wait off. On a timeout, call again.
• ask_person parks at most about four minutes per call (Stoat:AskPersonParkSeconds) and then answers pending with the question's id, so a client's tool timeout never cuts it off.
• The worker profile adds failing_tests, failing_spec, flaky_ledger and declare_repository_pack (16 tools).
• A new guide page: Stoat as a work queue for a lead agent.

Notifications

• Discord (Stoat:Notifications:Discord:Webhook), one embed per notification, which pings nobody.
• On macOS, notifications come from Stoat through terminal-notifier when it is installed, and a click opens the node.
• On by default now: question, give-up, review, person, stalled, limit, main-red and drift (person, a node of yours came ready, and stalled, a plan with work waiting and nothing running, are new), read from the same status as the cards. A burst (a restart with forty PRs open) is capped at five, with the rest summed up.

Setup and sessions

• stoat setup adds a sixth hook: a session opening in a repository Stoat knows hears its ready work, claims and memories.
• It registers the server's local folder feeds with NuGet on this machine, says which skills your plans use that are not installed, and says when terminal-notifier is missing.
• Session states read what Claude Code writes now: awaiting-input comes from the session file, and a session that ended while Stoat was down is closed on the first sweep.

0.5.0

The first public preview, released beside CritterWatch 1.1: plans, GitHub, NuGet and npm observation, claims and the agent roster, memories, session journals, the chapter runner, the run receiver, a plan's lead agent and 71 MCP tools, installed with dotnet tool install -g Stoat and wired with stoat setup.