Baixar wmux 3.51.0 per a Windows

### Added

• **Pasted screenshots can reach the agent as real images.** Pasting an
image-only clipboard into a pane used to write a temp PNG and type its path —
the only route an agent ever saw. Claude Code reads the clipboard itself when
it receives its image-paste key, so it now gets a real inline image instead of
a file path. Settings › Terminal › Image paste picks the route：Auto (the
default) uses it for panes running an agent known to read the clipboard, and
falls back to the file path everywhere else. Pasting text is unchanged. (#1209)

• **Optional：put the workspaces that need you at the top of the sidebar.** A new Appearance setting, "Needs-you rows first", lifts every workspace whose agent is blocked on you to the top of both the sidebar list and the collapsed rail. It is off by default, because a list that reorders itself while you are scanning costs more than the scan it saves. Turning it on changes the display only — Ctrl+N still numbers workspaces by their real position, and the stored order is untouched. Drag-to-reorder is paused while it is on, because a drop aimed at the order you can see would land at the order underneath it.

• `browser_type` takes a `selector`, for an element neither snapshot handed out a number for. It is CSS on every transport — a Playwright engine prefix (`text=`, `xpath=`, `>>`) is refused rather than accepted on one lane and not the others — and it must match exactly one element, the same uniqueness rule a ref carries.

• `browser_type` takes `newline：'enter' | 'shift-enter'`, which splits the text on `\n` and presses a real key between the lines instead of inserting a newline character a single-line input or a rich-text editor drops. Default stays `literal`, today's behaviour. If a keypress submits the field, the remaining lines are not typed into whatever the next page focuses: the type stops and reports how many lines went in.

• `browser_snapshot` takes `q`, keeping only the nodes that match it (case-insensitive substring, or `/pattern/flags`) plus their ancestors — a way to ask a 250-option listbox one question instead of reading it whole.

• Task ledger：a status log keyed by WorkTask id (`~/.wmux/task-ledger.jsonl`, WMUX_DATA_SUFFIX-scoped) recording `working → input_required / review_requested → completed / failed / cancelled` with compare-and-swap revisions, actor authorization and a gate-pass requirement for `completed`.

• MCP：`ledger_update` (every profile) lets a fan-out worker record `review_requested` / `input_required` on its own task; `ledger_list` is a commander-only tool (registered only under `--commander`, never in the full or core profile) that shows the brain the tasks it owns. Fan-out prompts now tell workers to report through the ledger instead of a chat "done".

• Orchestrator：`deck.ledgerGate` (default off, `~/.wmux/deck-ledger-gate.json`) makes the brain's Stop gate hold a turn while the ledger lists open tasks it owns, with the existing consecutive-block cap and hysteresis; while on, `deck_ask_decision` shows the human the open-task list.

• Every ledger transition is posted to the task's mission channel as `[ledger] <task> <from>→<to> <by> <summary>`.

• **An orchestrator can now finish the tasks it starts.** Fanning out could open
N isolated tasks, and then nothing：running a task's completion gate, taking
its changes back into the parent repository, opening its pull request and
closing it were all reachable only from the desktop UI, so a supervising agent
could do nothing but ask you to click four times per task. It can now do all
four itself, and read a task's git status, recent commits and PR state as data
instead of guessing from a terminal screen. It can also stop a gate that is
still running, rather than waiting out a hung test suite for fifteen minutes.

• **Closing a task or opening its PR asks you first.** Those two are the ones
nothing can take back — one removes a git worktree, the other pushes a branch
to your remote — so each raises the same approval prompt a fan-out does, naming
the task, its branch and the exact commit it points at, and auto-denying if
nobody answers. If the worker pushes another commit while the prompt is up,
the pull request is refused rather than sending something you did not see.
Running a gate and adopting a task's changes do not prompt：a gate run is
reversible by ignoring it, and adopted changes land staged and uncommitted.

• Tasks can now be finished from an agent, not only from the GUI：`task_gate_run`
runs a task's completion gate (its trusted verify script, or npm lint + test)
inside the task's own worktree and reports a structured verdict; `task_adopt`
takes all of a task's changes into the parent repository as a staged,
uncommitted patch; `task_close` and `task_pr` close a task or open its pull
request. Each refuses with a named reason — a dirty worktree, unpushed
commits, missing dependencies, a task branch that needs rebasing — instead of
failing silently, and an adopt that will not apply cleanly leaves the parent
repository untouched.

• `git_status`, `git_log` and `gh_pr_view` read a task's worktree as data, so a
supervising agent no longer has to infer what a task produced from a terminal
screen.

• `approval_press` — an orchestrator brain can now answer an approval prompt on
a fan-out worker **it delegated**, instead of typing the digit `1` at whatever
happens to be on that worker's screen. The press resolves the approval record,
so the prompt is confirmed to still be there, the operator's autonomy policy
decides whether it may land, and the decision is written to the approval
history. `decision` must be given explicitly — there is no default, and an
unnamed decision is never taken as an approval. A pane holding more than one
pending approval is refused as ambiguous rather than guessed at, and the tool
hands back the ids to choose from. On a pane wmux holds an approval record
for, a brain's `terminal_send` / `terminal_send_key` is refused and points at
the tool — except `ctrl+c` and `escape`, which still go through so a runaway
worker can always be interrupted. If the press is refused because the operator
has autonomy or approval-press off for that worker, the block lifts so the
brain is never left with no move at all. Your own typing is unaffected.

• Approvals raised by a permission gate now carry `deadlineAt`, the moment the
gate really stops waiting — reported by the gate broker that holds the timer,
so a surface can show an honest countdown.

• **The Deck says what is delegated.** A status panel pinned above the orchestrator conversation lists every open task from the task ledger — title, status, what the worker doing it is up to, its last ledger line and how long it has sat there. It refreshes the moment the ledger moves, collapses to nothing when no task is open, and opens the report rail once while work is outstanding. If the ledger cannot be read at all the panel says so rather than collapsing — "nothing is delegated" and "I cannot tell you what is delegated" are opposite facts.

• **`deck.ledgerGate` has a switch.** The ledger-backed Stop gate — hold the orchestrator's turn while the ledger still lists tasks it delegated, instead of guessing from pane activity — could previously only be turned on by hand-editing `deck-ledger-gate.json`. It is now a toggle in Settings › Agents, labelled experimental, writing the same file the gate reads, so the choice survives a restart.

• **The deck header names the approval deadline.** An approval raised by the orchestrator's own delegation auto-rejects on a timer; with the Claude Code terminal filling the deck, the dialog could sit behind it and the expiry looked like the orchestrator stopping for no reason. The header now counts the deadline down, and turns red for the last ten seconds.

• **Turns say which brain wrote them.** Switching the orchestrator brain mid-session left one log holding turns from two brains that share no transcript and no session. Each turn now carries a short tag for the brain that produced it, and a labelled break separates the runs. Turns from before this change show no tag rather than a guessed one.

• Channel composer now tells you where an @mention will actually land：a mention
of a roster member is pinned to that member's own agent pane (the only shape
that reaches an idle agent), with a "will reach …" hint under the input. A
member with no live agent pane is offered as a badge-only mention and labelled
as one instead of silently reaching nobody.

• Channel messages you post now show what actually happened to them：delivered
as soon as any recipient got it, target gone when none did, and "no answer —
nudges exhausted" when the wake worker gave up on a mentioned agent. A post
that never gets an outcome now reads "delivery unconfirmed" instead of
claiming to still be sending forever.

• Fleet's approval inbox shows the auto-reject countdown on every approval that
has a deadline, and keeps a short "auto-rejected" log of the ones that expired
while you were away instead of letting them vanish like an answered prompt.

• The Missions section header now opens the task cleanup scan, and a close that
fails on a worktree still holding uncommitted work offers two next steps on
the row itself："Commit & close", which types a ready-to-run
`git -C <worktree> add -- <the changed paths> && git -C <worktree> commit -m
"wip：<task>"` into the task's own shell without running it, and "Open
worktree". The commit line is offered only when the task's pane is a shell (in
an agent's TUI it would become a chat message) and only on POSIX shells.

• **`task_adopt` can commit what it takes, so several tasks can be adopted in a
row.** Adopt left its changes staged, which made the first adopt easy to review
and the second one impossible：the target repository was now dirty, and adopt
refuses a dirty target ra