From d0d2bf561048900853c1d7a561549294fc2f40c0 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Robert=20Sch=C3=A4fer?= <git@roschaefer.de>
Date: Fri, 13 Nov 2026 20:39:33 +0100
Subject: [PATCH 1/5] feat(tree): show each splice's B, U, R and T and pending
 work at a pause

A recursive pull is hard to follow: the drawings show its states, but a
Rust test that pauses it could only print ad-hoc lines of refs and file
contents. A paused pull now gives the splice tree as a table, in the
drawings' terms: per splice the boundary B, synced commit U, rebuild R
and upstream branch T, indented inside its parent, and what the pull did
or still does for it ("pending: merge, after b/").

Commits are labeled like the drawings: by the names a test gives them,
by the scenario label in their subject ("a1: ..."), or as name' for a
rebuild of a named commit. A test reuses the step-by-step page's
setup.bash and checks the table after each fetch, merge and the fold;
the merge states match the page's drawings step-a to step-d.
---
 docs/10-contributing/01-development.md |   1 +
 src/execution.rs                       |  11 ++
 src/lib.rs                             |   1 +
 src/merge.rs                           |  21 +++
 src/pull.rs                            | 225 ++++++++++++++++++++++++
 src/tree.rs                            | 228 +++++++++++++++++++++++++
 6 files changed, 487 insertions(+)
 create mode 100644 src/tree.rs

diff --git a/docs/10-contributing/01-development.md b/docs/10-contributing/01-development.md
index 86dba9c9..922b714e 100644
--- a/docs/10-contributing/01-development.md
+++ b/docs/10-contributing/01-development.md
@@ -55,6 +55,7 @@ the command's `run`. The tool only runs the `git` CLI, so
 | `src/context.rs` | Caller-owned `ExecutionContext`: immutable content-tree cache, validated supplied rebuilds and optional progress observer shared by operations in one invocation. |
 | `src/repo.rs` | `Repo`: discovery, path selection, reading `.splice`, upstreams, keys and what a splice syncs with. |
 | `src/rebuild.rs` | The push rebuild: `rebuild_splice`, `splice_start` (B) and the commit loop `rebuild_walk`. |
+| `src/tree.rs` | `SpliceTree`: each splice's B, U, R and T at HEAD and an operation's work for it, as a text table for Rust tests. |
 | `src/state.rs` | `classify_splice`, the sync state every command acts on, and `splice_in`, the re-rooted cherry-pick behind `merge` and `clone`. |
 | `src/pager.rs` | Paging for `diff` and `log`. |
 | `src/<command>.rs` | One command each: its `run` and its per-splice step. |
diff --git a/src/execution.rs b/src/execution.rs
index 141ef111..21c80854 100644
--- a/src/execution.rs
+++ b/src/execution.rs
@@ -1,6 +1,7 @@
 //! Typed observations and in-memory synchronization drivers.
 
 use crate::repo::{commit_of, Repo};
+use crate::tree::{SpliceTree, Tasks};
 use crate::util::*;
 use std::process::{Command, Stdio};
 
@@ -93,6 +94,10 @@ pub(crate) trait Operation {
     fn finish(&self) -> Res<i32>;
     /// Says what else an --exec hook that stopped the operation left behind.
     fn stopped(&self) {}
+    /// The work done and still to do, per splice.
+    fn tasks(&self) -> Tasks {
+        Tasks::default()
+    }
 }
 
 pub(crate) struct Execution<'context, O> {
@@ -171,6 +176,12 @@ impl<'context, O: Operation> Execution<'context, O> {
         Ok(ExecutionOutcome::Complete(status))
     }
 
+    /// The splice tree at HEAD, with the operation's work per splice.
+    pub(crate) fn splice_tree(&mut self) -> Res<SpliceTree> {
+        let tasks = self.progress.tasks();
+        self.repo.splice_tree(tasks)
+    }
+
     fn checked<T>(&mut self, result: Res<T>) -> Res<T> {
         if let Err(failure) = &result {
             self.failed = Some(*failure);
diff --git a/src/lib.rs b/src/lib.rs
index 180eccad..0c9b5a0c 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -19,4 +19,5 @@ pub mod rebuild;
 pub mod repo;
 pub mod state;
 pub mod status;
+pub mod tree;
 pub mod util;
diff --git a/src/merge.rs b/src/merge.rs
index fc25c556..b61ae463 100644
--- a/src/merge.rs
+++ b/src/merge.rs
@@ -7,6 +7,7 @@ use crate::fetch::{FetchFailures, FetchPlan, FetchResults};
 use crate::message::{self, Message, KNOWN};
 use crate::repo::*;
 use crate::state::*;
+use crate::tree::Task;
 use crate::util::*;
 use std::collections::HashMap;
 
@@ -870,6 +871,26 @@ impl MergeProgress {
         matches!(self.phase, MergePhase::Done)
     }
 
+    /// Each splice merged, failed or left in a conflict so far, and each still to merge.
+    pub(crate) fn tasks(&self) -> Vec<(String, Task)> {
+        self.paths
+            .iter()
+            .enumerate()
+            .map(|(index, path)| {
+                let task = if self.skipped.contains(path) {
+                    Task::Conflict
+                } else if self.failures.contains(path) {
+                    Task::Failed
+                } else if index < self.next {
+                    Task::Done
+                } else {
+                    Task::Pending("merge")
+                };
+                (path.clone(), task)
+            })
+            .collect()
+    }
+
     pub(crate) fn advance(&mut self, repo: &mut Repo) -> Res<()> {
         if let Some(event) = self.advance_event(repo)? {
             repo.context.emit(event);
diff --git a/src/pull.rs b/src/pull.rs
index ab20d83c..7de5b6eb 100644
--- a/src/pull.rs
+++ b/src/pull.rs
@@ -7,6 +7,7 @@ use crate::fetch::{FetchPlan, FetchResults};
 use crate::merge::{apply_merge_options, MergeProgress, MERGE_OPTIONS};
 use crate::message::{Message, KNOWN};
 use crate::repo::*;
+use crate::tree::{SpliceTree, Task, Tasks};
 use crate::util::*;
 
 pub const USAGE: &str = include_str!("usage/pull.txt");
@@ -42,6 +43,12 @@ impl PullExecution<'_> {
         self.inner.run()
     }
 
+    /// The splice tree at HEAD, with what this pull did and still does for each
+    /// splice: see [`SpliceTree::render`].
+    pub fn splice_tree(&mut self) -> Res<SpliceTree> {
+        self.inner.splice_tree()
+    }
+
     /// Pauses at a selected event. Repository identity, HEAD, branch, fetched
     /// refs, configuration, tracked files, index and pull markers must remain
     /// unchanged in the predicate and while paused.
@@ -637,6 +644,37 @@ impl Operation for PullProgress {
     fn stopped(&self) {
         let _ = self.say_if_detached();
     }
+    fn tasks(&self) -> Tasks {
+        let pending = |step| {
+            self.selected
+                .iter()
+                .map(|path| (path.clone(), Task::Pending(step)))
+                .collect()
+        };
+        match &self.phase {
+            PullPhase::Fetch(_) => Tasks {
+                per_splice: pending("fetch"),
+                next: None,
+            },
+            PullPhase::Fetched(_) | PullPhase::Reported => Tasks {
+                per_splice: pending("merge"),
+                next: None,
+            },
+            PullPhase::Merge(merges) => Tasks {
+                per_splice: merges.tasks(),
+                next: None,
+            },
+            PullPhase::Finalize | PullPhase::Fold { .. } => Tasks {
+                per_splice: Vec::new(),
+                next: self.recursive.then_some("fold"),
+            },
+            PullPhase::Cleanup { .. } => Tasks {
+                per_splice: Vec::new(),
+                next: Some("clean up"),
+            },
+            PullPhase::Done => Tasks::default(),
+        }
+    }
 }
 
 #[cfg(test)]
@@ -831,6 +869,193 @@ mod tests {
         });
     }
 
+    /// Builds the state of the step-by-step scenario page from its setup.bash:
+    /// a with b (with c inside) and d, then each upstream moves on and a
+    /// splices e in. Leaves the current directory in the monorepo.
+    fn step_by_step_scenario() {
+        let docs = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("docs");
+        let root = std::env::current_dir().unwrap();
+        let mut config = vec![
+            ("user.name".to_string(), "Test".to_string()),
+            ("user.email".to_string(), "test@example.com".to_string()),
+        ];
+        for x in ["a", "b", "c", "d", "e"] {
+            config.push((
+                format!("url.{}/upstream-{x}.git.insteadOf", root.display()),
+                format!("https://git.example.com/{x}.git"),
+            ));
+        }
+        std::env::set_var("GIT_CONFIG_COUNT", config.len().to_string());
+        for (index, (key, value)) in config.iter().enumerate() {
+            std::env::set_var(format!("GIT_CONFIG_KEY_{index}"), key);
+            std::env::set_var(format!("GIT_CONFIG_VALUE_{index}"), value);
+        }
+        let script = r#"
+            set -euo pipefail
+            source "$1"
+            source "$2"
+            scenario_recursive_pull "$PWD/monorepo" "$PWD/upstream"
+            for x in b c d; do
+              git clone -q "https://git.example.com/$x.git" "$x-work"
+              echo "$x upstream" >>"$x-work/file.txt"
+              git -C "$x-work" commit -q -am "${x}2: $x upstream"
+              git -C "$x-work" push -q origin main
+            done
+            git clone -q https://git.example.com/a.git a-work
+            add_splice a-work https://git.example.com/e.git e main "add e"
+            echo "a upstream" >>a-work/file.txt
+            git -C a-work commit -q --amend -am "a2: a upstream, and e spliced in"
+            git -C a-work push -q origin main
+        "#;
+        let status =
+            std::process::Command::new("bash")
+                .args(["-c", script, "scenario"])
+                .arg(docs.join("tests/helpers/fixtures.bash"))
+                .arg(docs.join(
+                    "09-scenarios/05-nested-splices/05-recursion/01-recursive-pull/setup.bash",
+                ))
+                .status()
+                .unwrap();
+        assert!(status.success());
+        std::env::set_current_dir("monorepo").unwrap();
+    }
+
+    #[test]
+    fn recursive_pull_shows_each_splices_commits_and_pending_work_step_by_step() {
+        with_repository(|| {
+            step_by_step_scenario();
+            let mut named = vec![("s", git(&["rev-parse", "HEAD"]))];
+            let mut context = ExecutionContext::new();
+            let mut execution =
+                start(&mut context, &["--recursive".into(), "vendor/a".into()]).unwrap();
+            let tree = |execution: &mut PullExecution, named: &[(&str, String)]| {
+                let tree = execution
+                    .splice_tree()
+                    .unwrap()
+                    .render(crate::tree::labels(named));
+                println!("{tree}");
+                tree
+            };
+            let mut steps = vec![("start", tree(&mut execution, &named))];
+            let wanted = |event: &ExecutionEvent| {
+                matches!(
+                    event,
+                    ExecutionEvent::AfterFetch { .. }
+                        | ExecutionEvent::AfterMerge { .. }
+                        | ExecutionEvent::BeforeFold { .. }
+                        | ExecutionEvent::AfterFold { .. }
+                )
+            };
+            while let ExecutionOutcome::Paused(event) = execution.run_until(wanted).unwrap() {
+                let step = match event {
+                    ExecutionEvent::AfterMerge {
+                        path, head_after, ..
+                    } => {
+                        let name = match path.rsplit('/').next().unwrap() {
+                            "a" => "pa",
+                            "b" => "pb",
+                            "c" => "pc",
+                            "d" => "pd",
+                            other => panic!("unexpected merge of {other}"),
+                        };
+                        named.push((name, head_after));
+                        "after-merge"
+                    }
+                    ExecutionEvent::AfterFetch { .. } => "after-fetch",
+                    ExecutionEvent::BeforeFold { .. } => "before-fold",
+                    ExecutionEvent::AfterFold { head_after, .. } => {
+                        named.push(("p", head_after));
+                        "after-fold"
+                    }
+                    _ => unreachable!(),
+                };
+                println!("{step}:");
+                steps.push((step, tree(&mut execution, &named)));
+            }
+            let observed: String = steps
+                .iter()
+                .map(|(step, tree)| format!("{step}:\n{tree}"))
+                .collect::<Vec<_>>()
+                .join("\n");
+            assert_eq!(
+                observed,
+                r#"start:
+monorepo   H=s
+vendor/a/  B=s  U=a1  R=a1  T=a1  pending: fetch
+  b/       B=s  U=b1  R=b1  T=b1  pending: fetch
+    c/     B=s  U=c1  R=c1  T=c1  pending: fetch
+  d/       B=s  U=d1  R=d1  T=d1  pending: fetch
+
+after-fetch:
+monorepo   H=s
+vendor/a/  B=s  U=a1  R=a1  T=a2  pending: merge
+  b/       B=s  U=b1  R=b1  T=b2  pending: merge, after vendor/a/
+    c/     B=s  U=c1  R=c1  T=c2  pending: merge, after b/
+  d/       B=s  U=d1  R=d1  T=d2  pending: merge, after vendor/a/
+
+after-merge:
+monorepo   H=pa
+vendor/a/  B=pa  U=a2  R=a2  T=a2  done
+  b/       B=pa  U=b1  R=b1  T=b2  pending: merge
+    c/     B=pa  U=c1  R=c1  T=c2  pending: merge, after b/
+  d/       B=pa  U=d1  R=d1  T=d2  pending: merge
+  e/       B=-   U=?   R=-   T=-
+
+after-fetch:
+monorepo   H=pa
+vendor/a/  B=pa  U=a2  R=a2  T=a2  done
+  b/       B=pa  U=b1  R=b1  T=b2  pending: merge
+    c/     B=pa  U=c1  R=c1  T=c2  pending: merge, after b/
+  d/       B=pa  U=d1  R=d1  T=d2  pending: merge
+  e/       B=pa  U=e1  R=e1  T=e1  pending: merge
+
+after-merge:
+monorepo   H=pb
+vendor/a/  B=pa  U=a2  R=pb'  T=a2  done
+  b/       B=pb  U=b2  R=b2   T=b2  done
+    c/     B=pb  U=c1  R=c1   T=c2  pending: merge
+  d/       B=pa  U=d1  R=d1   T=d2  pending: merge
+  e/       B=pa  U=e1  R=e1   T=e1  done
+
+after-merge:
+monorepo   H=pc
+vendor/a/  B=pa  U=a2  R=pc'  T=a2  done
+  b/       B=pb  U=b2  R=pc'  T=b2  done
+    c/     B=pc  U=c2  R=c2   T=c2  done
+  d/       B=pa  U=d1  R=d1   T=d2  pending: merge
+  e/       B=pa  U=e1  R=e1   T=e1  done
+
+after-merge:
+monorepo   H=pd
+vendor/a/  B=pa  U=a2  R=pd'  T=a2  done
+  b/       B=pb  U=b2  R=pc'  T=b2  done
+    c/     B=pc  U=c2  R=c2   T=c2  done
+  d/       B=pd  U=d2  R=d2   T=d2  done
+  e/       B=pa  U=e1  R=e1   T=e1  done
+
+before-fold:
+monorepo   H=pd
+vendor/a/  B=pa  U=a2  R=pd'  T=a2
+  b/       B=pb  U=b2  R=pc'  T=b2
+    c/     B=pc  U=c2  R=c2   T=c2
+  d/       B=pd  U=d2  R=d2   T=d2
+  e/       B=pa  U=e1  R=e1   T=e1
+next: fold
+
+after-fold:
+monorepo   H=p
+vendor/a/  B=s  U=a2  R=p'  T=a2
+  b/       B=s  U=b2  R=p'  T=b2
+    c/     B=p  U=c2  R=c2  T=c2
+  d/       B=p  U=d2  R=d2  T=d2
+  e/       B=p  U=e1  R=e1  T=e1
+next: clean up
+"#,
+                "observed trees:\n{observed}"
+            );
+        });
+    }
+
     #[test]
     fn pull_rejects_state_changes_between_start_and_first_run() {
         with_repository(|| {
diff --git a/src/tree.rs b/src/tree.rs
new file mode 100644
index 00000000..f645d324
--- /dev/null
+++ b/src/tree.rs
@@ -0,0 +1,228 @@
+//! The splice tree as a table: each splice's boundary B, synced commit U,
+//! rebuild R and upstream branch T at HEAD, and the work an operation still
+//! has for it. The same picture as a tree drawing, as text.
+
+use crate::repo::*;
+use crate::util::*;
+
+/// What an operation did or still does for a splice.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum Task {
+    Done,
+    Pending(&'static str),
+    Failed,
+    Conflict,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct Node {
+    pub path: String,
+    /// B: the monorepo commit the rebuild starts at.
+    pub boundary: Option<String>,
+    /// U: the synced commit HEAD's .splice records.
+    pub synced: String,
+    /// R: the rebuild push would send.
+    pub rebuild: Option<String>,
+    /// T: the fetched upstream branch, or pin, the splice follows.
+    pub target: Option<String>,
+    pub task: Option<Task>,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct SpliceTree {
+    pub head: String,
+    /// Splices top-down, a parent before the ones inside it.
+    pub nodes: Vec<Node>,
+    /// The operation's next step that belongs to no single splice.
+    pub next: Option<&'static str>,
+}
+
+/// An operation's work per splice, and its next step beyond them.
+#[derive(Default)]
+pub(crate) struct Tasks {
+    pub per_splice: Vec<(String, Task)>,
+    pub next: Option<&'static str>,
+}
+
+impl Repo<'_> {
+    pub(crate) fn splice_tree(&mut self, tasks: Tasks) -> Res<SpliceTree> {
+        let head = commit_of("HEAD").ok_or(Fail::Hard)?;
+        let suffix = format!("/{STATE_FILE}");
+        let paths: Vec<String> = self
+            .state_files("HEAD")
+            .iter()
+            .filter_map(|file| file.strip_suffix(&suffix).map(str::to_string))
+            .collect();
+        let branch = self.monorepo_branch.clone();
+        let mut nodes = Vec::new();
+        for path in splices_in_order(false, &paths) {
+            let (boundary, rebuild) = quietly(|| {
+                (
+                    self.splice_start(&path, "HEAD").ok().flatten(),
+                    self.rebuild_splice(&path, "HEAD").ok().flatten(),
+                )
+            });
+            let target = quietly(|| {
+                self.require_splice_upstream(&path).ok()?;
+                let target = self.resolve_upstream_target(&path, &branch).ok()?;
+                commit_of(&target.reference)
+            });
+            let task = tasks
+                .per_splice
+                .iter()
+                .find(|(done, _)| *done == path)
+                .map(|(_, task)| task.clone());
+            nodes.push(Node {
+                synced: splice_config(&path, "commit", "HEAD"),
+                path,
+                boundary,
+                rebuild,
+                target,
+                task,
+            });
+        }
+        Ok(SpliceTree {
+            head,
+            nodes,
+            next: tasks.next,
+        })
+    }
+}
+
+impl SpliceTree {
+    /// The tree as a table, one row per splice, indented inside its parent,
+    /// with each commit as <label> names it:
+    ///
+    /// ```text
+    /// monorepo    H=pa
+    /// vendor/a/   B=s  U=a2  R=pa'  T=a2  done
+    ///   b/        B=s  U=b1  R=b1   T=b2  pending: merge
+    ///     c/      B=s  U=c1  R=c1   T=c2  pending: merge, after b/
+    /// next: fold
+    /// ```
+    pub fn render(&self, label: impl Fn(&str) -> String) -> String {
+        let label = |id: &Option<String>| id.as_deref().map_or("-".to_string(), &label);
+        let parent = |path: &str| {
+            self.nodes
+                .iter()
+                .map(|node| node.path.as_str())
+                .filter(|above| path.starts_with(&format!("{above}/")))
+                .max_by_key(|above| above.len())
+        };
+        let depth = |path: &str| {
+            let mut depth = 0;
+            let mut at = path;
+            while let Some(above) = parent(at) {
+                depth += 1;
+                at = above;
+            }
+            depth
+        };
+        let pending = |path: &str| {
+            self.nodes
+                .iter()
+                .any(|node| node.path == path && matches!(node.task, Some(Task::Pending(_))))
+        };
+        let mut rows = vec![vec![
+            "monorepo".to_string(),
+            format!("H={}", label(&Some(self.head.clone()))),
+        ]];
+        for node in &self.nodes {
+            let name = match parent(&node.path) {
+                Some(above) => &node.path[above.len() + 1..],
+                None => node.path.as_str(),
+            };
+            let mut task = match &node.task {
+                None => String::new(),
+                Some(Task::Done) => "done".to_string(),
+                Some(Task::Failed) => "failed".to_string(),
+                Some(Task::Conflict) => "conflict".to_string(),
+                Some(Task::Pending(step)) => format!("pending: {step}"),
+            };
+            // Merges go top-down; fetches run side by side.
+            if let Some(above) = parent(&node.path).filter(|above| pending(above)) {
+                if node.task == Some(Task::Pending("merge")) {
+                    let name = match parent(above) {
+                        Some(top) => &above[top.len() + 1..],
+                        None => above,
+                    };
+                    task.push_str(&format!(", after {name}/"));
+                }
+            }
+            rows.push(vec![
+                format!("{}{name}/", "  ".repeat(depth(&node.path))),
+                format!("B={}", label(&node.boundary)),
+                format!(
+                    "U={}",
+                    label(&Some(node.synced.clone()).filter(|s| !s.is_empty()))
+                ),
+                format!("R={}", label(&node.rebuild)),
+                format!("T={}", label(&node.target)),
+                task,
+            ]);
+        }
+        let columns = rows.iter().map(Vec::len).max().unwrap_or(0);
+        let widths: Vec<usize> = (0..columns)
+            .map(|column| {
+                rows.iter()
+                    .filter_map(|row| row.get(column))
+                    .map(|cell| cell.chars().count())
+                    .max()
+                    .unwrap_or(0)
+            })
+            .collect();
+        let mut out = String::new();
+        for row in &rows {
+            let line = row
+                .iter()
+                .enumerate()
+                .map(|(column, cell)| format!("{cell:<width$}", width = widths[column]))
+                .collect::<Vec<_>>()
+                .join("  ");
+            out.push_str(line.trim_end());
+            out.push('\n');
+        }
+        if let Some(next) = self.next {
+            out.push_str(&format!("next: {next}\n"));
+        }
+        out
+    }
+}
+
+/// Labels a commit for [`SpliceTree::render`]: by the name <named> gives it;
+/// as a rebuild, name' for a commit with the subject of one <named> names,
+/// the last one if several have it;
+/// by its subject's label, the "a1" of "a1: a seed", as the scenarios name
+/// their commits; "?" for a commit that isn't here yet; else by its short id.
+pub fn labels<'a>(named: &'a [(&'a str, String)]) -> impl Fn(&str) -> String + 'a {
+    let subject = |id: &str| {
+        git(&["log", "-1", "--format=%s", id])
+            .q()
+            .out()
+            .unwrap_or_default()
+    };
+    let named_subjects: Vec<(&str, String)> = named
+        .iter()
+        .map(|(name, id)| (*name, subject(id)))
+        .collect();
+    move |id: &str| {
+        if let Some((name, _)) = named.iter().find(|(_, known)| known == id) {
+            return (*name).to_string();
+        }
+        if !commit_here(id) {
+            return "?".to_string();
+        }
+        let own = subject(id);
+        if let Some((name, _)) = named_subjects.iter().rev().find(|(_, s)| *s == own) {
+            return format!("{name}'");
+        }
+        if let Some((label, _)) = own.split_once(": ") {
+            if label.chars().all(|c| c.is_ascii_alphanumeric())
+                && label.chars().any(|c| c.is_ascii_digit())
+            {
+                return label.to_string();
+            }
+        }
+        short(id).to_string()
+    }
+}

From c26671243faa0b3c473a905ef19629d47c5816b1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Robert=20Sch=C3=A4fer?= <git@roschaefer.de>
Date: Fri, 13 Nov 2026 21:19:13 +0100
Subject: [PATCH 2/5] refactor(tree): draw the paused pull with check-drawing's
 tree

The table computed B, U, R and T a second time, in its own format, though
check-drawing's tree already reads them from git-splice's code for the
drawings. check-drawing is now a library too, and draws the same rows as
text; git-splice keeps only what it alone knows: each splice's task.

The test moves into check-drawing. It pauses one real pull --recursive at
each step, prints the tree with each splice's task, and checks the
step-by-step page's drawings against that live state. step-a only matches
after the extra fetch of e/: the page's replay shows e fetched already.
---
 check-drawing/src/lib.rs               |  14 ++
 check-drawing/src/main.rs              |  10 +-
 check-drawing/src/tree.rs              |  90 ++++++++
 check-drawing/tests/recursive_pull.rs  | 276 +++++++++++++++++++++++++
 docs/10-contributing/01-development.md |   2 +-
 src/execution.rs                       |   9 +-
 src/pull.rs                            | 196 +-----------------
 src/tree.rs                            | 245 ++++------------------
 8 files changed, 431 insertions(+), 411 deletions(-)
 create mode 100644 check-drawing/src/lib.rs
 create mode 100644 check-drawing/tests/recursive_pull.rs

diff --git a/check-drawing/src/lib.rs b/check-drawing/src/lib.rs
new file mode 100644
index 00000000..ccfe2235
--- /dev/null
+++ b/check-drawing/src/lib.rs
@@ -0,0 +1,14 @@
+//! check-drawing: checks a draw.io drawing of commit graphs against the
+//! repositories it shows. See README.md next to src/ for the drawing's
+//! vocabulary and its limits.
+//!
+//! What it reads about a splice, its boundary, rebuild, keys and the folders
+//! it had, comes from git-splice's own code, so a drawing is checked against
+//! what the tool really does.
+
+pub mod check;
+pub mod diagram;
+pub mod history;
+pub mod labels;
+pub mod placement;
+pub mod tree;
diff --git a/check-drawing/src/main.rs b/check-drawing/src/main.rs
index 388788e0..f3553ec5 100644
--- a/check-drawing/src/main.rs
+++ b/check-drawing/src/main.rs
@@ -6,14 +6,8 @@
 //! it had, comes from git-splice's own code, so a drawing is checked against
 //! what the tool really does.
 
-mod check;
-mod diagram;
-mod history;
-mod labels;
-mod placement;
-mod tree;
-
-use check::{Checker, Labels};
+use check_drawing::check::{Checker, Labels};
+use check_drawing::{labels, placement, tree};
 use std::process::ExitCode;
 
 const USAGE: &str = "usage: check-drawing <drawing> [--alias <name>=<term>...] [<label>=<rev>...]\n       check-drawing tree [--mark pulled|carried]... [<label>=<rev>...]\n       check-drawing labels <page>...\n       check-drawing placement <page>...";
diff --git a/check-drawing/src/tree.rs b/check-drawing/src/tree.rs
index 6f09ea0a..33de0ae5 100644
--- a/check-drawing/src/tree.rs
+++ b/check-drawing/src/tree.rs
@@ -68,6 +68,8 @@ struct Circle {
 /// it hangs, its synced commit (the root's: HEAD), R, where the splice has
 /// commits of its own, and the commit a conflicted pull of it merges in.
 struct Row {
+    /// The splice's path in the monorepo; empty for the monorepo's row.
+    path: String,
     folder: String,
     depth: usize,
     synced: Option<Circle>,
@@ -169,6 +171,7 @@ fn rows(git: &History, labels: &Labels, marks: &Marks) -> Result<Vec<Row>, Vec<S
     };
 
     let mut rows = vec![Row {
+        path: String::new(),
         folder: "monorepo".to_string(),
         depth: 0,
         synced: Some(circle(
@@ -209,6 +212,7 @@ fn rows(git: &History, labels: &Labels, marks: &Marks) -> Result<Vec<Row>, Vec<S
                 dashed: false,
             });
         rows.push(Row {
+            path: splice.clone(),
             folder: format!("{folder}/"),
             depth: around.len() + 1,
             synced,
@@ -375,6 +379,92 @@ fn render(rows: &[Row], marks: &Marks) -> String {
     )
 }
 
+/// The tree of the monorepo in the current folder as text, as `tree` prints
+/// folders, with the same rows as the drawing: each splice's synced commit
+/// and, after "…", its rebuild R. A commit is (label), or [label] where no
+/// upstream branch has it (dashed in the drawing); with <marks>, a pulled
+/// one ends in *, a carried one in ^, and the commit a conflicted pull
+/// merges in in !. <notes> adds text after the row of the splice it names.
+///
+/// ```text
+/// monorepo        (pb)
+/// └─ vendor/a/    (a2) … [pb']  done
+///    ├─ b/        (b2)          done
+///    │  └─ c/     (c1)          pending: merge
+///    └─ d/        (d1)          pending: merge
+/// ```
+pub fn ascii(
+    labels: &Labels,
+    marks: &Marks,
+    notes: &HashMap<String, String>,
+) -> Result<String, Vec<String>> {
+    let rows = rows(&History::default(), labels, marks)?;
+    let circle = |c: &Circle| {
+        let mark = match c.color {
+            Some(PULLED) => "*",
+            Some(CARRIED) => "^",
+            Some(_) => "!",
+            None => "",
+        };
+        if c.dashed {
+            format!("[{}{mark}]", c.label)
+        } else {
+            format!("({}{mark})", c.label)
+        }
+    };
+    // Whether no later row hangs from the same row as row <i>.
+    let last = |i: usize| {
+        let depth = rows[i].depth;
+        rows[i + 1..]
+            .iter()
+            .take_while(|row| row.depth >= depth)
+            .all(|row| row.depth > depth)
+    };
+    let mut lines: Vec<(String, String, String)> = Vec::new();
+    // For each depth, whether the row drawn last at it was its parent's last.
+    let mut closed: Vec<bool> = Vec::new();
+    for (i, row) in rows.iter().enumerate() {
+        let mut name = String::new();
+        if row.depth > 0 {
+            closed.truncate(row.depth);
+            for &done in closed.iter().skip(1) {
+                name.push_str(if done { "   " } else { "│  " });
+            }
+            let is_last = last(i);
+            name.push_str(if is_last { "└─ " } else { "├─ " });
+            closed.push(is_last);
+        } else {
+            closed = vec![true];
+        }
+        name.push_str(&row.folder);
+        let mut commits: Vec<String> = row.synced.iter().map(circle).collect();
+        if let Some(r) = &row.r {
+            if row.synced.is_some() {
+                commits.push("…".to_string());
+            }
+            commits.push(circle(r));
+        }
+        commits.extend(row.theirs.iter().map(circle));
+        let note = notes.get(&row.path).cloned().unwrap_or_default();
+        lines.push((name, commits.join(" "), note));
+    }
+    let width = |pick: fn(&(String, String, String)) -> &String| {
+        lines
+            .iter()
+            .map(|line| pick(line).chars().count())
+            .max()
+            .unwrap_or(0)
+    };
+    let (names, commits) = (width(|l| &l.0), width(|l| &l.1));
+    Ok(lines
+        .iter()
+        .map(|(name, circles, note)| {
+            let line = format!("{name:<names$}  {circles:<commits$}  {note}");
+            format!("{}\n", line.trim_end())
+        })
+        .collect())
+}
+
 /// `check-drawing tree [--mark pulled|carried]... [<label>=<rev>...]`:
 /// prints the tree of the monorepo in the current folder.
 pub fn generate(labels: &Labels, marks: &Marks) -> bool {
diff --git a/check-drawing/tests/recursive_pull.rs b/check-drawing/tests/recursive_pull.rs
new file mode 100644
index 00000000..a459ed0d
--- /dev/null
+++ b/check-drawing/tests/recursive_pull.rs
@@ -0,0 +1,276 @@
+//! One `git splice pull --recursive`, paused at each step: the splice tree
+//! as text, with what the pull still does for each splice, and the step-by-step
+//! page's drawing of that step checked against the same state.
+
+use check_drawing::check::{Checker, Labels};
+use check_drawing::tree::{ascii, Marks};
+use git_splice::context::ExecutionContext;
+use git_splice::execution::{ExecutionEvent, ExecutionOutcome};
+use git_splice::pull::{self, PullExecution};
+use std::path::{Path, PathBuf};
+
+const PAGE: &str = "docs/09-scenarios/05-nested-splices/05-recursion/01-recursive-pull";
+
+fn docs() -> PathBuf {
+    Path::new(env!("CARGO_MANIFEST_DIR")).join("..").join(PAGE)
+}
+
+fn git(args: &[&str]) -> String {
+    let output = std::process::Command::new("git")
+        .args(args)
+        .output()
+        .unwrap();
+    assert!(output.status.success(), "git {args:?}");
+    String::from_utf8(output.stdout)
+        .unwrap()
+        .trim_end()
+        .to_string()
+}
+
+/// A folder of its own, ignoring the developer's Git configuration; the
+/// upstreams' https://git.example.com URLs lead to bare repositories in it.
+fn sandbox() -> PathBuf {
+    let root = std::env::temp_dir().join(format!(
+        "check-drawing-recursive-pull-{}",
+        std::process::id()
+    ));
+    let _ = std::fs::remove_dir_all(&root);
+    std::fs::create_dir_all(root.join("home")).unwrap();
+    let root = root.canonicalize().unwrap();
+    for name in ["GIT_DIR", "GIT_WORK_TREE", "GIT_INDEX_FILE", "GIT_CONFIG"] {
+        std::env::remove_var(name);
+    }
+    std::env::set_var("HOME", root.join("home"));
+    std::env::set_var("GIT_CONFIG_GLOBAL", "/dev/null");
+    std::env::set_var("GIT_CONFIG_NOSYSTEM", "1");
+    let mut config = vec![
+        ("user.name".to_string(), "Test".to_string()),
+        ("user.email".to_string(), "test@example.com".to_string()),
+    ];
+    for x in ["a", "b", "c", "d", "e"] {
+        config.push((
+            format!("url.{}/upstream-{x}.git.insteadOf", root.display()),
+            format!("https://git.example.com/{x}.git"),
+        ));
+    }
+    std::env::set_var("GIT_CONFIG_COUNT", config.len().to_string());
+    for (index, (key, value)) in config.iter().enumerate() {
+        std::env::set_var(format!("GIT_CONFIG_KEY_{index}"), key);
+        std::env::set_var(format!("GIT_CONFIG_VALUE_{index}"), value);
+    }
+    root
+}
+
+/// The step-by-step page's state: its setup.bash, then the same upstream
+/// changes as the page. Leaves the current directory in the monorepo.
+fn step_by_step_scenario(root: &Path) {
+    let script = r#"
+        set -euo pipefail
+        source "$1"
+        source "$2"
+        scenario_recursive_pull "$PWD/monorepo" "$PWD/upstream"
+        for x in b c d; do
+          git clone -q "https://git.example.com/$x.git" "$x-work"
+          echo "$x upstream" >>"$x-work/file.txt"
+          git -C "$x-work" commit -q -am "${x}2: $x upstream"
+          git -C "$x-work" push -q origin main
+        done
+        git clone -q https://git.example.com/a.git a-work
+        add_splice a-work https://git.example.com/e.git e main "add e"
+        echo "a upstream" >>a-work/file.txt
+        git -C a-work commit -q --amend -am "a2: a upstream, and e spliced in"
+        git -C a-work push -q origin main
+    "#;
+    let fixtures =
+        Path::new(env!("CARGO_MANIFEST_DIR")).join("../docs/tests/helpers/fixtures.bash");
+    let status = std::process::Command::new("bash")
+        .current_dir(root)
+        .args(["-c", script, "scenario"])
+        .arg(fixtures)
+        .arg(docs().join("setup.bash"))
+        .status()
+        .unwrap();
+    assert!(status.success());
+    std::env::set_current_dir(root.join("monorepo")).unwrap();
+}
+
+fn labels(revs: &[(&str, &str)]) -> Labels {
+    let mut labels = Labels::default();
+    for (label, rev) in revs {
+        labels.revs.insert(label.to_string(), rev.to_string());
+    }
+    labels
+}
+
+/// The tree as text, each commit named by <named> or its subject, and what
+/// <execution> still does for each splice.
+fn tree(execution: &PullExecution, named: &[(&str, String)]) -> String {
+    let revs: Vec<(&str, &str)> = named.iter().map(|(l, r)| (*l, r.as_str())).collect();
+    let tasks = execution.tasks();
+    let marks = Marks {
+        pulled: true,
+        carried: false,
+    };
+    let mut text = ascii(&labels(&revs), &marks, &tasks.notes()).unwrap();
+    if let Some(next) = tasks.next {
+        text.push_str(&format!("next: {next}\n"));
+    }
+    text
+}
+
+/// Checks the page's drawing <name> as the page does, with labels <revs>.
+fn drawing(name: &str, revs: &[(&str, &str)]) {
+    let path = docs().join(name);
+    assert!(
+        Checker::run(path.to_str().unwrap(), &labels(revs)),
+        "{name} isn't the repository's tree"
+    );
+}
+
+#[test]
+fn recursive_pull_step_by_step() {
+    let root = sandbox();
+    step_by_step_scenario(&root);
+    // e1 isn't here until the pull fetches e's upstream: named by its hash.
+    let e1 = git(&[
+        "-C",
+        root.join("upstream-e.git").to_str().unwrap(),
+        "rev-parse",
+        "main",
+    ]);
+    let mut named = vec![("s", git(&["rev-parse", "HEAD"])), ("e1", e1)];
+    drawing("step-0.drawio.svg", &[("s", "HEAD")]);
+    let mut context = ExecutionContext::new();
+    let mut execution =
+        pull::start(&mut context, &["--recursive".into(), "vendor/a".into()]).unwrap();
+    let mut steps = vec![format!("start:\n{}", tree(&execution, &named))];
+    let wanted = |event: &ExecutionEvent| {
+        matches!(
+            event,
+            ExecutionEvent::AfterFetch { .. }
+                | ExecutionEvent::AfterMerge { .. }
+                | ExecutionEvent::BeforeFold { .. }
+                | ExecutionEvent::AfterFold { .. }
+        )
+    };
+    while let ExecutionOutcome::Paused(event) = execution.run_until(wanted).unwrap() {
+        let step = match event {
+            ExecutionEvent::AfterFetch { fetched } => {
+                let paths: Vec<String> = fetched.into_iter().map(|f| f.path).collect();
+                // e/ came with a's merge; the page's drawing of that merge
+                // shows it fetched, as it is only from here on.
+                if paths == ["vendor/a/e"] {
+                    drawing("step-a.drawio.svg", &[("pa", "HEAD")]);
+                }
+                format!("after-fetch {}", paths.join(" "))
+            }
+            ExecutionEvent::AfterMerge {
+                path, head_after, ..
+            } => {
+                let (name, page) = match path.as_str() {
+                    "vendor/a" => ("pa", None),
+                    "vendor/a/b" => ("pb", Some(("step-b.drawio.svg", vec![("pb", "HEAD")]))),
+                    "vendor/a/b/c" => ("pc", Some(("step-c.drawio.svg", vec![("pc", "HEAD")]))),
+                    "vendor/a/d" => (
+                        "pd",
+                        Some(("step-d.drawio.svg", vec![("pd", "HEAD"), ("pc", "HEAD~1")])),
+                    ),
+                    other => panic!("unexpected merge of {other}"),
+                };
+                named.push((name, head_after));
+                if let Some((file, revs)) = page {
+                    drawing(file, &revs);
+                }
+                format!("after-merge {path}")
+            }
+            ExecutionEvent::BeforeFold { .. } => "before-fold".to_string(),
+            ExecutionEvent::AfterFold { head_after, .. } => {
+                named.push(("p", head_after));
+                drawing("step-folded.drawio.svg", &[("p", "HEAD")]);
+                "after-fold".to_string()
+            }
+            _ => unreachable!(),
+        };
+        steps.push(format!("{step}:\n{}", tree(&execution, &named)));
+    }
+    let observed = steps.join("\n");
+    println!("{observed}");
+    std::env::set_current_dir(std::env::temp_dir()).unwrap();
+    let _ = std::fs::remove_dir_all(&root);
+    assert_eq!(
+        observed,
+        r#"start:
+monorepo      (s)
+└─ vendor/a/  (a1)  pending: fetch
+   ├─ b/      (b1)  pending: fetch
+   │  └─ c/   (c1)  pending: fetch
+   └─ d/      (d1)  pending: fetch
+
+after-fetch vendor/a vendor/a/b vendor/a/b/c vendor/a/d:
+monorepo      (s)
+└─ vendor/a/  (a1)  pending: merge
+   ├─ b/      (b1)  pending: merge, after vendor/a/
+   │  └─ c/   (c1)  pending: merge, after b/
+   └─ d/      (d1)  pending: merge, after vendor/a/
+
+after-merge vendor/a:
+monorepo      (pa*)
+└─ vendor/a/  (a2*)  done
+   ├─ b/      (b1)   pending: merge
+   │  └─ c/   (c1)   pending: merge, after b/
+   ├─ d/      (d1)   pending: merge
+   └─ e/      (e1)
+
+after-fetch vendor/a/e:
+monorepo      (pa*)
+└─ vendor/a/  (a2*)  done
+   ├─ b/      (b1)   pending: merge
+   │  └─ c/   (c1)   pending: merge, after b/
+   ├─ d/      (d1)   pending: merge
+   └─ e/      (e1)   pending: merge
+
+after-merge vendor/a/b:
+monorepo      (pb*)
+└─ vendor/a/  (a2) … [pb'*]  done
+   ├─ b/      (b2*)          done
+   │  └─ c/   (c1)           pending: merge
+   ├─ d/      (d1)           pending: merge
+   └─ e/      (e1)           done
+
+after-merge vendor/a/b/c:
+monorepo      (pc*)
+└─ vendor/a/  (a2) … [pc'*]  done
+   ├─ b/      (b2) … [pc'*]  done
+   │  └─ c/   (c2*)          done
+   ├─ d/      (d1)           pending: merge
+   └─ e/      (e1)           done
+
+after-merge vendor/a/d:
+monorepo      (pd*)
+└─ vendor/a/  (a2) … [pd'*]  done
+   ├─ b/      (b2) … [pc'*]  done
+   │  └─ c/   (c2*)          done
+   ├─ d/      (d2*)          done
+   └─ e/      (e1)           done
+
+before-fold:
+monorepo      (pd*)
+└─ vendor/a/  (a2) … [pd'*]
+   ├─ b/      (b2) … [pc'*]
+   │  └─ c/   (c2*)
+   ├─ d/      (d2*)
+   └─ e/      (e1)
+next: fold
+
+after-fold:
+monorepo      (p*)
+└─ vendor/a/  (a2*) … [p'*]
+   ├─ b/      (b2*) … [p'*]
+   │  └─ c/   (c2*)
+   ├─ d/      (d2*)
+   └─ e/      (e1)
+next: clean up
+"#,
+        "observed trees:\n{observed}"
+    );
+}
diff --git a/docs/10-contributing/01-development.md b/docs/10-contributing/01-development.md
index 922b714e..d15338e2 100644
--- a/docs/10-contributing/01-development.md
+++ b/docs/10-contributing/01-development.md
@@ -55,7 +55,7 @@ the command's `run`. The tool only runs the `git` CLI, so
 | `src/context.rs` | Caller-owned `ExecutionContext`: immutable content-tree cache, validated supplied rebuilds and optional progress observer shared by operations in one invocation. |
 | `src/repo.rs` | `Repo`: discovery, path selection, reading `.splice`, upstreams, keys and what a splice syncs with. |
 | `src/rebuild.rs` | The push rebuild: `rebuild_splice`, `splice_start` (B) and the commit loop `rebuild_walk`. |
-| `src/tree.rs` | `SpliceTree`: each splice's B, U, R and T at HEAD and an operation's work for it, as a text table for Rust tests. |
+| `src/tree.rs` | `Tasks`: an operation's work per splice, done or pending, for a paused execution to show. |
 | `src/state.rs` | `classify_splice`, the sync state every command acts on, and `splice_in`, the re-rooted cherry-pick behind `merge` and `clone`. |
 | `src/pager.rs` | Paging for `diff` and `log`. |
 | `src/<command>.rs` | One command each: its `run` and its per-splice step. |
diff --git a/src/execution.rs b/src/execution.rs
index 21c80854..d119847d 100644
--- a/src/execution.rs
+++ b/src/execution.rs
@@ -1,7 +1,7 @@
 //! Typed observations and in-memory synchronization drivers.
 
 use crate::repo::{commit_of, Repo};
-use crate::tree::{SpliceTree, Tasks};
+use crate::tree::Tasks;
 use crate::util::*;
 use std::process::{Command, Stdio};
 
@@ -176,10 +176,9 @@ impl<'context, O: Operation> Execution<'context, O> {
         Ok(ExecutionOutcome::Complete(status))
     }
 
-    /// The splice tree at HEAD, with the operation's work per splice.
-    pub(crate) fn splice_tree(&mut self) -> Res<SpliceTree> {
-        let tasks = self.progress.tasks();
-        self.repo.splice_tree(tasks)
+    /// The operation's work per splice, done and still to do.
+    pub(crate) fn tasks(&self) -> Tasks {
+        self.progress.tasks()
     }
 
     fn checked<T>(&mut self, result: Res<T>) -> Res<T> {
diff --git a/src/pull.rs b/src/pull.rs
index 7de5b6eb..ca1834b4 100644
--- a/src/pull.rs
+++ b/src/pull.rs
@@ -7,7 +7,7 @@ use crate::fetch::{FetchPlan, FetchResults};
 use crate::merge::{apply_merge_options, MergeProgress, MERGE_OPTIONS};
 use crate::message::{Message, KNOWN};
 use crate::repo::*;
-use crate::tree::{SpliceTree, Task, Tasks};
+use crate::tree::{Task, Tasks};
 use crate::util::*;
 
 pub const USAGE: &str = include_str!("usage/pull.txt");
@@ -43,10 +43,9 @@ impl PullExecution<'_> {
         self.inner.run()
     }
 
-    /// The splice tree at HEAD, with what this pull did and still does for each
-    /// splice: see [`SpliceTree::render`].
-    pub fn splice_tree(&mut self) -> Res<SpliceTree> {
-        self.inner.splice_tree()
+    /// What this pull did and still does for each splice.
+    pub fn tasks(&self) -> Tasks {
+        self.inner.tasks()
     }
 
     /// Pauses at a selected event. Repository identity, HEAD, branch, fetched
@@ -869,193 +868,6 @@ mod tests {
         });
     }
 
-    /// Builds the state of the step-by-step scenario page from its setup.bash:
-    /// a with b (with c inside) and d, then each upstream moves on and a
-    /// splices e in. Leaves the current directory in the monorepo.
-    fn step_by_step_scenario() {
-        let docs = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("docs");
-        let root = std::env::current_dir().unwrap();
-        let mut config = vec![
-            ("user.name".to_string(), "Test".to_string()),
-            ("user.email".to_string(), "test@example.com".to_string()),
-        ];
-        for x in ["a", "b", "c", "d", "e"] {
-            config.push((
-                format!("url.{}/upstream-{x}.git.insteadOf", root.display()),
-                format!("https://git.example.com/{x}.git"),
-            ));
-        }
-        std::env::set_var("GIT_CONFIG_COUNT", config.len().to_string());
-        for (index, (key, value)) in config.iter().enumerate() {
-            std::env::set_var(format!("GIT_CONFIG_KEY_{index}"), key);
-            std::env::set_var(format!("GIT_CONFIG_VALUE_{index}"), value);
-        }
-        let script = r#"
-            set -euo pipefail
-            source "$1"
-            source "$2"
-            scenario_recursive_pull "$PWD/monorepo" "$PWD/upstream"
-            for x in b c d; do
-              git clone -q "https://git.example.com/$x.git" "$x-work"
-              echo "$x upstream" >>"$x-work/file.txt"
-              git -C "$x-work" commit -q -am "${x}2: $x upstream"
-              git -C "$x-work" push -q origin main
-            done
-            git clone -q https://git.example.com/a.git a-work
-            add_splice a-work https://git.example.com/e.git e main "add e"
-            echo "a upstream" >>a-work/file.txt
-            git -C a-work commit -q --amend -am "a2: a upstream, and e spliced in"
-            git -C a-work push -q origin main
-        "#;
-        let status =
-            std::process::Command::new("bash")
-                .args(["-c", script, "scenario"])
-                .arg(docs.join("tests/helpers/fixtures.bash"))
-                .arg(docs.join(
-                    "09-scenarios/05-nested-splices/05-recursion/01-recursive-pull/setup.bash",
-                ))
-                .status()
-                .unwrap();
-        assert!(status.success());
-        std::env::set_current_dir("monorepo").unwrap();
-    }
-
-    #[test]
-    fn recursive_pull_shows_each_splices_commits_and_pending_work_step_by_step() {
-        with_repository(|| {
-            step_by_step_scenario();
-            let mut named = vec![("s", git(&["rev-parse", "HEAD"]))];
-            let mut context = ExecutionContext::new();
-            let mut execution =
-                start(&mut context, &["--recursive".into(), "vendor/a".into()]).unwrap();
-            let tree = |execution: &mut PullExecution, named: &[(&str, String)]| {
-                let tree = execution
-                    .splice_tree()
-                    .unwrap()
-                    .render(crate::tree::labels(named));
-                println!("{tree}");
-                tree
-            };
-            let mut steps = vec![("start", tree(&mut execution, &named))];
-            let wanted = |event: &ExecutionEvent| {
-                matches!(
-                    event,
-                    ExecutionEvent::AfterFetch { .. }
-                        | ExecutionEvent::AfterMerge { .. }
-                        | ExecutionEvent::BeforeFold { .. }
-                        | ExecutionEvent::AfterFold { .. }
-                )
-            };
-            while let ExecutionOutcome::Paused(event) = execution.run_until(wanted).unwrap() {
-                let step = match event {
-                    ExecutionEvent::AfterMerge {
-                        path, head_after, ..
-                    } => {
-                        let name = match path.rsplit('/').next().unwrap() {
-                            "a" => "pa",
-                            "b" => "pb",
-                            "c" => "pc",
-                            "d" => "pd",
-                            other => panic!("unexpected merge of {other}"),
-                        };
-                        named.push((name, head_after));
-                        "after-merge"
-                    }
-                    ExecutionEvent::AfterFetch { .. } => "after-fetch",
-                    ExecutionEvent::BeforeFold { .. } => "before-fold",
-                    ExecutionEvent::AfterFold { head_after, .. } => {
-                        named.push(("p", head_after));
-                        "after-fold"
-                    }
-                    _ => unreachable!(),
-                };
-                println!("{step}:");
-                steps.push((step, tree(&mut execution, &named)));
-            }
-            let observed: String = steps
-                .iter()
-                .map(|(step, tree)| format!("{step}:\n{tree}"))
-                .collect::<Vec<_>>()
-                .join("\n");
-            assert_eq!(
-                observed,
-                r#"start:
-monorepo   H=s
-vendor/a/  B=s  U=a1  R=a1  T=a1  pending: fetch
-  b/       B=s  U=b1  R=b1  T=b1  pending: fetch
-    c/     B=s  U=c1  R=c1  T=c1  pending: fetch
-  d/       B=s  U=d1  R=d1  T=d1  pending: fetch
-
-after-fetch:
-monorepo   H=s
-vendor/a/  B=s  U=a1  R=a1  T=a2  pending: merge
-  b/       B=s  U=b1  R=b1  T=b2  pending: merge, after vendor/a/
-    c/     B=s  U=c1  R=c1  T=c2  pending: merge, after b/
-  d/       B=s  U=d1  R=d1  T=d2  pending: merge, after vendor/a/
-
-after-merge:
-monorepo   H=pa
-vendor/a/  B=pa  U=a2  R=a2  T=a2  done
-  b/       B=pa  U=b1  R=b1  T=b2  pending: merge
-    c/     B=pa  U=c1  R=c1  T=c2  pending: merge, after b/
-  d/       B=pa  U=d1  R=d1  T=d2  pending: merge
-  e/       B=-   U=?   R=-   T=-
-
-after-fetch:
-monorepo   H=pa
-vendor/a/  B=pa  U=a2  R=a2  T=a2  done
-  b/       B=pa  U=b1  R=b1  T=b2  pending: merge
-    c/     B=pa  U=c1  R=c1  T=c2  pending: merge, after b/
-  d/       B=pa  U=d1  R=d1  T=d2  pending: merge
-  e/       B=pa  U=e1  R=e1  T=e1  pending: merge
-
-after-merge:
-monorepo   H=pb
-vendor/a/  B=pa  U=a2  R=pb'  T=a2  done
-  b/       B=pb  U=b2  R=b2   T=b2  done
-    c/     B=pb  U=c1  R=c1   T=c2  pending: merge
-  d/       B=pa  U=d1  R=d1   T=d2  pending: merge
-  e/       B=pa  U=e1  R=e1   T=e1  done
-
-after-merge:
-monorepo   H=pc
-vendor/a/  B=pa  U=a2  R=pc'  T=a2  done
-  b/       B=pb  U=b2  R=pc'  T=b2  done
-    c/     B=pc  U=c2  R=c2   T=c2  done
-  d/       B=pa  U=d1  R=d1   T=d2  pending: merge
-  e/       B=pa  U=e1  R=e1   T=e1  done
-
-after-merge:
-monorepo   H=pd
-vendor/a/  B=pa  U=a2  R=pd'  T=a2  done
-  b/       B=pb  U=b2  R=pc'  T=b2  done
-    c/     B=pc  U=c2  R=c2   T=c2  done
-  d/       B=pd  U=d2  R=d2   T=d2  done
-  e/       B=pa  U=e1  R=e1   T=e1  done
-
-before-fold:
-monorepo   H=pd
-vendor/a/  B=pa  U=a2  R=pd'  T=a2
-  b/       B=pb  U=b2  R=pc'  T=b2
-    c/     B=pc  U=c2  R=c2   T=c2
-  d/       B=pd  U=d2  R=d2   T=d2
-  e/       B=pa  U=e1  R=e1   T=e1
-next: fold
-
-after-fold:
-monorepo   H=p
-vendor/a/  B=s  U=a2  R=p'  T=a2
-  b/       B=s  U=b2  R=p'  T=b2
-    c/     B=p  U=c2  R=c2  T=c2
-  d/       B=p  U=d2  R=d2  T=d2
-  e/       B=p  U=e1  R=e1  T=e1
-next: clean up
-"#,
-                "observed trees:\n{observed}"
-            );
-        });
-    }
-
     #[test]
     fn pull_rejects_state_changes_between_start_and_first_run() {
         with_repository(|| {
diff --git a/src/tree.rs b/src/tree.rs
index f645d324..bff62ffa 100644
--- a/src/tree.rs
+++ b/src/tree.rs
@@ -1,228 +1,63 @@
-//! The splice tree as a table: each splice's boundary B, synced commit U,
-//! rebuild R and upstream branch T at HEAD, and the work an operation still
-//! has for it. The same picture as a tree drawing, as text.
-
-use crate::repo::*;
-use crate::util::*;
+//! The work an operation did and still does for each splice, as a promise
+//! is pending or settled: for a tree drawing, or a test, to show next to
+//! each splice.
 
 /// What an operation did or still does for a splice.
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub enum Task {
     Done,
+    /// The step that is still to come, e.g. "merge".
     Pending(&'static str),
     Failed,
     Conflict,
 }
 
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Node {
-    pub path: String,
-    /// B: the monorepo commit the rebuild starts at.
-    pub boundary: Option<String>,
-    /// U: the synced commit HEAD's .splice records.
-    pub synced: String,
-    /// R: the rebuild push would send.
-    pub rebuild: Option<String>,
-    /// T: the fetched upstream branch, or pin, the splice follows.
-    pub target: Option<String>,
-    pub task: Option<Task>,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct SpliceTree {
-    pub head: String,
-    /// Splices top-down, a parent before the ones inside it.
-    pub nodes: Vec<Node>,
-    /// The operation's next step that belongs to no single splice.
-    pub next: Option<&'static str>,
-}
-
 /// An operation's work per splice, and its next step beyond them.
-#[derive(Default)]
-pub(crate) struct Tasks {
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+pub struct Tasks {
+    /// Each splice's task, top-down.
     pub per_splice: Vec<(String, Task)>,
+    /// The next step that belongs to no single splice, e.g. "fold".
     pub next: Option<&'static str>,
 }
 
-impl Repo<'_> {
-    pub(crate) fn splice_tree(&mut self, tasks: Tasks) -> Res<SpliceTree> {
-        let head = commit_of("HEAD").ok_or(Fail::Hard)?;
-        let suffix = format!("/{STATE_FILE}");
-        let paths: Vec<String> = self
-            .state_files("HEAD")
-            .iter()
-            .filter_map(|file| file.strip_suffix(&suffix).map(str::to_string))
-            .collect();
-        let branch = self.monorepo_branch.clone();
-        let mut nodes = Vec::new();
-        for path in splices_in_order(false, &paths) {
-            let (boundary, rebuild) = quietly(|| {
-                (
-                    self.splice_start(&path, "HEAD").ok().flatten(),
-                    self.rebuild_splice(&path, "HEAD").ok().flatten(),
-                )
-            });
-            let target = quietly(|| {
-                self.require_splice_upstream(&path).ok()?;
-                let target = self.resolve_upstream_target(&path, &branch).ok()?;
-                commit_of(&target.reference)
-            });
-            let task = tasks
-                .per_splice
-                .iter()
-                .find(|(done, _)| *done == path)
-                .map(|(_, task)| task.clone());
-            nodes.push(Node {
-                synced: splice_config(&path, "commit", "HEAD"),
-                path,
-                boundary,
-                rebuild,
-                target,
-                task,
-            });
-        }
-        Ok(SpliceTree {
-            head,
-            nodes,
-            next: tasks.next,
-        })
-    }
-}
-
-impl SpliceTree {
-    /// The tree as a table, one row per splice, indented inside its parent,
-    /// with each commit as <label> names it:
-    ///
-    /// ```text
-    /// monorepo    H=pa
-    /// vendor/a/   B=s  U=a2  R=pa'  T=a2  done
-    ///   b/        B=s  U=b1  R=b1   T=b2  pending: merge
-    ///     c/      B=s  U=c1  R=c1   T=c2  pending: merge, after b/
-    /// next: fold
-    /// ```
-    pub fn render(&self, label: impl Fn(&str) -> String) -> String {
-        let label = |id: &Option<String>| id.as_deref().map_or("-".to_string(), &label);
-        let parent = |path: &str| {
-            self.nodes
+impl Tasks {
+    /// Each splice's task as text, by path: "pending: merge, after b/" for a
+    /// merge that waits on the splice around it, as merges go top-down.
+    pub fn notes(&self) -> std::collections::HashMap<String, String> {
+        let pending = |path: &str| {
+            self.per_splice
                 .iter()
-                .map(|node| node.path.as_str())
-                .filter(|above| path.starts_with(&format!("{above}/")))
-                .max_by_key(|above| above.len())
+                .any(|(p, task)| p == path && matches!(task, Task::Pending(_)))
         };
-        let depth = |path: &str| {
-            let mut depth = 0;
-            let mut at = path;
-            while let Some(above) = parent(at) {
-                depth += 1;
-                at = above;
-            }
-            depth
-        };
-        let pending = |path: &str| {
-            self.nodes
+        let around = |path: &str| {
+            self.per_splice
                 .iter()
-                .any(|node| node.path == path && matches!(node.task, Some(Task::Pending(_))))
+                .map(|(p, _)| p.as_str())
+                .filter(|p| path.starts_with(&format!("{p}/")))
+                .max_by_key(|p| p.len())
+                .map(str::to_string)
         };
-        let mut rows = vec![vec![
-            "monorepo".to_string(),
-            format!("H={}", label(&Some(self.head.clone()))),
-        ]];
-        for node in &self.nodes {
-            let name = match parent(&node.path) {
-                Some(above) => &node.path[above.len() + 1..],
-                None => node.path.as_str(),
-            };
-            let mut task = match &node.task {
-                None => String::new(),
-                Some(Task::Done) => "done".to_string(),
-                Some(Task::Failed) => "failed".to_string(),
-                Some(Task::Conflict) => "conflict".to_string(),
-                Some(Task::Pending(step)) => format!("pending: {step}"),
-            };
-            // Merges go top-down; fetches run side by side.
-            if let Some(above) = parent(&node.path).filter(|above| pending(above)) {
-                if node.task == Some(Task::Pending("merge")) {
-                    let name = match parent(above) {
-                        Some(top) => &above[top.len() + 1..],
-                        None => above,
-                    };
-                    task.push_str(&format!(", after {name}/"));
+        self.per_splice
+            .iter()
+            .map(|(path, task)| {
+                let mut note = match task {
+                    Task::Done => "done".to_string(),
+                    Task::Failed => "failed".to_string(),
+                    Task::Conflict => "conflict".to_string(),
+                    Task::Pending(step) => format!("pending: {step}"),
+                };
+                if *task == Task::Pending("merge") {
+                    if let Some(above) = around(path).filter(|a| pending(a)) {
+                        let name = match around(&above) {
+                            Some(top) => above[top.len() + 1..].to_string(),
+                            None => above.clone(),
+                        };
+                        note.push_str(&format!(", after {name}/"));
+                    }
                 }
-            }
-            rows.push(vec![
-                format!("{}{name}/", "  ".repeat(depth(&node.path))),
-                format!("B={}", label(&node.boundary)),
-                format!(
-                    "U={}",
-                    label(&Some(node.synced.clone()).filter(|s| !s.is_empty()))
-                ),
-                format!("R={}", label(&node.rebuild)),
-                format!("T={}", label(&node.target)),
-                task,
-            ]);
-        }
-        let columns = rows.iter().map(Vec::len).max().unwrap_or(0);
-        let widths: Vec<usize> = (0..columns)
-            .map(|column| {
-                rows.iter()
-                    .filter_map(|row| row.get(column))
-                    .map(|cell| cell.chars().count())
-                    .max()
-                    .unwrap_or(0)
+                (path.clone(), note)
             })
-            .collect();
-        let mut out = String::new();
-        for row in &rows {
-            let line = row
-                .iter()
-                .enumerate()
-                .map(|(column, cell)| format!("{cell:<width$}", width = widths[column]))
-                .collect::<Vec<_>>()
-                .join("  ");
-            out.push_str(line.trim_end());
-            out.push('\n');
-        }
-        if let Some(next) = self.next {
-            out.push_str(&format!("next: {next}\n"));
-        }
-        out
-    }
-}
-
-/// Labels a commit for [`SpliceTree::render`]: by the name <named> gives it;
-/// as a rebuild, name' for a commit with the subject of one <named> names,
-/// the last one if several have it;
-/// by its subject's label, the "a1" of "a1: a seed", as the scenarios name
-/// their commits; "?" for a commit that isn't here yet; else by its short id.
-pub fn labels<'a>(named: &'a [(&'a str, String)]) -> impl Fn(&str) -> String + 'a {
-    let subject = |id: &str| {
-        git(&["log", "-1", "--format=%s", id])
-            .q()
-            .out()
-            .unwrap_or_default()
-    };
-    let named_subjects: Vec<(&str, String)> = named
-        .iter()
-        .map(|(name, id)| (*name, subject(id)))
-        .collect();
-    move |id: &str| {
-        if let Some((name, _)) = named.iter().find(|(_, known)| known == id) {
-            return (*name).to_string();
-        }
-        if !commit_here(id) {
-            return "?".to_string();
-        }
-        let own = subject(id);
-        if let Some((name, _)) = named_subjects.iter().rev().find(|(_, s)| *s == own) {
-            return format!("{name}'");
-        }
-        if let Some((label, _)) = own.split_once(": ") {
-            if label.chars().all(|c| c.is_ascii_alphanumeric())
-                && label.chars().any(|c| c.is_ascii_digit())
-            {
-                return label.to_string();
-            }
-        }
-        short(id).to_string()
+            .collect()
     }
 }

From 8d43288f8109d93c9a9d0d4864892df56f79e212 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Robert=20Sch=C3=A4fer?= <git@roschaefer.de>
Date: Fri, 13 Nov 2026 22:00:16 +0100
Subject: [PATCH 3/5] fix(tree): record each splice's outcome where the merge
 decides it

The tasks were inferred afterwards from the merge's skipped and failed
lists and its position: the splice whose merge conflicted showed "done"
and the ones waiting behind it "conflict", removed splices and copies
showed "done", splices a failed fetch kept from merging showed "pending"
and then vanished, and "next: fold" showed for pulls that don't fold.

The merge now records an outcome per splice at each decision (done,
conflict, blocked by another splice, failed, removed, copy), pull reports
failed fetches from one rule shared with begin_merges, keeps the outcomes
to the end, and says "fold" only when it folds. The merge step is an enum,
and notes name splices by path, as tree rows can differ in nesting.
---
 check-drawing/tests/recursive_pull.rs |  26 +++---
 src/merge.rs                          |  53 ++++++++---
 src/pull.rs                           | 130 +++++++++++++++++---------
 src/tree.rs                           |  59 +++++++-----
 4 files changed, 174 insertions(+), 94 deletions(-)

diff --git a/check-drawing/tests/recursive_pull.rs b/check-drawing/tests/recursive_pull.rs
index a459ed0d..7822f93c 100644
--- a/check-drawing/tests/recursive_pull.rs
+++ b/check-drawing/tests/recursive_pull.rs
@@ -210,14 +210,14 @@ after-fetch vendor/a vendor/a/b vendor/a/b/c vendor/a/d:
 monorepo      (s)
 └─ vendor/a/  (a1)  pending: merge
    ├─ b/      (b1)  pending: merge, after vendor/a/
-   │  └─ c/   (c1)  pending: merge, after b/
+   │  └─ c/   (c1)  pending: merge, after vendor/a/b/
    └─ d/      (d1)  pending: merge, after vendor/a/
 
 after-merge vendor/a:
 monorepo      (pa*)
 └─ vendor/a/  (a2*)  done
    ├─ b/      (b1)   pending: merge
-   │  └─ c/   (c1)   pending: merge, after b/
+   │  └─ c/   (c1)   pending: merge, after vendor/a/b/
    ├─ d/      (d1)   pending: merge
    └─ e/      (e1)
 
@@ -225,7 +225,7 @@ after-fetch vendor/a/e:
 monorepo      (pa*)
 └─ vendor/a/  (a2*)  done
    ├─ b/      (b1)   pending: merge
-   │  └─ c/   (c1)   pending: merge, after b/
+   │  └─ c/   (c1)   pending: merge, after vendor/a/b/
    ├─ d/      (d1)   pending: merge
    └─ e/      (e1)   pending: merge
 
@@ -255,20 +255,20 @@ monorepo      (pd*)
 
 before-fold:
 monorepo      (pd*)
-└─ vendor/a/  (a2) … [pd'*]
-   ├─ b/      (b2) … [pc'*]
-   │  └─ c/   (c2*)
-   ├─ d/      (d2*)
-   └─ e/      (e1)
+└─ vendor/a/  (a2) … [pd'*]  done
+   ├─ b/      (b2) … [pc'*]  done
+   │  └─ c/   (c2*)          done
+   ├─ d/      (d2*)          done
+   └─ e/      (e1)           done
 next: fold
 
 after-fold:
 monorepo      (p*)
-└─ vendor/a/  (a2*) … [p'*]
-   ├─ b/      (b2*) … [p'*]
-   │  └─ c/   (c2*)
-   ├─ d/      (d2*)
-   └─ e/      (e1)
+└─ vendor/a/  (a2*) … [p'*]  done
+   ├─ b/      (b2*) … [p'*]  done
+   │  └─ c/   (c2*)          done
+   ├─ d/      (d2*)          done
+   └─ e/      (e1)           done
 next: clean up
 "#,
         "observed trees:\n{observed}"
diff --git a/src/merge.rs b/src/merge.rs
index b61ae463..59b5db2b 100644
--- a/src/merge.rs
+++ b/src/merge.rs
@@ -7,7 +7,7 @@ use crate::fetch::{FetchFailures, FetchPlan, FetchResults};
 use crate::message::{self, Message, KNOWN};
 use crate::repo::*;
 use crate::state::*;
-use crate::tree::Task;
+use crate::tree::{Step, Task};
 use crate::util::*;
 use std::collections::HashMap;
 
@@ -840,6 +840,10 @@ pub(crate) struct MergeProgress {
     loaded: HashMap<String, Option<String>>,
     failures: Vec<String>,
     skipped: Vec<String>,
+    /// What became of each path merged so far, as decided.
+    outcomes: Vec<(String, Task)>,
+    /// The path whose merge left a conflict, which the ones after it wait on.
+    conflict: Option<String>,
     recursive: bool,
     branch: String,
     verb: String,
@@ -856,6 +860,8 @@ impl MergeProgress {
             loaded: HashMap::new(),
             failures: Vec::new(),
             skipped: Vec::new(),
+            outcomes: Vec::new(),
+            conflict: None,
             recursive: repo.args.has_flag("--recursive") || (verb == "pull" && repo.args.all),
             branch: branch.to_string(),
             verb: verb.to_string(),
@@ -871,26 +877,25 @@ impl MergeProgress {
         matches!(self.phase, MergePhase::Done)
     }
 
-    /// Each splice merged, failed or left in a conflict so far, and each still to merge.
+    /// What became of each path so far, and each still to merge.
     pub(crate) fn tasks(&self) -> Vec<(String, Task)> {
         self.paths
             .iter()
-            .enumerate()
-            .map(|(index, path)| {
-                let task = if self.skipped.contains(path) {
-                    Task::Conflict
-                } else if self.failures.contains(path) {
-                    Task::Failed
-                } else if index < self.next {
-                    Task::Done
-                } else {
-                    Task::Pending("merge")
-                };
+            .map(|path| {
+                let task = self
+                    .outcomes
+                    .iter()
+                    .find(|(settled, _)| settled == path)
+                    .map_or(Task::Pending(Step::Merge), |(_, task)| task.clone());
                 (path.clone(), task)
             })
             .collect()
     }
 
+    fn settle(&mut self, path: &str, task: Task) {
+        self.outcomes.push((path.to_string(), task));
+    }
+
     pub(crate) fn advance(&mut self, repo: &mut Repo) -> Res<()> {
         if let Some(event) = self.advance_event(repo)? {
             repo.context.emit(event);
@@ -919,6 +924,8 @@ impl MergeProgress {
                 self.next += 1;
                 if splice_in_progress() {
                     self.skipped.push(path.clone());
+                    let waits_on = self.conflict.clone().unwrap_or_default();
+                    self.settle(path, Task::Blocked(waits_on));
                     return Ok(None);
                 }
                 // Reading its .splice again after a merge above failed, e.g. the
@@ -928,6 +935,7 @@ impl MergeProgress {
                         "{path}: not {}, since its {STATE_FILE} from a merge above failed to load",
                         past_tense(verb)
                     ));
+                    self.settle(path, Task::Failed);
                     return Ok(None);
                 }
                 if let Some(failed) = first_above(path, &self.failures) {
@@ -936,6 +944,7 @@ impl MergeProgress {
                         past_tense(verb)
                     ));
                     self.failures.push(path.clone());
+                    self.settle(path, Task::Blocked(failed));
                     return Ok(None);
                 }
                 // Its merge could change the .splice of the failed one again: then
@@ -946,6 +955,7 @@ impl MergeProgress {
                         past_tense(verb)
                     ));
                     self.failures.push(path.clone());
+                    self.settle(path, Task::Blocked(failed));
                     return Ok(None);
                 }
                 // A pull of a splice above this one may have removed it.
@@ -959,6 +969,7 @@ impl MergeProgress {
                             "{path}: not a splice any more -- nothing to {verb}"
                         )),
                     }
+                    self.settle(path, Task::Removed);
                     return Ok(None);
                 }
                 // A copy of a splice it's inside, by its id: pulling it brings in
@@ -976,6 +987,8 @@ impl MergeProgress {
                             "{path}: a copy of {above}, which it's inside -- not {}",
                             past_tense(verb)
                         ));
+                        let above = above.clone();
+                        self.settle(path, Task::Copy(above));
                         return Ok(None);
                     }
                 }
@@ -993,11 +1006,21 @@ impl MergeProgress {
                         }
                     }
                 }
+                let pull_stopped = verb == "pull" && splice_in_progress();
+                let outcome = if splice_in_progress() {
+                    self.conflict = Some(path.clone());
+                    Task::Conflict
+                } else if self.failures.contains(path) {
+                    Task::Failed
+                } else {
+                    Task::Done
+                };
+                self.settle(path, outcome);
                 // The pull stops here: the splices the conflicted merge brings
                 // in are fetched now, as a merge without a conflict would.
                 // A failure here was reported; the run's summary still comes.
-                if verb == "pull" && splice_in_progress() {
-                    return match repo.fetch_below_conflict(path, branch) {
+                if pull_stopped {
+                    return match repo.fetch_below_conflict(path, &self.branch) {
                         Err(Fail::Hard) => Err(Fail::Hard),
                         Err(_) => Ok(None),
                         Ok((event, failures)) => {
diff --git a/src/pull.rs b/src/pull.rs
index ca1834b4..088979e4 100644
--- a/src/pull.rs
+++ b/src/pull.rs
@@ -7,7 +7,7 @@ use crate::fetch::{FetchPlan, FetchResults};
 use crate::merge::{apply_merge_options, MergeProgress, MERGE_OPTIONS};
 use crate::message::{Message, KNOWN};
 use crate::repo::*;
-use crate::tree::{Task, Tasks};
+use crate::tree::{Step, Task, Tasks};
 use crate::util::*;
 
 pub const USAGE: &str = include_str!("usage/pull.txt");
@@ -79,10 +79,19 @@ struct PullProgress {
     fold_roots: Vec<String>,
     rebasing: bool,
     fetch_failures: Vec<String>,
+    /// What the merges did for each splice, once they are over.
+    merged: Vec<(String, Task)>,
     status: i32,
     phase: PullPhase,
 }
 
+/// Why a selected splice isn't merged after the fetch.
+enum NotFetched {
+    Itself,
+    Above(String),
+    Below(String),
+}
+
 impl PullProgress {
     fn new(repo: &mut Repo) -> Res<Self> {
         repo.require_message_template(Message {
@@ -141,6 +150,7 @@ impl PullProgress {
             fold_roots: Vec::new(),
             rebasing: false,
             fetch_failures: Vec::new(),
+            merged: Vec::new(),
             status: 0,
             phase: PullPhase::Fetch(plan),
         })
@@ -169,11 +179,13 @@ impl PullProgress {
                 let event = advanced.as_ref().ok().cloned().flatten();
                 if advanced.is_err() {
                     self.status = 1;
+                    self.merged = merges.tasks();
                     self.phase = PullPhase::Finalize;
                 } else if merges.done() {
                     if merges.finish().is_err() {
                         self.status = 1;
                     }
+                    self.merged = merges.tasks();
                     self.phase = PullPhase::Finalize;
                 } else {
                     self.phase = PullPhase::Merge(merges);
@@ -182,7 +194,7 @@ impl PullProgress {
             }
             PullPhase::Finalize => {
                 let allowed = self.recursive && !splice_in_progress();
-                if allowed && self.status == 0 {
+                if self.folds() {
                     let observed_head = commit_of("HEAD");
                     let event = observed_head
                         .as_ref()
@@ -214,27 +226,38 @@ impl PullProgress {
         }
     }
 
+    /// Why selected splice <path> isn't merged, if a fetch failed for it.
+    fn not_fetched(&self, path: &str) -> Option<NotFetched> {
+        if self.fetch_failures.iter().any(|failed| failed == path) {
+            return Some(NotFetched::Itself);
+        }
+        if let Some(failed) = first_above(path, &self.fetch_failures) {
+            return Some(NotFetched::Above(failed));
+        }
+        // Its pull could move the synced commit of the failed one to one that
+        // wasn't fetched.
+        first_below(path, &self.fetch_failures).map(NotFetched::Below)
+    }
+
+    /// Whether the merges end in folding: a recursive pull with no conflict
+    /// left and no failure.
+    fn folds(&self) -> bool {
+        self.recursive && !splice_in_progress() && self.status == 0
+    }
+
     fn begin_merges(&mut self, repo: &mut Repo) -> Res<()> {
         let mut fetched = Vec::new();
         for path in &self.selected {
-            if self.fetch_failures.contains(path) {
-                continue;
-            }
-            if let Some(failed) = first_above(path, &self.fetch_failures) {
-                log_err(format!(
+            match self.not_fetched(path) {
+                None => fetched.push(path.clone()),
+                Some(NotFetched::Itself) => {}
+                Some(NotFetched::Above(failed)) => log_err(format!(
                     "{path}: not pulled, since {failed} above it wasn't fetched"
-                ));
-                continue;
-            }
-            // Its pull could move the synced commit of the failed one to one that
-            // wasn't fetched.
-            if let Some(failed) = first_below(path, &self.fetch_failures) {
-                log_err(format!(
+                )),
+                Some(NotFetched::Below(failed)) => log_err(format!(
                 "{path}: not pulled, since {failed} below it wasn't fetched -- 'git splice merge {path}' merges what was fetched anyway"
-            ));
-                continue;
+            )),
             }
-            fetched.push(path.clone());
         }
 
         // A recursive pull is one commit per splice it starts from, made of its
@@ -644,35 +667,54 @@ impl Operation for PullProgress {
         let _ = self.say_if_detached();
     }
     fn tasks(&self) -> Tasks {
-        let pending = |step| {
-            self.selected
+        // A splice a failed fetch keeps from merging, from the report on.
+        let unfetched = |path: &String| match self.not_fetched(path)? {
+            NotFetched::Itself => Some(Task::Failed),
+            NotFetched::Above(failed) | NotFetched::Below(failed) => Some(Task::Blocked(failed)),
+        };
+        let with = |merges: &[(String, Task)], or: Task| -> Vec<(String, Task)> {
+            let mut tasks: Vec<(String, Task)> = self
+                .selected
                 .iter()
-                .map(|path| (path.clone(), Task::Pending(step)))
-                .collect()
+                .map(|path| {
+                    let task = unfetched(path)
+                        .or_else(|| {
+                            merges
+                                .iter()
+                                .find(|(p, _)| p == path)
+                                .map(|(_, t)| t.clone())
+                        })
+                        .unwrap_or_else(|| or.clone());
+                    (path.clone(), task)
+                })
+                .collect();
+            // Splices the merges found below the selected ones.
+            for (path, task) in merges {
+                if !tasks.iter().any(|(p, _)| p == path) {
+                    tasks.push((path.clone(), task.clone()));
+                }
+            }
+            tasks
         };
-        match &self.phase {
-            PullPhase::Fetch(_) => Tasks {
-                per_splice: pending("fetch"),
-                next: None,
-            },
-            PullPhase::Fetched(_) | PullPhase::Reported => Tasks {
-                per_splice: pending("merge"),
-                next: None,
-            },
-            PullPhase::Merge(merges) => Tasks {
-                per_splice: merges.tasks(),
-                next: None,
-            },
-            PullPhase::Finalize | PullPhase::Fold { .. } => Tasks {
-                per_splice: Vec::new(),
-                next: self.recursive.then_some("fold"),
-            },
-            PullPhase::Cleanup { .. } => Tasks {
-                per_splice: Vec::new(),
-                next: Some("clean up"),
-            },
-            PullPhase::Done => Tasks::default(),
-        }
+        let (per_splice, next) = match &self.phase {
+            PullPhase::Fetch(_) | PullPhase::Fetched(_) => (
+                self.selected
+                    .iter()
+                    .map(|path| (path.clone(), Task::Pending(Step::Fetch)))
+                    .collect(),
+                None,
+            ),
+            PullPhase::Reported => (with(&[], Task::Pending(Step::Merge)), None),
+            PullPhase::Merge(merges) => (with(&merges.tasks(), Task::Pending(Step::Merge)), None),
+            PullPhase::Finalize => {
+                let next = if self.folds() { "fold" } else { "clean up" };
+                (with(&self.merged, Task::Done), Some(next))
+            }
+            PullPhase::Fold { .. } => (with(&self.merged, Task::Done), Some("fold")),
+            PullPhase::Cleanup { .. } => (with(&self.merged, Task::Done), Some("clean up")),
+            PullPhase::Done => (with(&self.merged, Task::Done), None),
+        };
+        Tasks { per_splice, next }
     }
 }
 
diff --git a/src/tree.rs b/src/tree.rs
index bff62ffa..e1beab0d 100644
--- a/src/tree.rs
+++ b/src/tree.rs
@@ -2,14 +2,31 @@
 //! is pending or settled: for a tree drawing, or a test, to show next to
 //! each splice.
 
-/// What an operation did or still does for a splice.
+use std::collections::HashMap;
+
+/// A step an operation still has to take for a splice.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Step {
+    Fetch,
+    /// Merges go top-down: a splice's waits for the one around it.
+    Merge,
+}
+
+/// What an operation did or still does for a splice, as it decided it.
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub enum Task {
+    Pending(Step),
     Done,
-    /// The step that is still to come, e.g. "merge".
-    Pending(&'static str),
-    Failed,
+    /// Its merge stopped in a conflict.
     Conflict,
+    /// Not merged: it waits on the splice at this path, which stopped in a
+    /// conflict or failed.
+    Blocked(String),
+    Failed,
+    /// The pull above removed it, or it isn't a splice any more.
+    Removed,
+    /// A copy of the splice at this path, which it's inside: not merged.
+    Copy(String),
 }
 
 /// An operation's work per splice, and its next step beyond them.
@@ -22,13 +39,14 @@ pub struct Tasks {
 }
 
 impl Tasks {
-    /// Each splice's task as text, by path: "pending: merge, after b/" for a
-    /// merge that waits on the splice around it, as merges go top-down.
-    pub fn notes(&self) -> std::collections::HashMap<String, String> {
-        let pending = |path: &str| {
+    /// Each splice's task as text, by path, naming other splices by their
+    /// path: "pending: merge, after vendor/a/" for a merge that waits on the
+    /// splice around it.
+    pub fn notes(&self) -> HashMap<String, String> {
+        let pending_merge = |path: &str| {
             self.per_splice
                 .iter()
-                .any(|(p, task)| p == path && matches!(task, Task::Pending(_)))
+                .any(|(p, task)| p == path && *task == Task::Pending(Step::Merge))
         };
         let around = |path: &str| {
             self.per_splice
@@ -36,26 +54,23 @@ impl Tasks {
                 .map(|(p, _)| p.as_str())
                 .filter(|p| path.starts_with(&format!("{p}/")))
                 .max_by_key(|p| p.len())
-                .map(str::to_string)
         };
         self.per_splice
             .iter()
             .map(|(path, task)| {
-                let mut note = match task {
+                let note = match task {
+                    Task::Pending(Step::Fetch) => "pending: fetch".to_string(),
+                    Task::Pending(Step::Merge) => match around(path).filter(|a| pending_merge(a)) {
+                        Some(above) => format!("pending: merge, after {above}/"),
+                        None => "pending: merge".to_string(),
+                    },
                     Task::Done => "done".to_string(),
-                    Task::Failed => "failed".to_string(),
                     Task::Conflict => "conflict".to_string(),
-                    Task::Pending(step) => format!("pending: {step}"),
+                    Task::Blocked(on) => format!("blocked by {on}/"),
+                    Task::Failed => "failed".to_string(),
+                    Task::Removed => "removed".to_string(),
+                    Task::Copy(of) => format!("copy of {of}/"),
                 };
-                if *task == Task::Pending("merge") {
-                    if let Some(above) = around(path).filter(|a| pending(a)) {
-                        let name = match around(&above) {
-                            Some(top) => above[top.len() + 1..].to_string(),
-                            None => above.clone(),
-                        };
-                        note.push_str(&format!(", after {name}/"));
-                    }
-                }
                 (path.clone(), note)
             })
             .collect()

From adbd1fc652f646eafba1f4eb421de60d65504444 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Robert=20Sch=C3=A4fer?= <git@roschaefer.de>
Date: Sat, 14 Nov 2026 11:46:42 +0100
Subject: [PATCH 4/5] test(check-drawing): isolate the pull tests and show a
 conflict

The test changed its own process's HOME, Git configuration variables and
working directory, as #483 stopped doing for git-splice's tests, left
GIT_COMMON_DIR and the like set, and left its folder behind on a panic.
Each test now runs in a child process of the test binary without any
GIT_* variable, in a folder a guard removes.

A second test makes b's merge conflict: b shows the conflict and the
commit it merges in, c and d wait on it. The binary's crate comment now
points at the library instead of repeating it.
---
 check-drawing/src/main.rs             |   8 +-
 check-drawing/tests/recursive_pull.rs | 124 +++++++++++++++++++++-----
 2 files changed, 102 insertions(+), 30 deletions(-)

diff --git a/check-drawing/src/main.rs b/check-drawing/src/main.rs
index f3553ec5..c18951fe 100644
--- a/check-drawing/src/main.rs
+++ b/check-drawing/src/main.rs
@@ -1,10 +1,4 @@
-//! check-drawing: checks a draw.io drawing of commit graphs against the
-//! repositories it shows. See README.md next to src/ for the drawing's
-//! vocabulary and its limits.
-//!
-//! What it reads about a splice, its boundary, rebuild, keys and the folders
-//! it had, comes from git-splice's own code, so a drawing is checked against
-//! what the tool really does.
+//! The check-drawing command: see the library, lib.rs, for what it checks.
 
 use check_drawing::check::{Checker, Labels};
 use check_drawing::{labels, placement, tree};
diff --git a/check-drawing/tests/recursive_pull.rs b/check-drawing/tests/recursive_pull.rs
index 7822f93c..d94aa4e0 100644
--- a/check-drawing/tests/recursive_pull.rs
+++ b/check-drawing/tests/recursive_pull.rs
@@ -27,22 +27,41 @@ fn git(args: &[&str]) -> String {
         .to_string()
 }
 
-/// A folder of its own, ignoring the developer's Git configuration; the
-/// upstreams' https://git.example.com URLs lead to bare repositories in it.
-fn sandbox() -> PathBuf {
-    let root = std::env::temp_dir().join(format!(
-        "check-drawing-recursive-pull-{}",
-        std::process::id()
-    ));
-    let _ = std::fs::remove_dir_all(&root);
-    std::fs::create_dir_all(root.join("home")).unwrap();
-    let root = root.canonicalize().unwrap();
-    for name in ["GIT_DIR", "GIT_WORK_TREE", "GIT_INDEX_FILE", "GIT_CONFIG"] {
-        std::env::remove_var(name);
+const CHILD: &str = "CHECK_DRAWING_TEST_CHILD";
+
+/// A folder that is removed when it goes out of scope, also after a panic.
+struct Sandbox(PathBuf);
+
+impl Drop for Sandbox {
+    fn drop(&mut self) {
+        let _ = std::fs::remove_dir_all(&self.0);
+    }
+}
+
+/// Runs test <name> in a child process of this test binary, in a folder of
+/// its own: its environment and current directory stay out of other tests,
+/// and the developer's Git configuration and GIT_* variables out of it. The
+/// upstreams' https://git.example.com URLs lead to bare repositories in that
+/// folder, which is removed afterwards.
+fn isolated(name: &str, test: impl FnOnce(&Path)) {
+    if std::env::var(CHILD).as_deref() == Ok(name) {
+        test(&std::env::current_dir().unwrap());
+        return;
+    }
+    let folder = std::env::temp_dir().join(format!("check-drawing-{name}-{}", std::process::id()));
+    let _ = std::fs::remove_dir_all(&folder);
+    std::fs::create_dir_all(folder.join("home")).unwrap();
+    let sandbox = Sandbox(folder.canonicalize().unwrap());
+    let root = &sandbox.0;
+    let mut child = std::process::Command::new(std::env::current_exe().unwrap());
+    child
+        .args([name, "--exact", "--nocapture", "--test-threads=1"])
+        .current_dir(root);
+    for (key, _) in std::env::vars_os() {
+        if key.to_string_lossy().starts_with("GIT_") {
+            child.env_remove(&key);
+        }
     }
-    std::env::set_var("HOME", root.join("home"));
-    std::env::set_var("GIT_CONFIG_GLOBAL", "/dev/null");
-    std::env::set_var("GIT_CONFIG_NOSYSTEM", "1");
     let mut config = vec![
         ("user.name".to_string(), "Test".to_string()),
         ("user.email".to_string(), "test@example.com".to_string()),
@@ -53,12 +72,19 @@ fn sandbox() -> PathBuf {
             format!("https://git.example.com/{x}.git"),
         ));
     }
-    std::env::set_var("GIT_CONFIG_COUNT", config.len().to_string());
+    child
+        .env(CHILD, name)
+        .env("HOME", root.join("home"))
+        .env("GIT_CONFIG_GLOBAL", "/dev/null")
+        .env("GIT_CONFIG_NOSYSTEM", "1")
+        .env("GIT_CONFIG_COUNT", config.len().to_string());
     for (index, (key, value)) in config.iter().enumerate() {
-        std::env::set_var(format!("GIT_CONFIG_KEY_{index}"), key);
-        std::env::set_var(format!("GIT_CONFIG_VALUE_{index}"), value);
+        child
+            .env(format!("GIT_CONFIG_KEY_{index}"), key)
+            .env(format!("GIT_CONFIG_VALUE_{index}"), value);
     }
-    root
+    let status = child.status().unwrap();
+    assert!(status.success(), "isolated test {name} failed: {status}");
 }
 
 /// The step-by-step page's state: its setup.bash, then the same upstream
@@ -129,8 +155,11 @@ fn drawing(name: &str, revs: &[(&str, &str)]) {
 
 #[test]
 fn recursive_pull_step_by_step() {
-    let root = sandbox();
-    step_by_step_scenario(&root);
+    isolated("recursive_pull_step_by_step", step_by_step);
+}
+
+fn step_by_step(root: &Path) {
+    step_by_step_scenario(root);
     // e1 isn't here until the pull fetches e's upstream: named by its hash.
     let e1 = git(&[
         "-C",
@@ -195,8 +224,6 @@ fn recursive_pull_step_by_step() {
     }
     let observed = steps.join("\n");
     println!("{observed}");
-    std::env::set_current_dir(std::env::temp_dir()).unwrap();
-    let _ = std::fs::remove_dir_all(&root);
     assert_eq!(
         observed,
         r#"start:
@@ -274,3 +301,54 @@ next: clean up
         "observed trees:\n{observed}"
     );
 }
+
+#[test]
+fn recursive_pull_conflict_blocks_the_splices_after_it() {
+    isolated(
+        "recursive_pull_conflict_blocks_the_splices_after_it",
+        conflict,
+    );
+}
+
+/// The monorepo changed b's file where b's upstream did too: b's merge stops
+/// in a conflict, and the splices after it wait on it.
+fn conflict(root: &Path) {
+    step_by_step_scenario(root);
+    std::fs::write(
+        "vendor/a/b/file.txt",
+        std::fs::read_to_string("vendor/a/b/file.txt").unwrap() + "b in the monorepo\n",
+    )
+    .unwrap();
+    git(&["commit", "-q", "-am", "m1: b in the monorepo"]);
+    let e1 = git(&[
+        "-C",
+        root.join("upstream-e.git").to_str().unwrap(),
+        "rev-parse",
+        "main",
+    ]);
+    let mut named = vec![("e1", e1)];
+    let mut context = ExecutionContext::new();
+    let mut execution =
+        pull::start(&mut context, &["--recursive".into(), "vendor/a".into()]).unwrap();
+    let paused = execution
+        .run_until(|event| matches!(event, ExecutionEvent::AfterMerge { .. }))
+        .unwrap();
+    let ExecutionOutcome::Paused(ExecutionEvent::AfterMerge { head_after, .. }) = paused else {
+        panic!("no merge: {paused:?}");
+    };
+    named.push(("pa", head_after));
+    assert_eq!(execution.run().unwrap(), 1);
+    let observed = tree(&execution, &named);
+    println!("{observed}");
+    assert_eq!(
+        observed,
+        r#"monorepo      (pa*)
+└─ vendor/a/  (a2*) … [pa']       done
+   ├─ b/      (b1) … [m1'] (b2!)  conflict
+   │  └─ c/   (c1)                blocked by vendor/a/b/
+   ├─ d/      (d1)                blocked by vendor/a/b/
+   └─ e/      (e1)                done
+"#,
+        "observed tree:\n{observed}"
+    );
+}

From e2b4c8becf38cd72e76ae0c99b8708f97580a780 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Robert=20Sch=C3=A4fer?= <git@roschaefer.de>
Date: Sat, 14 Nov 2026 13:21:45 +0100
Subject: [PATCH 5/5] fix(tree): keep a merge pending until the merges settle
 it

A pull that stopped before its merges ran, e.g. when planning them failed, showed every splice as done: splices without a recorded outcome defaulted to done once the merges phase was over. Every merged splice records its outcome, so the default only ever hid work that never ran.
---
 src/pull.rs | 19 +++++++++++++------
 1 file changed, 13 insertions(+), 6 deletions(-)

diff --git a/src/pull.rs b/src/pull.rs
index 088979e4..49523ca0 100644
--- a/src/pull.rs
+++ b/src/pull.rs
@@ -706,13 +706,20 @@ impl Operation for PullProgress {
             ),
             PullPhase::Reported => (with(&[], Task::Pending(Step::Merge)), None),
             PullPhase::Merge(merges) => (with(&merges.tasks(), Task::Pending(Step::Merge)), None),
-            PullPhase::Finalize => {
-                let next = if self.folds() { "fold" } else { "clean up" };
-                (with(&self.merged, Task::Done), Some(next))
+            // A splice keeps its merge pending unless the merges settled it.
+            PullPhase::Finalize
+            | PullPhase::Fold { .. }
+            | PullPhase::Cleanup { .. }
+            | PullPhase::Done => {
+                let next = match &self.phase {
+                    PullPhase::Finalize if self.folds() => Some("fold"),
+                    PullPhase::Finalize => Some("clean up"),
+                    PullPhase::Fold { .. } => Some("fold"),
+                    PullPhase::Cleanup { .. } => Some("clean up"),
+                    _ => None,
+                };
+                (with(&self.merged, Task::Pending(Step::Merge)), next)
             }
-            PullPhase::Fold { .. } => (with(&self.merged, Task::Done), Some("fold")),
-            PullPhase::Cleanup { .. } => (with(&self.merged, Task::Done), Some("clean up")),
-            PullPhase::Done => (with(&self.merged, Task::Done), None),
         };
         Tasks { per_splice, next }
     }