0.66.0
2026-08-24- Added**`nxf next` reads like a list a person can scan — and can be cut without lying about it.** On a real terminal the ticket title is bold, the one field you actually look for and the one that used to weigh exactly as much as the id in front of it; the id and the `↳` epic line are muted; and the priority is coloured along a single ramp from Deep Ember through Ember and Flame down to graphite, so the weighting is visible without reading the label. The ramp maps the canonical priority ORDINAL rather than its name, so it is just as right under a plugin that calls its levels now/soon/later. `nxf next --limit <n>` shows only the head of the list and never cuts silently: a truncated list is headed `showing 15 of 180`, and under `--json` the flag wraps the records as `{"items": [...], "total": 180}`, so a consumer reads the true total instead of inferring it from the array's length. The limit applies last, after `--sort` and after `--label`, so a filtered list discloses how much of your filter you are seeing. Without `--limit` the command is unchanged and complete, and its `--json` payload is still the same bare array. Nothing else changes: `--json`, a pipe, CI and an agent's `prime` context still receive the same plain ASCII, byte for byte, with no escape sequences at all, and `NO_COLOR` / `TERM=dumb` keep the weight while dropping the colour.
- Added**`nxm guide` — memory has documentation now.** Five guides, in English and German, shipped inside the binary and published to the docs page: an introduction, the core concepts (keys and auto-keys, category/reach/references, the retrieval rule that decides where a memory is read, reading order, the reversible tombstone), the complete command reference with every `--json` shape, the `memory_*` MCP tools and what `nxs prime` contributes, and how to bring an existing Claude memory store in. Until now `nxm` had `--help` and nothing else.
- Added**`Engine::withdraw`** — an embedding app can take back a commission that is still parked behind the working copy, the same narrow case `nxc withdraw` covers. The seam already handed out `queue_position`/`queued_behind` on a send receipt ("not started, 3rd in line") with no call to answer them; this closes that.
- Changed**A session can no longer end owing an answer without anybody noticing.** One that ends without answering its thread is given its turn back and reminded — once, naming the thread, both ways to end a turn, and any round it commissioned that is still open — before the sidecar posts anything in its name. Most answer then. One that is reminded and ends silent again is handed back as an escalation, so `escalated: true` on `nxc status` tells the caller that no result exists and somebody has to decide. An escalation is now recognisable in the text the receiving session reads FIRST, on all three paths it can travel (a channel's pass-through, a 1:1 resume, a quorum wake): what it is, that the working copy is held while it stands, and what is expected in return — the flag alone did not help, because an agent reads the message that woke it, not `nxc status`. And every session that owes a reply is told in its system prompt that its turn must end in exactly one of two ways, `nxc reply --thread <id> "<result>"` or `nxc reply --thread <id> --escalate "<what is in the way>"`; that obligation reaches even a persona declared `prime: false`, so a declaration cannot leave out the one rule the engine depends on.
- Changed**The board says what it is waiting for.** `nxc status` gains two operation-level flags: `needs_decision` (somewhere under this root a task was handed back and nobody took it up — read it beside `awaiting_human`, which looks identical and means the opposite) and `holds_working_tree` (the working copy is held somewhere below, so you know whether to go looking at all). `nxc tick` now distinguishes a settled round whose only remaining blocker is a live session, reporting `waiting_for_a_session` instead of `not_due` — the difference matters, because nothing re-checks that one on a clock and this verb is the way out. And a round whose every commission was withdrawn no longer counts as an open operation: `nxc withdraw` discharges the thread you named as well, instead of leaving it waiting for a supervisor whose round had just been taken away.
- Fixed**A step that claims the working copy exclusively now ends when its session's process ends, not when its reply arrives.** A member of a `flow: sequential` channel that answered and kept working used to let the next step start into the same checkout: measured in a real run, a coder replied at 00:16:33 and went on editing until 00:34:27, while the next step had been running since 00:16:36. Sessions now report their own end — `nxc session ended`, called by the agent sidecar's teardown, and `Engine::session_ended` for a host that runs its own runtime — and where that announcement never arrives, the worker's process check answers the next time anything asks. **Nothing re-checks it on a clock:** a channel's declared `timeout:` is a deadline for an *answer*, and a member that has replied has answered, so a lost announcement (a sidecar killed before its teardown, an older `nxc`, a host runtime that never wires `Engine::session_ended`) leaves the round waiting until somebody runs `nxc tick --thread <id>` — which now says exactly that instead of "nothing to do". That teardown is itself bounded now, a five-minute reminder round and a thirty-second timeout on every `nxc` call it makes, because it runs inside the very process whose exit an exclusive channel is waiting for: one call that never returns holds a checkout, not merely a process. Channels without an exclusive working-copy claim are unchanged.
- Changed**For anyone embedding nexus-flow as a Rust library: this jump is purely additive — pin the new tag and change nothing.** Across the whole span the three consumed surfaces (`nexus-flow-facade`, `nexus-chat`, `nexus-memory`) only gained: `Engine::withdraw` takes back a commission still parked behind the working copy; `Engine::session_ended` lets a host that runs its own agent runtime announce a session's end, with `Worker::session_is_running` as the fallback answer where it never arrives; `StatusOperation` carries the two new operation-level flags; and flow's read layer gained `truncate_next` with its `NextPage` result, the one mechanism behind `nxf next --limit` and `prime`'s own truncation. Nothing was removed, renamed or re-typed — `cargo-semver-checks` confirms it against v0.63.0 for all three packages. The one thing worth wiring while you are here is `Engine::session_ended`: without it, a channel step that claims the working copy exclusively falls back to the process check and waits for someone to run `nxc tick`. Read the per-version entries on the releases page for the exact shape of each step.