kari v0.11.2

kari v0.11.2 — built from 9d9aea6.

This release stops autopilot from repeating a run.

Autopilot took one card again every 30 minutes, for as long as the trigger
held. The card had already run and its result waited in Review. Each repeat
forked the session, added a card to the board and spent quota on work that
was finished. A card now leaves the plan after one run and waits for you.

TL;DR

• Stop autopilot from running the same card again every half hour
• Keep the text when a send fails, and name a version skew

What changed

Stop autopilot from running the same card again every half hour

Autopilot ran one card 11 times in one day. Every run forked the session, so
the board grew a card for each fork, and each run spent quota on a
conversation that was already finished.

Two rules made the loop. An accepted plan stops being live 30 minutes after
it starts, and the panel clears. The planner then looks again, the
weekly-reset trigger is still true for 36 hours, and the card whose run
finished is still the top candidate, because the candidate filter dropped
only the states that wait for an answer: needs decision, needs approval,
working and done. A finished run gives the state validate, which the board
shows in Review. The planner took it again, and again.

The planner now leaves every card whose run ended. The card remembers the
outcome of its last run in last_job_state, so done, failed and stopped all
count, and the state validate is on the list of states that belong to the
user. A card leaves the pool after one run and waits for a person.

A manual move to Ready now settles the outcome of the last run, beside the
moves to Backlog and to Done that settled it before. That move is the way
back: drag a card out of Review onto Ready and the planner can take it again.

Keep the text when a send fails, and name a version skew

Two failure paths cost the user the message they typed.

The phone emptied the reply box before it started the request, and nothing
put the text back when the request failed. The desktop composer did the same.
A phone sends over a link that drops, so the cost fell on the user.

Act now resolves true or false, so a caller that holds typed text can wait
for the outcome. Both composers empty only after the send goes through. One
tested predicate, clearsBox, holds the rule: the send went through, and the
box still holds the text that went. Anything typed while the send was in
flight is a new message, and it stays. The phone also disables Send while one
send is in flight, so a slow link cannot take the message twice.

The other path was a bare 404. An older server does not have the route the
button calls, and the user read "404" with no idea what to do. Every handler
answers with a JSON error message and the router answers an unknown route
with an empty body, so an empty 404 on a /kari/v1/ path means one thing:
the far end runs an older kari. The shared error path says so now, and every
call gains it, not the send alone. A 404 that carries a message keeps it,
because a handler answered and that is not a skew.

Install

Download the .dmg for your Mac: aarch64 for Apple silicon, x64 for Intel.
The app is not signed. After you copy it to Applications, run:

xattr -dr com.apple.quarantine /Applications/kari.app

On Windows, run kari_0.11.2_x64-setup.exe. It installs for the current user,
because kari reads the Claude Code state of whoever is logged in. That installer is
not signed either, so SmartScreen asks once: More info, then Run anyway.

An installed kari updates itself to this release: it checks on start and every six hours,
writes the new version beside the running one and offers a restart. Settings, Updates has the switch.

Every host runs the headless node, so that its sessions stay on the board while no window is open.
A Mac takes kari-node-v0.11.2-aarch64-apple-darwin (or the x86_64 one),
a Linux host kari-node-v0.11.2-x86_64-unknown-linux-gnu.tar.gz,
a Windows host kari-node-v0.11.2-x86_64-pc-windows-msvc.zip.
Run kari-node service install to keep it running at login. One engine runs on a host at a time:
open the app and the node steps down, quit the app and it takes the host back.
A node updates itself only when asked: kari-node update, or serve --auto-update.

An Android phone installs kari-latest.apk. Add this repository to Obtainium: the asset name never
carries the version and the signing key never changes, so an update installs over the previous build.
The phone reaches the nodes over a private network, such as a VPN, and pairs with the code from
Settings, Nodes on the desktop. See TOUR.md.

See the README for requirements and setup.