Every shipped chat-branching feature (ChatGPT, AI Studio "Branch from here", Gemini app rollout, Claude edit-earlier-turn) is full persistence and stops there: fork from any node, parent stays intact, future diverges. None is confluent — there is no merge. The reason is not product timidity; prose has no merge function that preserves anything falsifiable.

The claim: confluence is tractable exactly when the branches emit typed, refutable artifacts instead of prose. That is the difference between a chat UI and a grind harness. The harness is the confluent tier the chat UIs structurally cannot reach.

Okasaki (??, ????) / Driscoll–Sarnak–Sleator–Tarjan (??, a) vocabulary, applied to a thread (confluent persistence is the later addition (??, a); persistence taxonomy per (??, a); prior art: MIT ADS chat, 2025-08):

The fork point is a version node. The carried prefix is path-copying: you do not mutate the shared spine, you copy the path from fork to root and grow a new child. Gemini's "context only up to the fork point" is the path-copy invariant stated in product language.

All four sit on the same rung. The interesting variable is not the tier but whether the fork is a pure function of (parent_version, new_prompt). ChatGPT/Claude forks are (modulo sampling) hermetic; the Gemini family is not, and the tell is in the implementation: AI Studio branching requires Drive persistence, and the consumer app separately does implicit past-chat referencing. A branch that can pull context the prefix does not name is no longer path-copying; it is a fork with an ambient read of mutable global state — a different algebra.

In a chat the leaf is prose; merge(prose_A, prose_B) is undefined, so confluence is "science fiction" (the MIT chat's own phrase). In a grind harness the leaf is an artifact under a contract:

• a Lean example : by …= that compiles, or does not
• a test.check property that holds at N=1000, or shrinks to a counter-example
• a registry field :lean :status populated by exact?
• a TLA+ refinement that model-checks, or surfaces a trace

These do have a merge function: union under the refutation predicate. lemmata.elenchus is the join node. Two branches that each pass their local contract are merged iff their union violates no global invariant; the refuted branch is pruned, not reconciled by hand. Confluent persistence is not exotic here — it is the CPRR cycle with the fork made explicit: Conjecture forks the version DAG, Proof/Refutation labels each leaf, the surviving leaves join.

The slogan: you never merge the conversation; you merge the evidence. The prose is the partial-persistence shell around a confluent artifact DAG.

A fork with no provenance is anthropomorphism: "the model explored option B." A fork in the harness is a ledger event carrying the governance tuple — the same append-only event shape as petclinic-lab:

{:event      :fork
 :ts         #inst "2026-06-13T..."
 :parent     "v2"                      ; version node forked from
 :branch     "v3b"
 :tuple      "[aygp-dr:worker-B:coordinator@env(forklab:workspace)]"
 :prefix-sha "…"                       ; hash of carried context; the path-copy witness
 :note       "alternate refutation path for conjecture F3"}

{:event   :merge
 :ts      #inst "..."
 :join    "v5"
 :inputs  ["v4a" "v4b"]
 :gate    :elenchus
 :verdict :survives ; | :refuted
 :reviewer "coordinator"}

The branch point = a git worktree. The merge authority = the coordinator. The concurrency cap (4 in petclinic-lab) is the same cap here: past ~6 parallel forks, the rebase-after-merge fan-out stops being followable and the join verdict stops being auditable. Branching chats and multi-agent worktree coordination are the same structure at two scales: the chat UI exposes full persistence to one human; the harness exposes confluent persistence to a coordinator holding a merge contract.

Every product respects it (Gemini: context only to the fork point, the rest "left behind"). It is the path-copying invariant, and the harness states it as: the ledger is append-only, :seed is once-per-workspace-lifetime, no event is edited in place. The conversational grandfather paradox — rewrite v2 and invalidate v3..vN — is impossible by construction. Retroactivity is not forbidden by policy; it is unrepresentable.

• Is elenchus as a merge gate associative and commutative over the leaf set? If join order changes the verdict, "confluent" is the wrong word and it is really a sequential fold (which petclinic-lab's serial-merge coordinator already assumes — so maybe the honest model is foldable, not confluent, and the DAG is a picture we draw for intuition).
• What is the right witness for :prefix-sha? Hash of the rendered prefix is fragile to whitespace; hash of the message-id chain is stable but does not capture the sampling seed. The hermeticity claim (R2) is only as strong as this witness.