commandertui 1.4.2__tar.gz → 1.5.0__tar.gz

{commandertui-1.4.2 → commandertui-1.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: commandertui
-Version: 1.4.2
+Version: 1.5.0
 Summary: Dual-pane retro terminal file manager: compare, sync, copy and move folders
 Author: Humberto Barchini
 License-Expression: MIT
@@ -260,3 +260,20 @@ first version, **Claude Opus 5.5** did most of v0.2 and the v1.0 packaging.
 ## License
 
 MIT — see [LICENSE](LICENSE).
+
+
+## Copy/move conflicts
+
+F5 (Copy) and F6 (Move) check the destination before transferring. Existing
+items open a dialog focused on **Skip**: overwrite, skip, rename, or ask for
+each conflict (with **Apply to all remaining**). Copy also offers **Only newer**
+and **Merge** for existing folders; Merge asks how to handle conflicting files.
+Overwrite on folders keeps destination-only files. Repeated source names use
+the same policy; rename selects free `_1`, `_2`, … names.
+
+Transfers run with cancellable progress. Skipped and unfinished sources stay
+marked. Moves verify each copied file before trashing its source; skipped
+and failed files stay in the source. Existing files always require a decision,
+even when size and date match: Overwrite copies/moves them, while Skip (or
+Only newer for identical files) retains them. The completion message reports
+copied, skipped, failed, and identical files retained by a move.

{commandertui-1.4.2 → commandertui-1.5.0}/README.md

@@ -241,3 +241,20 @@ first version, **Claude Opus 5.5** did most of v0.2 and the v1.0 packaging.
 ## License
 
 MIT — see [LICENSE](LICENSE).
+
+
+## Copy/move conflicts
+
+F5 (Copy) and F6 (Move) check the destination before transferring. Existing
+items open a dialog focused on **Skip**: overwrite, skip, rename, or ask for
+each conflict (with **Apply to all remaining**). Copy also offers **Only newer**
+and **Merge** for existing folders; Merge asks how to handle conflicting files.
+Overwrite on folders keeps destination-only files. Repeated source names use
+the same policy; rename selects free `_1`, `_2`, … names.
+
+Transfers run with cancellable progress. Skipped and unfinished sources stay
+marked. Moves verify each copied file before trashing its source; skipped
+and failed files stay in the source. Existing files always require a decision,
+even when size and date match: Overwrite copies/moves them, while Skip (or
+Only newer for identical files) retains them. The completion message reports
+copied, skipped, failed, and identical files retained by a move.

commandertui-1.5.0/commandertui/__init__.py

@@ -0,0 +1 @@
+__version__ = "1.5.0"

commandertui-1.5.0/commandertui/conflicts.py

@@ -0,0 +1,183 @@
+"""Read-only copy/move collision detection and pure per-entry decisions.
+
+Identity is metadata-based, not a content comparison: SMB/GVFS can report
+misleading sizes/mtimes. As in diff.py, equal sizes and mtimes within two
+seconds count as identical. Every existing file is still a conflict requiring
+an explicit resolution, including metadata-identical files.
+"""
+
+from __future__ import annotations
+
+import os
+import stat
+from collections import Counter
+from dataclasses import dataclass, field, replace
+from enum import Enum
+from typing import Literal
+
+from .diff import MTIME_TOLERANCE_SECONDS
+from .models import EntryKind, FileEntry, OpKind
+from .scanner import scan_directory
+
+
+@dataclass(frozen=True)
+class Conflict:
+    rel_path: str
+    name: str
+    src: FileEntry
+    dst: FileEntry
+    kind_mismatch: bool
+    newer: Literal["src", "dst", "same"]
+    identical: bool = False
+
+
+@dataclass
+class ConflictReport:
+    conflicts: list[Conflict] = field(default_factory=list)
+    identical: int = 0
+    dir_collisions: list[str] = field(default_factory=list)
+    total_src_files_new: int = 0
+    duplicate_sources: list[str] = field(default_factory=list)
+    identical_paths: list[str] = field(default_factory=list)
+    conflicts_by_source: dict[str, Conflict] = field(default_factory=dict)
+
+    @property
+    def has_conflicts(self) -> bool:
+        return bool(self.conflicts or self.duplicate_sources)
+
+
+class Resolution(str, Enum):
+    OVERWRITE = "overwrite"
+    SKIP = "skip"
+    ONLY_NEWER = "only_newer"
+    RENAME = "rename"
+    MERGE = "merge"
+    CANCEL = "cancel"
+
+
+def allowed_resolutions(kind: OpKind) -> list[Resolution]:
+    if kind == OpKind.COPY:
+        return list(Resolution)
+    if kind == OpKind.MOVE:
+        return [Resolution.OVERWRITE, Resolution.SKIP, Resolution.RENAME, Resolution.CANCEL]
+    raise ValueError(f"Unsupported operation: {kind}")
+
+
+def rename_target(path: str) -> str:
+    """Suggest a free sibling (not reserved); even dangling symlinks occupy names."""
+    stem, extension = os.path.splitext(path)
+    index = 1
+    while True:
+        candidate = f"{stem}_{index}{extension}"
+        if not os.path.lexists(candidate):
+            return candidate
+        index += 1
+
+
+def resolve(conflict: Conflict, resolution: Resolution) -> Literal["copy", "skip", "rename"]:
+    """Choose an action without touching either side, including for MOVE skips.
+
+    MERGE is a tree-level policy: missing files copy directly, while collisions
+    need another per-file resolution. CANCEL must be handled by the caller.
+    Neither is a valid per-conflict decision here.
+    """
+    if resolution == Resolution.OVERWRITE:
+        return "copy"
+    if resolution == Resolution.SKIP:
+        return "skip"
+    if resolution == Resolution.RENAME:
+        return "rename"
+    if resolution == Resolution.ONLY_NEWER:
+        return "copy" if conflict.newer == "src" else "skip"
+    raise ValueError(f"{resolution} requires caller-level handling")
+
+
+def _entry(path: str, rel_path: str) -> FileEntry:
+    metadata = os.lstat(path)
+    kind = (
+        EntryKind.SYMLINK
+        if stat.S_ISLNK(metadata.st_mode)
+        else EntryKind.DIR if stat.S_ISDIR(metadata.st_mode) else EntryKind.FILE
+    )
+    return FileEntry(
+        rel_path,
+        os.path.basename(rel_path),
+        kind,
+        0 if kind == EntryKind.DIR else metadata.st_size,
+        metadata.st_mtime,
+    )
+
+
+def detect_conflicts(sources: list[str], dst_dir: str, cancel_check=None) -> ConflictReport:
+    """Return collisions with paths relative to dst_dir, including source basename.
+
+    Uses scanner exclusions and never follows symlinks. Directory/type collisions
+    block their subtree, so descendants are not reported as independently new.
+    Cancellation returns an empty report rather than a misleading partial result.
+    """
+    names = Counter(os.path.basename(os.path.normpath(source)) for source in sources)
+    report = ConflictReport(duplicate_sources=[name for name, count in names.items() if count > 1])
+
+    def cancelled() -> bool:
+        return bool(cancel_check and cancel_check())
+
+    def compare(src: FileEntry, dst: FileEntry) -> None:
+        src_abs = os.path.join(os.path.dirname(os.path.abspath(source)), src.rel_path)
+        mismatch = src.kind != dst.kind
+        delta = src.mtime - dst.mtime
+        newer = "same" if abs(delta) <= MTIME_TOLERANCE_SECONDS else "src" if delta > 0 else "dst"
+        identical = not mismatch and src.size == dst.size and newer == "same"
+        if identical:
+            report.identical += 1
+            report.identical_paths.append(src_abs)
+        conflict = Conflict(src.rel_path, src.name, src, dst, mismatch, newer, identical)
+        report.conflicts.append(conflict)
+        report.conflicts_by_source[src_abs] = conflict
+
+    for source in sources:
+        if cancelled():
+            return ConflictReport()
+        name = os.path.basename(os.path.normpath(source))
+        src = _entry(source, name)
+        target = os.path.join(dst_dir, name)
+        dst = _entry(target, name) if os.path.lexists(target) else None
+        if src.kind != EntryKind.DIR:
+            if dst is None:
+                report.total_src_files_new += 1
+            else:
+                compare(src, dst)
+            continue
+        if dst is not None and dst.kind != EntryKind.DIR:
+            compare(src, dst)
+            continue
+        left = scan_directory(source, cancel_check=cancel_check)
+        if cancelled():
+            return ConflictReport()
+        if dst is None:
+            report.total_src_files_new += sum(e.kind != EntryKind.DIR for e in left.values())
+            continue
+        report.dir_collisions.append(name)
+        right = scan_directory(target, cancel_check=cancel_check)
+        if cancelled():
+            return ConflictReport()
+        blocked: set[str] = set()
+        for path, entry in left.items():
+            if cancelled():
+                return ConflictReport()
+            if any(parent in blocked for parent in _parents(path)):
+                continue
+            other = right.get(path)
+            if other is None:
+                report.total_src_files_new += entry.kind != EntryKind.DIR
+            elif entry.kind != EntryKind.DIR or other.kind != EntryKind.DIR:
+                compare(replace(entry, rel_path=f"{name}/{path}"), replace(other, rel_path=f"{name}/{path}"))
+                if entry.kind == EntryKind.DIR:
+                    blocked.add(path)
+    return report
+
+
+def _parents(path: str):
+    parent = os.path.dirname(path)
+    while parent:
+        yield parent
+        parent = os.path.dirname(parent)

{commandertui-1.4.2 → commandertui-1.5.0}/commandertui/main_screen.py

@@ -24,6 +24,7 @@ from .modals import (
 )
 from .models import OpKind, OpSide, OperationQueue, QueuedOp
 from .run_queue import run_queue_with_progress
+from .run_transfer import run_transfer
 from .scanner import path_size
 from .widgets import PARENT_MARK, FilePanel, FunctionBar, MainTopBar
 
@@ -350,7 +351,9 @@ class MainScreen(Screen):
                     )
                 else:
                     self.app.push_screen(
-                        MessageScreen("The update did not finish. Check the terminal output, then try again.")
+                        MessageScreen(
+                            "The update did not finish. The package index may not have the new version yet:\nwait a few minutes and try again, or check the terminal output."
+                        )
                     )
 
         self.app.push_screen(UpdateScreen(info), on_choice)
@@ -491,25 +494,7 @@ class MainScreen(Screen):
             self._nothing_selected()
             return
 
-        side = OpSide.LEFT_TO_RIGHT if src_panel.side == "left" else OpSide.RIGHT_TO_LEFT
-        queue = OperationQueue()
-        for item in items:
-            rel_path = os.path.relpath(item, src_panel.path)
-            queue.add(QueuedOp(kind, side, rel_path, os.path.isdir(item), size=path_size(item)))
-
-        def after(report) -> None:
-            src_panel.marked.clear()
-            src_panel.refresh_listing()
-            dst_panel.refresh_listing()
-
-        run_queue_with_progress(
-            self,
-            f"{label} to {dst_panel.path}",
-            queue,
-            self._panel("left").path,
-            self._panel("right").path,
-            after,
-        )
+        run_transfer(self, kind, label, src_panel, dst_panel, items)
 
     # ------------------------------------------------------------- misc
     def action_show_compare(self) -> None:

{commandertui-1.4.2 → commandertui-1.5.0}/commandertui/modals.py

@@ -7,7 +7,7 @@ import time
 
 from textual.app import ComposeResult
 from textual.binding import Binding
-from textual.containers import Horizontal, Vertical
+from textual.containers import Horizontal, Vertical, VerticalScroll
 from textual.screen import ModalScreen
 from textual.widgets import Button, DataTable, Input, OptionList, Static
 
@@ -698,3 +698,204 @@ class UpdateScreen(ModalScreen[str]):
 
     def action_skip(self) -> None:
         self.dismiss("skip")
+
+
+class ConflictScreen(ModalScreen):
+    """One safe decision for a batch or one collision; no filesystem changes."""
+
+    DEFAULT_CSS = """
+    ConflictScreen { align: center middle; }
+    #conflict-box { width: 80%; min-width: 60; max-width: 100; height: auto; max-height: 95%;
+        border: heavy $foreground; padding: 1 3; overflow: hidden hidden; }
+    ConflictScreen.compact #conflict-box { padding: 0 2; }
+    #conflict-title { text-style: bold; margin-bottom: 1; max-height: 2; }
+    #conflict-summary { height: auto; margin-bottom: 1; overflow: hidden auto; }
+    #conflict-buttons { height: auto; overflow: hidden hidden; }
+    #conflict-buttons Button { position: absolute; min-width: 0; height: 3; margin: 0; }
+    #apply-remaining { margin-top: 1; }
+    ConflictScreen.compact #apply-remaining { margin-top: 0; }
+    """
+
+    BINDINGS = [
+        Binding(key, f"choose('{value}')", label, priority=True)
+        for key, value, label in [
+            ("o", "overwrite", "Overwrite"),
+            ("s", "skip", "Skip"),
+            ("n", "only_newer", "Only newer"),
+            ("r", "rename", "Rename"),
+            ("m", "merge", "Merge"),
+            ("a", "ask", "Ask each"),
+            ("c", "cancel", "Cancel"),
+            ("escape", "cancel", "Cancel"),
+        ]
+    ]
+
+    def __init__(self, report, dst_dir, kind, *, rel_path=None, file_policy=False, summary=None):
+        super().__init__()
+        from .conflicts import Resolution, allowed_resolutions
+
+        self.report_data = report
+        self.dst_dir = dst_dir
+        self.kind = kind
+        self.rel_path = rel_path
+        self.file_policy = file_policy
+        self.summary_text = summary
+        self.options = [
+            r.value
+            for r in allowed_resolutions(kind)
+            if r != Resolution.MERGE or (report.dir_collisions and not file_policy and rel_path is None)
+        ]
+        if not file_policy and rel_path is None:
+            self.options.insert(-1, "ask")
+
+    def compose(self):
+        from textual.widgets import Checkbox
+
+        report = self.report_data
+        count = len(
+            {c.rel_path for c in report.conflicts}
+            | set(report.dir_collisions)
+            | set(report.duplicate_sources)
+        )
+        title = (
+            f"Resolve {self.rel_path}"
+            if self.rel_path
+            else (
+                "Choose a policy for conflicting files"
+                if self.file_policy
+                else f"{count} items already exist"
+            )
+        )
+        entries = report.conflicts
+        if self.rel_path:
+            entries = [c for c in entries if c.rel_path == self.rel_path]
+        lines = [f"in {self.dst_dir}"]
+        if report.identical:
+            lines.append(f"({report.identical} identical: same size and date)")
+        for conflict in entries[:6]:
+
+            def side(entry, label):
+                date = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(entry.mtime))
+                return f"{label}: {_human_bytes(entry.size)}, {date}"
+
+            label = "identical" if conflict.identical else f"newer: {conflict.newer}"
+            lines.append(
+                f"{conflict.rel_path}: {side(conflict.src, 'Source')} | "
+                f"{side(conflict.dst, 'Destination')} — {label}"
+            )
+        if len(entries) > 6:
+            lines.append(f"... and {len(entries) - 6} more")
+        if report.dir_collisions:
+            lines.append("Existing folders: " + ", ".join(report.dir_collisions[:6]))
+        if report.duplicate_sources:
+            lines.append("Repeated source names: " + ", ".join(report.duplicate_sources))
+        labels = {
+            "overwrite": "Overwrite (o)",
+            "skip": "Skip (s)",
+            "only_newer": "Only newer (n)",
+            "rename": "Rename (r)",
+            "merge": "Merge (m)",
+            "ask": "Ask each (a)",
+            "cancel": "Cancel (Esc)",
+        }
+        if report.dir_collisions and not self.file_policy:
+            labels["overwrite"] = "Overwrite (keeps extra files) (o)"
+        with Vertical(id="conflict-box"):
+            yield Static(title, id="conflict-title", markup=False)
+            with VerticalScroll(id="conflict-summary"):
+                yield Static(self.summary_text or "\n".join(lines), id="conflict-list", markup=False)
+            with Vertical(id="conflict-buttons"):
+                for option in self.options:
+                    yield Button(labels[option], id=f"conflict-{option}")
+            if self.rel_path:
+                yield Checkbox("Apply to all remaining (l)", id="apply-remaining")
+
+    def on_mount(self):
+        self._resize_layout()
+        self.query_one("#conflict-skip", Button).focus()
+
+    def on_resize(self):
+        self._resize_layout()
+
+    def _resize_layout(self):
+        self.set_class(self.size.width < 125 or self.size.height < 30, "compact")
+        self.call_after_refresh(self._layout_controls)
+
+    def _layout_controls(self):
+        """Wrap measured button widths; reserve fixed space outside the list.
+
+        Reposition existing buttons instead of remounting them, preserving
+        focus and the Ask each checkbox when the terminal is resized.
+        """
+        from rich.cells import cell_len
+
+        box = self.query_one("#conflict-box")
+        controls = self.query_one("#conflict-buttons")
+        buttons = list(controls.query(Button))
+        available = controls.content_size.width
+        if not available:
+            return
+        compact = self.has_class("compact")
+        margin = 1 if compact else 2
+        widths = [
+            max(14 if compact else 18, cell_len(str(button.label)) + max(4, button.gutter.width))
+            for button in buttons
+        ]
+        rows = [list(range(min(3, len(buttons)))), list(range(3, len(buttons)))]
+        if compact or any(sum(widths[i] + 2 * margin for i in row) > available for row in rows):
+            rows = []
+            row = []
+            used = 0
+            for index, width in enumerate(widths):
+                if row and used + width + 2 * margin > available:
+                    rows.append(row)
+                    row, used = [], 0
+                row.append(index)
+                used += width + 2 * margin
+            if row:
+                rows.append(row)
+        y = 1
+        for row in filter(None, rows):
+            used = sum(widths[i] + 2 * margin for i in row)
+            x = max(0, (available - used) // 2)
+            for index in row:
+                button = buttons[index]
+                button.styles.width = min(widths[index], available - 2 * margin)
+                button.styles.offset = (x + margin, y)
+                x += widths[index] + 2 * margin
+            y += 3 if compact else 4
+        controls.styles.height = y if compact else y - 1
+        title = self.query_one("#conflict-title")
+        summary = self.query_one("#conflict-summary")
+        checkbox = self.query("#apply-remaining")
+        checkbox_height = (3 + (0 if compact else 1)) if checkbox else 0
+        # Auto height keeps the established large-dialog proportions. Only the
+        # summary is capped and scrollable; focus can never scroll the box.
+        reserved = (
+            box.gutter.height
+            + min(2, title.get_content_height(box.content_size, self.size, available))
+            + title.styles.margin.height
+            + int(controls.styles.height.value)
+        )
+        reserved += checkbox_height + summary.styles.margin.height
+        summary.styles.max_height = max(1, int(self.size.height * 0.95) - reserved)
+
+    def action_choose(self, value):
+        from textual.widgets import Checkbox
+
+        if value not in self.options:
+            return
+        apply = self.query_one("#apply-remaining", Checkbox).value if self.rel_path else False
+        self.dismiss((value, apply))
+
+    def action_cancel(self):
+        self.dismiss(("cancel", False))
+
+    def key_l(self):
+        if self.rel_path:
+            checkbox = self.query_one("#apply-remaining")
+            checkbox.value = not checkbox.value
+
+    def on_button_pressed(self, event: Button.Pressed):
+        event.stop()
+        self.action_choose(event.button.id.removeprefix("conflict-"))

commandertui-1.5.0/commandertui/run_transfer.py

@@ -0,0 +1,191 @@
+"""Textual orchestration for the shared copy/move transfer engine."""
+
+from __future__ import annotations
+
+import os
+import time
+from dataclasses import replace
+
+from .conflicts import Resolution, detect_conflicts
+from .executor import TransferStatus
+from .modals import ConfirmScreen, ConflictScreen, MessageScreen
+from .models import OpKind, OpSide, OperationQueue, QueuedOp
+from .progress_screen import ProgressScreen
+from .scanner import tree_stats
+from .transfer import ConflictPolicy, build_transfer_plan, execute_transfer_plan
+
+CANCELLED_TEXT = (
+    "Cancelled.\n\nFiles already copied stay at the destination.\n"
+    "The file in progress was discarded - no half-copied files were left.\n"
+    "For a move, the source of anything unfinished is still in place."
+)
+
+
+def run_transfer(owner, kind, label, src_panel, dst_panel, sources):
+    destination = dst_panel.path
+    scanning = ProgressScreen("Checking copy/move conflicts…", len(sources))
+    owner.app.push_screen(scanning)
+
+    def scanned(report, queue, error=None):
+        scanning.dismiss()
+        if error:
+            owner.app.push_screen(MessageScreen(f"Could not scan sources: {error}"))
+        elif scanning.cancel_requested:
+            owner.app.push_screen(MessageScreen(CANCELLED_TEXT))
+        elif report.has_conflicts or report.dir_collisions:
+            choose_policy(report)
+        else:
+            owner.app.push_screen(
+                ConfirmScreen(f"{label} to {destination}", queue),
+                lambda confirmed: (
+                    execute(report, ConflictPolicy(Resolution.OVERWRITE)) if confirmed else None
+                ),
+            )
+
+    def scan():
+        try:
+            report = detect_conflicts(sources, destination, lambda: scanning.cancel_requested)
+            queue = OperationQueue()
+            side = OpSide.LEFT_TO_RIGHT if src_panel.side == "left" else OpSide.RIGHT_TO_LEFT
+            for source in sources:
+                _, _, size = tree_stats([source], lambda: scanning.cancel_requested)
+                queue.add(
+                    QueuedOp(
+                        kind, side, os.path.relpath(source, src_panel.path), os.path.isdir(source), size=size
+                    )
+                )
+            owner.app.call_from_thread(scanned, report, queue)
+        except Exception as error:
+            owner.app.call_from_thread(scanned, None, None, str(error))
+
+    def choose_policy(report):
+        def selected(answer):
+            value, _ = answer
+            if value == "cancel":
+                return
+            if value == "ask":
+                ask_each(report)
+            elif value == "merge":
+
+                def merged(answer):
+                    value, _ = answer
+                    if value != "cancel":
+                        execute(
+                            report,
+                            ConflictPolicy(
+                                Resolution(value), {path: Resolution.MERGE for path in report.dir_collisions}
+                            ),
+                        )
+
+                owner.app.push_screen(ConflictScreen(report, destination, kind, file_policy=True), merged)
+            else:
+                execute(report, ConflictPolicy(Resolution(value)))
+
+        owner.app.push_screen(ConflictScreen(report, destination, kind), selected)
+
+    def ask_each(report):
+        # A rel_path is the policy key, so homonymous source names share a
+        # decision, displayed explicitly in the summary.
+        paths = list(dict.fromkeys([c.rel_path for c in report.conflicts] + report.duplicate_sources))
+        paths += [p for p in report.dir_collisions if not any(x == p or x.startswith(p + "/") for x in paths)]
+        policy = ConflictPolicy(Resolution.SKIP)
+
+        def next_item(index):
+            if index == len(paths):
+                execute(report, policy)
+                return
+
+            def selected(answer):
+                value, apply = answer
+                if value == "cancel":
+                    return  # Nothing has executed yet, including prior decisions.
+                remaining = paths[index:] if apply else [paths[index]]
+                for path in remaining:
+                    policy.overrides[path] = Resolution(value)
+                next_item(len(paths) if apply else index + 1)
+
+            owner.app.push_screen(ConflictScreen(report, destination, kind, rel_path=paths[index]), selected)
+
+        next_item(0)
+
+    def execute(report, policy):
+        progress = ProgressScreen(f"{label} to {destination}", len(sources))
+        owner.app.push_screen(progress)
+
+        def work():
+            try:
+                plan = build_transfer_plan(sources, destination, kind, report, policy)
+                status = TransferStatus(ops_total=len(plan.items))
+                for item in plan.items:
+                    if item.action != "skip":
+                        files, _, size = tree_stats([item.src_abs], lambda: progress.cancel_requested)
+                        status.files_total += files
+                        status.bytes_total += size
+                last = 0.0
+                current_done = 0
+                completed = set()
+                previous_failures = 0
+
+                def update(done, total, name):
+                    nonlocal last, current_done
+                    if done == 0:
+                        current_done = 0
+                        status.files_done += 1
+                    status.bytes_done += done - current_done
+                    current_done = done
+                    status.file_name, status.file_done, status.file_total = name, done, total
+                    now = time.monotonic()
+                    if now - last >= 0.1 or done == total:
+                        last = now
+                        owner.app.call_from_thread(progress.report, replace(status))
+
+                def on_item(item, result):
+                    nonlocal previous_failures
+                    status.ops_done += 1
+                    if (
+                        item.action != "skip"
+                        and not result.cancelled
+                        and len(result.failed) == previous_failures
+                    ):
+                        completed.add(item.src_abs)
+                    previous_failures = len(result.failed)
+                    owner.app.call_from_thread(progress.report, replace(status))
+
+                result = execute_transfer_plan(plan, kind, update, lambda: progress.cancel_requested, on_item)
+                owner.app.call_from_thread(finish, plan, result, completed)
+            except Exception as error:
+                owner.app.call_from_thread(failed, str(error))
+
+        def failed(error):
+            progress.dismiss()
+            owner.app.push_screen(MessageScreen(f"Could not transfer: {error}"))
+
+        def finish(plan, result, completed):
+            progress.dismiss()
+            for source in sources:
+                related = [
+                    item
+                    for item in plan.items
+                    if item.src_abs == source or item.src_abs.startswith(source + os.sep)
+                ]
+                if (related and all(item.src_abs in completed for item in related)) or (
+                    not related and not result.cancelled and not result.failed and source in plan.source_dirs
+                ):
+                    src_panel.marked.discard(source)
+            src_panel.refresh_listing()
+            dst_panel.refresh_listing()
+            summary = f"{result.copied} copied, {len(result.skipped)} skipped, {len(result.failed)} failed"
+            identical_kept = result.identical_kept or plan.identical_kept
+            if kind == OpKind.MOVE and identical_kept:
+                summary += f"\n{identical_kept} identical files stayed in the source"
+            if result.cancelled:
+                owner.app.push_screen(MessageScreen(CANCELLED_TEXT + "\n\n" + summary))
+            elif result.failed:
+                errors = "\n".join(f"{path}: {error}" for path, error in result.failed[:10])
+                owner.app.push_screen(MessageScreen(summary + "\n" + errors))
+            else:
+                owner.notify(summary)
+
+        owner.call_after_refresh(lambda: owner.run_worker(work, thread=True))
+
+    owner.call_after_refresh(lambda: owner.run_worker(scan, thread=True))