playbook: publish every client edit, and re-converge when one is rejected (#1103, #1104, #1089)

[edwin-zvs]

Fixes #1103, #1104 and #1089, and turns on the regressions #1114 landed #[ignore]d.

(Replaces #1115, which GitHub auto-closed when its base branch was deleted on the #1114 merge. Same commit, rebased onto main.)

These are one bug wearing three hats. A Playbook is a document a human and an agent hold at once, so an interactive client owes it two things: publish every local mutation, and re-converge when a publish is rejected. The TUI was doing neither on some paths, and the failure mode was invisible — a correct-looking buffer that had stopped talking to the daemon in both directions.

#1103 — paste never published

on_paste inserted into the buffer and returned. Every keystroke path snapshots the buffer and calls flush_playbook_live_edit; this one didn't, so a pasted block lived only in the client. Worse, the next keystroke's anchored edit was then derived from a base the daemon never received, so it failed too — and so did every one after it.

Paste now goes through insert_playbook_text_synced, which inserts, follows the scroll, publishes the cursor, and flushes — the same tail handle_playbook_key runs.

#1104 — CR line breaks stored verbatim

Terminals routinely deliver the line breaks inside a bracketed paste as \r (it's what a tty expects for Enter, and what tmux's paste-buffer sends without -r). Nothing normalized them. Stored verbatim they aren't line breaks to anything downstream: the renderer paints them as nothing, so the block collapses to one visible line, and block splitting is newline-based, so it collapses to one addressable block — one shimmer target, one selection-Run target, one opaque line for the agent.

Normalized in two places, deliberately:

• Client, in insert_playbook_text — so the caret lands where the user expects immediately rather than after a round trip, and every ingress path is covered (bracketed paste, clipboard yank, clip insertion).
• Daemon, in both playbook write paths — so "a stored Playbook contains no lone CR" is an invariant of the store rather than a promise each client has to keep. The web UI and MCP writers get it for free.

#1089 — rejected live edits were swallowed

let Ok(result) = … else { return }; dropped the failure. That left saved_markdown stale, so on_playbook_state stopped adopting remote changes (correctly, to protect what looked like unsaved work) — and the document was severed in both directions while the buffer kept accepting input.

A rejected edit now falls back to save_playbook_popup, the same three-way merge C-x C-s performs: it rebases onto the latest document, keeps both sides, re-arms saved_markdown, and sets its own status so the user sees that a merge happened. No new machinery.

A third instance, found while writing the spec

apply_playbook_template — clicking a template button in the empty state — had exactly the same shape: replace the buffer, return, never publish. So a brand-new Playbook, the very first thing a user does with one, existed only in that client. Fixed the same way.

Tests

The two regressions #1114 landed lose their #[ignore] and pass:

test playbook_paste_normalizes_carriage_returns ... ok
test playbook_paste_reaches_the_daemon ... ok
test playbook_recovers_from_a_diverged_buffer ... ok

playbook_recovers_from_a_diverged_buffer is new here, covering #1089. Verified it fails without the fix, for its own reason:

editing never re-converged after a rejected live edit: the daemon is still on "seedXYZ\n"

It opens the divergence with C-x u, which today mutates without publishing (#1088). The assertion is written to hold after that's fixed too — there is then simply no divergence to recover from, and the typed character still lands.

Specs

• 0171-playbook-client-edits-publish-and-reconverge — the rule these three bugs each broke, and the reason the second half (re-converge) exists: a client that stops publishing doesn't lose one edit, it loses all of them, silently.
• 0172-playbook-stores-newline-normalized-markdown — why the store owns the newline guarantee rather than each client.

Binaries

crates/cli and crates/daemon both change, and both live in the single construct binary:

/Users/moon/agentd/.claude/worktrees/fix-playbook-paste-sync/target/debug/construct

To try it: open a Playbook, paste a multi-line Markdown block from your terminal, and check construct playbook get <session> — the structure survives and the daemon has it without saving.