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..c18951fe 100644
--- a/check-drawing/src/main.rs
+++ b/check-drawing/src/main.rs
@@ -1,19 +1,7 @@
-//! 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.
 
-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..d94aa4e0
--- /dev/null
+++ b/check-drawing/tests/recursive_pull.rs
@@ -0,0 +1,354 @@
+//! 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()
+}
+
+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);
+        }
+    }
+    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"),
+        ));
+    }
+    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() {
+        child
+            .env(format!("GIT_CONFIG_KEY_{index}"), key)
+            .env(format!("GIT_CONFIG_VALUE_{index}"), value);
+    }
+    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
+/// 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() {
+    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",
+        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}");
+    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 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 vendor/a/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 vendor/a/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'*]  done
+   ├─ b/      (b2) … [pc'*]  done
+   │  └─ c/   (c2*)          done
+   ├─ d/      (d2*)          done
+   └─ e/      (e1)           done
+next: fold
+
+after-fold:
+monorepo      (p*)
+└─ 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}"
+    );
+}
+
+#[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}"
+    );
+}
diff --git a/docs/10-contributing/01-development.md b/docs/10-contributing/01-development.md
index 86dba9c9..d15338e2 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` | `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 141ef111..d119847d 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::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,11 @@ impl<'context, O: Operation> Execution<'context, O> {
         Ok(ExecutionOutcome::Complete(status))
     }
 
+    /// 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> {
         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..59b5db2b 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::{Step, Task};
 use crate::util::*;
 use std::collections::HashMap;
 
@@ -839,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,
@@ -855,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(),
@@ -870,6 +877,25 @@ impl MergeProgress {
         matches!(self.phase, MergePhase::Done)
     }
 
+    /// What became of each path so far, and each still to merge.
+    pub(crate) fn tasks(&self) -> Vec<(String, Task)> {
+        self.paths
+            .iter()
+            .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);
@@ -898,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
@@ -907,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) {
@@ -915,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
@@ -925,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.
@@ -938,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
@@ -955,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);
                     }
                 }
@@ -972,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 ab20d83c..49523ca0 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::{Step, Task, Tasks};
 use crate::util::*;
 
 pub const USAGE: &str = include_str!("usage/pull.txt");
@@ -42,6 +43,11 @@ impl PullExecution<'_> {
         self.inner.run()
     }
 
+    /// 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
     /// refs, configuration, tracked files, index and pull markers must remain
     /// unchanged in the predicate and while paused.
@@ -73,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 {
@@ -135,6 +150,7 @@ impl PullProgress {
             fold_roots: Vec::new(),
             rebasing: false,
             fetch_failures: Vec::new(),
+            merged: Vec::new(),
             status: 0,
             phase: PullPhase::Fetch(plan),
         })
@@ -163,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);
@@ -176,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()
@@ -208,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
@@ -637,6 +666,63 @@ impl Operation for PullProgress {
     fn stopped(&self) {
         let _ = self.say_if_detached();
     }
+    fn tasks(&self) -> Tasks {
+        // 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| {
+                    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
+        };
+        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),
+            // 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)
+            }
+        };
+        Tasks { per_splice, next }
+    }
 }
 
 #[cfg(test)]
diff --git a/src/tree.rs b/src/tree.rs
new file mode 100644
index 00000000..e1beab0d
--- /dev/null
+++ b/src/tree.rs
@@ -0,0 +1,78 @@
+//! 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.
+
+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,
+    /// 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.
+#[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 Tasks {
+    /// 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 && *task == Task::Pending(Step::Merge))
+        };
+        let around = |path: &str| {
+            self.per_splice
+                .iter()
+                .map(|(p, _)| p.as_str())
+                .filter(|p| path.starts_with(&format!("{p}/")))
+                .max_by_key(|p| p.len())
+        };
+        self.per_splice
+            .iter()
+            .map(|(path, 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::Conflict => "conflict".to_string(),
+                    Task::Blocked(on) => format!("blocked by {on}/"),
+                    Task::Failed => "failed".to_string(),
+                    Task::Removed => "removed".to_string(),
+                    Task::Copy(of) => format!("copy of {of}/"),
+                };
+                (path.clone(), note)
+            })
+            .collect()
+    }
+}