devlyn-cli 4.3.31 → 4.3.33

package/native/codex/plugins/devlyn/skills/_shared/task-complete.py

@@ -695,6 +695,12 @@ def retained_modules(receipt):
             + str(Path(gitdir) / 'modules') + '; retain')
 
 
+def refuse_submodules(receipt, work, gitlinks):
+    retained_modules(receipt)
+    require(not any(path_present(work / relative / '.git') for relative in gitlinks),
+            'working tree contains populated submodules; preserve their source and explicitly resolve them; retain')
+
+
 def remove_managed_registration(receipt):
     retained_modules(receipt)
     require(not path_present(receipt['worktree']), 'managed tree reappeared; retain registration')
@@ -765,10 +771,7 @@ def removal_eligibility(receipt, path, *, abandonment, partial):
             require(stage == '0' and known.get(relative) == (mode, oid), 'partial checkout index changed; retain: ' + relative)
             indexed[relative] = (mode, oid)
     require(abandonment or indexed == known, 'removal index changed; retain')
-    retained_modules(receipt)
-    require(not any(mode == '160000' and path_present(work / relative / '.git')
-                        for relative, (mode, oid) in known.items()),
-            'working tree contains populated submodules; preserve their source and explicitly resolve them; retain')
+    refuse_submodules(receipt, work, [relative for relative, (mode, oid) in known.items() if mode == '160000'])
     # Git's own comparison applies eol/clean filters and gitlink semantics. A
     # private baseline index also handles an interrupted checkout's missing entries.
     with tempfile.TemporaryDirectory(prefix='.removal-index-', dir=path.parent) as temporary:
@@ -1241,7 +1244,11 @@ def removable(receipt, work):
     # native removal would delete it with its uncommitted work.
     nested = [p for p in git(work, "ls-files", "--others", "--ignored", "--exclude-standard", "-z").split("\0") if p.endswith("/")]
     require(not nested, "nested repository or worktree inside the task tree: " + ", ".join(nested) + "; retain")
-    if not storage_call('managed_receipt', receipt):
+    if storage_call('managed_receipt', receipt):
+        return
+    if sys.platform == "win32":
+        outside(work)  # The move that starts the removal is the writer check there (move_aside).
+    else:
         stopped_writers(work)
 
 
@@ -1369,6 +1376,10 @@ def clean_scratch(receipt, path, writers_stopped):
     require(scratch == scratch.resolve() and scratch.is_dir(), "owned scratch missing or redirected; retain and inspect")
     identity = workspace_identity(scratch, path.parent)
     require(same_workspace_identity(identity, receipt["scratch_identity"]), "scratch directory was replaced; retain")
+    if sys.platform == "win32" and not any(scratch.iterdir()):  # Nothing to delete, so nothing the refusals below guard.
+        receipt["scratch_cleanup"] = {"status": "CLEAN", "logical_bytes_removed": 0}
+        atomic_json(path, receipt)
+        return receipt["scratch_cleanup"]
     require(shutil.rmtree.avoids_symlink_attacks, "safe scratch removal unsupported on this platform; retain")
     require(not any(mount.is_relative_to(scratch) for mount in scratch_mounts()), "scratch contains a mounted filesystem; retain")
     stopped_writers(scratch)
@@ -1417,7 +1428,110 @@ def verify_custody(receipt, path):
     require(read_json(path.parent / 'manifest.json') == receipt['files'], 'custody manifest changed')
 
 
-def cleanup_workspace(receipt, path, *, warnings):
+def preserve_records(receipt, path, work):
+    records = records_manifest(work)
+    if records:
+        destination = path.parent / "records"
+        if os.path.lexists(destination) and records_manifest(destination) != records:
+            digest = hashlib.sha256(json.dumps(records, sort_keys=True, separators=(",", ":")).encode()).hexdigest()[:12]
+            destination = path.parent / ("records." + digest)
+        if not os.path.lexists(destination):
+            with tempfile.TemporaryDirectory(prefix=".records-", dir=path.parent) as temporary:
+                shutil.copytree(safe_path(work, ".devlyn"), Path(temporary) / ".devlyn", symlinks=True)
+                require(records_manifest(Path(temporary)) == records, ".devlyn changed while it was copied; stop its writer and resume")
+                Path(temporary).rename(destination)
+        require(records_manifest(destination) == records, f"records copy mismatch; repair and resume: {destination}")
+        if storage_call("managed_receipt", receipt):
+            receipt["storage"]["records_custody"] = {"path": str(destination), "files": records}
+            atomic_json(path, receipt)
+    return records
+
+
+def aside(work):
+    return work.with_name(work.name + ".devlyn-removing")
+
+
+@contextlib.contextmanager
+def long_paths():
+    # The move lengthens every path in the tree; Git for Windows reads and deletes past MAX_PATH only with long paths.
+    # Every Git child started in the span inherits it, after the entries the environment already has (Git 2.31).
+    count = int(os.environ.get("GIT_CONFIG_COUNT") or 0)
+    names = ("GIT_CONFIG_COUNT", f"GIT_CONFIG_KEY_{count}", f"GIT_CONFIG_VALUE_{count}")
+    saved = {name: os.environ.get(name) for name in names}
+    os.environ.update(zip(names, (str(count + 1), "core.longpaths", "true")))
+    try:
+        yield
+    finally:
+        for name, value in saved.items():
+            if value is None:
+                os.environ.pop(name, None)
+            else:
+                os.environ[name] = value
+
+
+def move_aside(work):
+    # Windows refuses to rename a folder while a process holds a handle in it or below it. The Windows error stays in
+    # the message: a refusal can also be an access denied for another reason.
+    try:
+        os.rename(work, aside(work))
+    except PermissionError as exc:
+        raise WriterActive(f"a program still uses {work} ({exc}); close it, then resume") from exc
+    except OSError as exc:
+        raise WritersUnobservable(f"cannot move {work} aside to remove it ({exc}); retain") from exc
+
+
+def remove_by_moving(receipt, work):
+    """The Windows removal of a merged or on-base tree: its move is the writer check and is never undone."""
+    moved = aside(work)
+    # Git's unforced removal would refuse these after the move, so they are refused while the tree is in place.
+    refuse_submodules(receipt, work, [item.split("\t", 1)[1] for item in
+                                      gref(receipt, "ls-tree", "-r", "-z", receipt["publish_sha"]).split("\0")
+                                      if item.startswith("160000 ")])
+    require(not path_present(moved) and all(not moved.is_relative_to(p) and not p.is_relative_to(moved)
+                                             for p in map(Path, registrations(receipt))),
+            f"{moved} exists or overlaps a registered worktree; leave it, keep {work}, inspect both, then resume")
+    version = re.match(r"git version (\d+)\.(\d+)", command(["git", "--version"]))
+    if not version or (int(version[1]), int(version[2])) < (2, 31):
+        raise WritersUnobservable("removing a task checkout on Windows needs Git 2.31 or later; update Git, then resume")
+    move_aside(work)
+    with long_paths():
+        gref(receipt, "worktree", "repair", str(moved))
+        gref(receipt, "worktree", "remove", str(moved))
+
+
+@long_paths()
+def remove_moved(receipt, path, work, anchor):
+    """Finish a Windows removal interrupted after its move, forward only, rechecking the moved tree."""
+    require(receipt.get("writers_released"), "wait actual children, stop/yield known writers, then resume with --writers-stopped")
+    moved = aside(work)
+    foreign = f"{moved} cannot be verified as the task checkout moved from {work}; leave both, inspect them, then resume"
+    pointer = moved / ".git"
+    require(path_present(pointer) and stat.S_ISREG(pointer.lstat().st_mode), foreign)
+    kind, _, value = pointer.read_text(encoding="utf-8").partition(":")
+    gitdir = Path(os.path.normpath(moved / value.strip()))
+    require(kind == "gitdir" and gitdir == Path(receipt["worktree_gitdir"]), foreign)
+    # A prune, or a Git removal that failed part way, deletes the registration that Git needs to remove the tree. Only
+    # the folder's own inode, which a rename keeps, then tells the checkout from another folder naming that Gitdir.
+    if not path_present(gitdir):
+        require(moved.stat().st_ino == receipt["worktree_identity"][0][1], foreign)
+        raise CompletionError(f"{moved} is the task checkout moved from {work}, but its Git registration is gone; "
+                              "inspect it and remove it by hand, then resume")
+    require(gitdir.is_dir() and same_workspace_identity(workspace_identity(moved, gitdir), receipt["worktree_identity"]), foreign)
+    # Until the repair, Git may list the tree at its original path only, never another registration at the moved one.
+    row = registrations(receipt).get(str(moved.resolve()))
+    require(row is None or row.get("branch") == "refs/heads/" + receipt["branch"], foreign)
+    verify_files(moved, receipt["files"])
+    records = preserve_records(receipt, path, moved)
+    outside(moved)
+    require(anchor is None or not (os.path.samefile(moved, anchor) if os.path.exists(anchor) else moved == anchor),
+            "cannot clean the current allocation's anchor checkout: " + str(anchor))
+    gref(receipt, "worktree", "repair", str(moved))
+    removable(dict(receipt, worktree=str(moved)), moved)
+    require(records_manifest(moved) == records, ".devlyn changed after it was copied; stop its writer and resume")
+    gref(receipt, "worktree", "remove", str(moved))
+
+
+def cleanup_workspace(receipt, path, *, warnings, anchor=None):
     sha = receipt["publish_sha"]
     branch_ref = "refs/heads/" + receipt["branch"]
     work = Path(receipt["worktree"])
@@ -1434,21 +1548,7 @@ def cleanup_workspace(receipt, path, *, warnings):
             partial = storage_call("managed_receipt", receipt) and "tree_removal_digest" in receipt["storage"]
             if not partial:
                 removable(receipt, work)
-            records = {} if partial else records_manifest(work)
-            if records:
-                destination = path.parent / "records"
-                if os.path.lexists(destination) and records_manifest(destination) != records:
-                    digest = hashlib.sha256(json.dumps(records, sort_keys=True, separators=(",", ":")).encode()).hexdigest()[:12]
-                    destination = path.parent / ("records." + digest)
-                if not os.path.lexists(destination):
-                    with tempfile.TemporaryDirectory(prefix=".records-", dir=path.parent) as temporary:
-                        shutil.copytree(safe_path(work, ".devlyn"), Path(temporary) / ".devlyn", symlinks=True)
-                        require(records_manifest(Path(temporary)) == records, ".devlyn changed while it was copied; stop its writer and resume")
-                        Path(temporary).rename(destination)
-                require(records_manifest(destination) == records, f"records copy mismatch; repair and resume: {destination}")
-                if storage_call("managed_receipt", receipt):
-                    receipt["storage"]["records_custody"] = {"path": str(destination), "files": records}
-                    atomic_json(path, receipt)
+            records = {} if partial else preserve_records(receipt, path, work)
             if not partial:
                 removable(receipt, work)
                 require(records_manifest(work) == records, ".devlyn changed after it was copied; stop its writer and resume")
@@ -1457,6 +1557,8 @@ def cleanup_workspace(receipt, path, *, warnings):
                 if str(work) in registrations(receipt):
                     remove_managed_registration(receipt)
                 sync_surviving_directory(Path(receipt["common_gitdir"]) / "worktrees")
+            elif sys.platform == "win32":
+                remove_by_moving(receipt, work)
             else:
                 gref(receipt, "worktree", "remove", str(work))
         else:
@@ -1467,6 +1569,8 @@ def cleanup_workspace(receipt, path, *, warnings):
                 sync_surviving_directory(work.parent)
                 sync_surviving_directory(Path(receipt["common_gitdir"]) / "worktrees")
             else:
+                if sys.platform == "win32" and path_present(aside(work)):
+                    remove_moved(receipt, path, work, anchor)
                 require(str(work) not in registrations(receipt), "missing worktree is still registered; retain")
         if storage_call("managed_receipt", receipt):
             finish_managed_removal(receipt, path, managed_registration(receipt, recovery=True))
@@ -1480,18 +1584,25 @@ def cleanup_workspace(receipt, path, *, warnings):
             sync_surviving_directory(Path(receipt['common_gitdir']) / 'worktrees')
 
 
-def cleanup(receipt, path, pr, *, warnings=None):
-    warnings = [] if warnings is None else warnings
+def verify_delivery(receipt, path, pr):
+    """Evidence that the accepted source is delivered, checked before anything is removed."""
     if pr is not None:
         require(pr["state"] == "MERGED" and pr.get("mergedAt") and pr.get("mergeCommit", {}).get("oid"), "actual matching merge evidence is required")
     sha = receipt["publish_sha"]
-    branch_ref = "refs/heads/" + receipt["branch"]
     # The recovery ref keeps the accepted commit reachable, so squash and
     # rebase merges need only the merge commit on base.
     verify_custody(receipt, path)
     gref(receipt, "merge-base", "--is-ancestor", pr["mergeCommit"]["oid"] if pr else sha, remote_base(receipt))
     gref(receipt, "merge-base", "--is-ancestor", receipt["source_sha"], sha)
-    cleanup_workspace(receipt, path, warnings=warnings)
+    # The base was fetched through the remote's name, so that name must still bind the receipt's repository.
+    require(remote_url(receipt) == receipt["remote_url"], "remote changed during the delivery checks; retain resources")
+
+
+def remove_delivered(receipt, path, *, warnings=None, anchor=None):
+    warnings = [] if warnings is None else warnings
+    sha = receipt["publish_sha"]
+    branch_ref = "refs/heads/" + receipt["branch"]
+    cleanup_workspace(receipt, path, warnings=warnings, anchor=anchor)
     checked_out = [p for p, row in registrations(receipt).items() if row.get("branch") == branch_ref]
     require(not checked_out, "task branch is still checked out at " + ", ".join(checked_out) + "; switch it off the task branch before cleanup")
     # Check ownership/ref identity once more immediately before each deletion.
@@ -1511,6 +1622,11 @@ def cleanup(receipt, path, pr, *, warnings=None):
     atomic_json(path, receipt)
 
 
+def cleanup(receipt, path, pr, *, warnings=None, anchor=None):
+    verify_delivery(receipt, path, pr)
+    remove_delivered(receipt, path, warnings=warnings, anchor=anchor)
+
+
 def resolve_receipt(path, *, operation_id=None):
     """Resolve a lost retirement reply without guessing between operations."""
     require(path.name == 'receipt.json' and path == path.resolve(), 'receipt locator must be nonsymlink and absolute')
@@ -1630,13 +1746,17 @@ def completion_result(receipt, path, status, *, warnings=None):
 
 
 def cleanup_delivered(receipt, path, pr, *, warnings=None):
+    # Missing evidence leaves delivery unrecorded; once it holds, a refused removal retains what it guards.
+    verify_delivery(receipt, path, pr)
     try:
-        cleanup(receipt, path, pr, warnings=warnings)
+        remove_delivered(receipt, path, warnings=warnings)
     except (CompletionError, OSError) as error:
-        managed_outage = storage_call('managed_receipt', receipt)
-        if not isinstance(error, (WritersUnobservable, WriterActive)) and not managed_outage:
+        if receipt.get('status') == 'COMPLETE':
+            # Every workspace and ref removal finished and only the final record write failed: the resume ends COMPLETE,
+            # or CLEANUP_PENDING while a scratch cleanup retained on its own remains.
             raise
-        reason = manual_removal(receipt, path, error) if managed_outage and isinstance(error, WritersUnobservable) else str(error)
+        managed = storage_call('managed_receipt', receipt)
+        reason = manual_removal(receipt, path, error) if managed and isinstance(error, WritersUnobservable) else str(error)
         receipt['workspace_cleanup'] = {'status': 'RETAINED', 'reason': reason, 'resume': receipt_resume('complete', path, receipt)}
         atomic_json(path, receipt)
 
@@ -1681,7 +1801,14 @@ def reconcile(common, allocated, anchor, *, exclude_receipts=(), warnings=None):
                 if storage_call("managed_receipt", receipt):
                     cleanup_delivered(receipt, path, pr, warnings=warnings)
                 else:
-                    cleanup(receipt, path, pr, warnings=warnings)
+                    try:
+                        cleanup(receipt, path, pr, warnings=warnings, anchor=anchor)
+                    except (CompletionError, OSError) as error:
+                        if "workspace_cleanup" in receipt:
+                            # A retained cleanup names its latest refusal, which may guard less than the first.
+                            receipt["workspace_cleanup"]["reason"] = str(error)
+                            atomic_json(path, receipt)
+                        raise
                 results.append(completion_result(receipt, path, "COMPLETE", warnings=warnings))
         except (Exception, SystemExit) as error:
             results.append({"receipt": str(path), "status": "RETAINED", "reason": str(error)})
@@ -1794,7 +1921,7 @@ def complete(args, *, warnings=None):
             inspect_workspace(receipt)
             verify_files(Path(receipt["worktree"]), receipt["files"])
             require(remote_head(receipt, receipt["branch"]) == receipt["publish_sha"], "remote head race before merge")
-            refused = None
+            refused = waits = None
             if not pr.get("autoMergeRequest"):
                 if not info["mergeCommitAllowed"]:
                     refused = "repository disallows merge commits"
@@ -1818,9 +1945,11 @@ def complete(args, *, warnings=None):
                                 break
                             if attempt < 9:
                                 time.sleep(2)
-                        if state not in {"CLEAN", "HAS_HOOKS", "UNSTABLE"}:
+                        if state in {"BLOCKED", "UNKNOWN"}:
+                            waits = state
+                        elif state not in {"CLEAN", "HAS_HOOKS", "UNSTABLE"}:
                             refused = "pull request is not mergeable: " + state
-                    if not refused:
+                    if not refused and not waits:
                         try:
                             gh(receipt, "pr", "merge", str(pr["number"]), *auto, "--merge", "--match-head-commit", receipt["publish_sha"])
                         except CompletionError as error:
@@ -1828,8 +1957,10 @@ def complete(args, *, warnings=None):
             pr = json.loads(gh(receipt, "pr", "view", str(pr["number"]), "--json", PR_FIELDS))
             validate_pr(receipt, pr)
             if pr["state"] != "MERGED":
-                # Merge only when the repository allows it; a refused request leaves the PR for a person.
-                return dict(result("PR"), merge_refused=refused) if refused and not pr.get("autoMergeRequest") else result("PENDING")
+                # Only a refusal leaves the PR for a person; merge_waits: the resume merges once the PR is mergeable.
+                if refused and not pr.get("autoMergeRequest"):
+                    return dict(result("PR"), merge_refused=refused)
+                return dict(result("PENDING"), **({"merge_waits": waits} if waits else {}))
         if pr:
             receipt["merge"] = pr
             atomic_json(path, receipt)
@@ -2089,6 +2220,9 @@ class CompletionTests(unittest.TestCase):
         self.bin.mkdir()
         self.data = self.root / "gh.json"
         self.data.write_text(json.dumps({"bare": str(self.bare)}), encoding="utf-8")
+        # A commit's detached automatic maintenance would still write into .git while a test reads the tree. A file, not
+        # GIT_CONFIG_COUNT: the storage suite reuses this fixture with a native helper that refuses that variable.
+        (self.root / "gitconfig").write_text("[maintenance]\n\tauto = false\n", encoding="utf-8")
         self.env = {**os.environ, "GIT_CONFIG_NOSYSTEM": "1", "GIT_CONFIG_GLOBAL": str(self.root / "gitconfig"),
                     "GIT_AUTHOR_NAME": "Fixture", "GIT_AUTHOR_EMAIL": "fixture@example.invalid",
                     "GIT_COMMITTER_NAME": "Fixture", "GIT_COMMITTER_EMAIL": "fixture@example.invalid",
@@ -2144,6 +2278,14 @@ class CompletionTests(unittest.TestCase):
                                   repository="test/project", base="main", remote="origin", worktree=str(worktree),
                                   local_base=None, from_receipt=None, start=None)
 
+    def test_fixture_commit_starts_no_automatic_maintenance(self):
+        # Its detached child would still write into .git while a test reads the tree or cleanup removes it.
+        trace = self.root / "trace.json"
+        self.env["GIT_TRACE2_EVENT"] = str(trace)
+        self.g("commit", "-q", "--allow-empty", "-m", "traced")
+        children = [line for line in trace.read_text(encoding="utf-8").splitlines() if '"event":"child_start"' in line]
+        self.assertEqual(children, [])
+
     def test_allocation_marks_exclusively_created_empty_target_before_checkout(self):
         # Prediction: persisted intent precedes exclusive creation and marking; real Git then populates that directory.
         from unittest.mock import patch
@@ -2988,6 +3130,20 @@ ctypes.CDLL(None).pthread_exit(None)
                 clean_scratch(receipt, self.receipt, True)
         self.assertEqual((scratch / "keep").read_text(), "retained")
 
+    def test_windows_empty_scratch_is_clean_and_scratch_with_files_is_retained(self):
+        # Prediction: on win32, where safe scratch removal is unsupported, an empty scratch records CLEAN with 0 bytes and
+        # one that holds a file stays with it. Before: both refused.
+        from unittest.mock import patch
+        scratch = Path(self.allocate()["scratch"])
+        receipt = read_json(self.receipt)
+        clean = {"status": "CLEAN", "logical_bytes_removed": 0}
+        with patch.object(sys, "platform", "win32"), patch.object(shutil.rmtree, "avoids_symlink_attacks", False):
+            self.assertEqual((clean_scratch(receipt, self.receipt, True), read_json(self.receipt)["scratch_cleanup"]), (clean, clean))
+            (scratch / "build").write_bytes(b"output")
+            with self.assertRaisesRegex(CompletionError, "safe scratch removal unsupported"):
+                clean_scratch(receipt, self.receipt, True)
+        self.assertEqual((scratch / "build").read_bytes(), b"output")
+
     def test_scratch_mount_table_parsing_preserves_ambiguous_literal_paths(self):
         from unittest.mock import patch
         target = "/task/scratch/name on inside\\040literal"
@@ -3118,7 +3274,7 @@ ctypes.CDLL(None).pthread_exit(None)
             error.storage_error = {'code': 'storage_unavailable'}
             raise error
         args = argparse.Namespace(receipt=str(self.receipt), acceptance=None, mode=None, local_only=False, writers_stopped=True)
-        with patch.dict(os.environ, self.env), patch.dict(complete.__globals__, managed_registration=lambda receipt, **kwargs: {}, cleanup=outage):
+        with patch.dict(os.environ, self.env), patch.dict(complete.__globals__, managed_registration=lambda receipt, **kwargs: {}, remove_delivered=outage):
             result = complete(args)
         self.assertEqual((result['status'], result['delivery_status']), ('CLEANUP_PENDING', 'COMPLETE'))
         self.assertIn('complete --receipt', result['resume'])
@@ -3133,13 +3289,17 @@ ctypes.CDLL(None).pthread_exit(None)
         receipt.update(mode='managed', allocation='managed_owned', delivery='COMPLETE', writers_released=True,
                        storage={'decision': {'registration': {'fixture': True}}, 'request': {'operation_id': 'saved'}, 'result': {'closure_result': {'established_by': 'never_admitted', 'operation_id': 'saved'}}})
         atomic_json(self.receipt, receipt)
+        calls = []
         def outage(*args, **kwargs):
+            calls.append(args)
             error = CompletionError('authority offline during reconciliation')
             error.storage_error = {'code': 'storage_unavailable'}
             raise error
-        with patch.dict(os.environ, self.env), patch.dict(reconcile.__globals__, managed_registration=lambda receipt, **kwargs: {}, cleanup=outage):
+        with patch.dict(os.environ, self.env), patch.dict(reconcile.__globals__, managed_registration=lambda receipt, **kwargs: {}, remove_delivered=outage):
             [result] = reconcile(Path(receipt['common_gitdir']), self.receipt.with_name('other.json'), self.work)
+        self.assertEqual(len(calls), 1)
         self.assertEqual((result['status'], result['delivery_status']), ('CLEANUP_PENDING', 'COMPLETE'))
+        self.assertEqual(result['workspace_cleanup']['reason'], 'authority offline during reconciliation')
         self.assertIn('complete --receipt', result['resume'])
         self.assertTrue(self.task.exists())
 
@@ -3164,6 +3324,42 @@ ctypes.CDLL(None).pthread_exit(None)
         d = read_json(self.data)
         self.assertEqual((d["pushs"], d.get("creates", 0)), (0, 0))
 
+    def test_unchanged_failed_final_receipt_write_raises_and_resumes_to_complete(self):
+        # Prediction: every removal finished and only the final status-COMPLETE record write fails, so complete raises
+        # that error and the printed resume ends COMPLETE. Before: retained as CLEANUP_PENDING on a COMPLETE receipt,
+        # which every resume reported again.
+        from unittest.mock import patch
+        self.allocate(); self.accept(unchanged=True)
+        self.cli("accept", "--receipt", self.receipt, "--acceptance", self.acceptance)
+        real, failed = atomic_json, []
+        def final_write_fails(path, value):
+            real(path, value)
+            if value.get("status") == "COMPLETE" and "workspace_cleanup" not in value and not failed:
+                failed.append(path)
+                raise OSError(5, "fixture final receipt write failure")
+        args = argparse.Namespace(receipt=str(self.receipt), acceptance=None, mode=None, local_only=False, writers_stopped=True)
+        with patch.dict(os.environ, self.env), patch.dict(complete.__globals__, atomic_json=final_write_fails):
+            with self.assertRaises(OSError):
+                complete(args)
+        self.assertFalse(self.task.exists())
+        result, _ = self.complete("--writers-stopped", acceptance=False)
+        self.assertEqual((result["status"], result["workspace_cleanup"]), ("COMPLETE", None))
+
+    def test_unchanged_removal_os_error_is_retained_with_delivery_complete(self):
+        # Prediction: an OSError raised while the workspace is removed (the records copy) is retained like a refusal:
+        # delivery COMPLETE, CLEANUP_PENDING naming the error, tree and task ref kept. Fails if only CompletionError is retained.
+        from unittest.mock import patch
+        self.allocate(); self.accept(unchanged=True)
+        args = argparse.Namespace(receipt=str(self.receipt), acceptance=str(self.acceptance), mode=None, local_only=False, writers_stopped=True)
+        with patch.dict(os.environ, self.env), \
+                patch.object(shutil, "copytree", side_effect=OSError(errno.ENOSPC, "fixture records copy failure")):
+            result = complete(args)
+        self.assertEqual((result["status"], result["delivery_status"]), ("CLEANUP_PENDING", "COMPLETE"))
+        self.assertIn("fixture records copy failure", result["workspace_cleanup"]["reason"])
+        self.assertEqual(read_json(self.receipt)["delivery"], "COMPLETE")
+        self.assertTrue(self.task.exists())
+        self.assertEqual(self.g("rev-parse", "task/fixture"), self.sha)
+
     def test_unchanged_writer_retention_reconciles_on_allocate(self):
         # Prediction: the next allocation retries on-base delivery once writer observation succeeds.
         from unittest.mock import Mock, patch
@@ -3232,7 +3428,8 @@ ctypes.CDLL(None).pthread_exit(None)
         self.assertEqual(self.complete(acceptance=False)[0]["status"], "COMPLETE")
 
     def test_merged_foreign_remote_head_records_merge_and_retains_ref(self):
-        # Prediction: merged PRs record merge evidence and reach cleanup's remote-ref retention guard.
+        # Prediction: merged PRs record merge evidence and reach cleanup's remote-ref retention guard, which keeps both
+        # task refs and leaves the merged delivery COMPLETE (CLEANUP_PENDING). Before: BLOCKED, delivery unrecorded.
         self.allocate(); self.accept()
         self.complete("--mode", "pr")
         self.run_cmd(["gh", "pr", "merge", "1", "--merge", "--match-head-commit", self.sha,
@@ -3240,11 +3437,113 @@ ctypes.CDLL(None).pthread_exit(None)
         self.g("commit", "--allow-empty", "-m", "foreign commit")
         foreign = self.g("rev-parse", "HEAD")
         self.g("push", "origin", "+" + foreign + ":refs/heads/task/fixture")
-        result, _ = self.complete("--writers-stopped", success=False)
-        self.assertEqual(result["status"], "BLOCKED")
-        self.assertIn("remote branch changed after merge; retain ref", result["reason"])
+        result, _ = self.complete("--writers-stopped")
+        self.assertEqual((result["status"], result["delivery_status"]), ("CLEANUP_PENDING", "COMPLETE"))
+        self.assertIn("remote branch changed after merge; retain ref", result["workspace_cleanup"]["reason"])
         self.assertEqual(read_json(self.receipt)["merge"], read_json(self.data)["prs"][0])
         self.assertEqual(self.g("ls-remote", "origin", "refs/heads/task/fixture").split()[0], foreign)
+        self.assertEqual(self.g("rev-parse", "task/fixture"), self.sha)
+
+    def test_merged_task_branch_checked_out_elsewhere_keeps_both_task_refs(self):
+        # Prediction: with the task branch also checked out in another worktree, the merged delivery is COMPLETE and
+        # reports CLEANUP_PENDING naming that worktree; neither task ref is deleted. Once that worktree leaves the branch,
+        # the printed resume deletes both. Before: BLOCKED, delivery unrecorded.
+        self.allocate(); self.accept()
+        self.complete("--mode", "pr", "--writers-stopped")
+        self.merge_pr()
+        other = self.root / "other"
+        self.g("worktree", "add", "--force", str(other), "task/fixture")
+        result, _ = self.complete()
+        self.assertEqual((result["status"], result["delivery_status"]), ("CLEANUP_PENDING", "COMPLETE"))
+        self.assertIn("task branch is still checked out at " + str(other), result["workspace_cleanup"]["reason"])
+        self.assertEqual(read_json(self.receipt)["delivery"], "COMPLETE")
+        self.assertEqual(self.g("rev-parse", "task/fixture"), self.sha)
+        self.assertEqual(self.g("ls-remote", "origin", "refs/heads/task/fixture").split()[0], self.sha)
+        self.g("switch", "--detach", work=other)
+        result, _ = self.cli(*shlex.split(result["resume"])[2:])
+        self.assertEqual((result["status"], result["workspace_cleanup"]), ("COMPLETE", None))
+        self.assertFalse(self.task.exists())
+        self.assertEqual(self.g("branch", "--list", "task/fixture"), "")
+        self.assertEqual(self.g("ls-remote", "origin", "refs/heads/task/fixture"), "")
+
+    def test_delivery_evidence_failure_blocks_with_delivery_unrecorded(self):
+        # Prediction: evidence is checked before any removal, so a PR view that is not merge evidence, or a changed
+        # custody manifest, stops completion BLOCKED with delivery left at PR and nothing removed. Unchanged on origin/main;
+        # fails if the evidence checks move inside the retention boundary.
+        self.allocate(); self.accept()
+        self.assertEqual(self.complete("--mode", "pr", "--writers-stopped")[0]["status"], "PR")
+        pr = read_json(self.data)["prs"][0]
+        manifest = self.receipt.parent / "manifest.json"
+        for case, reason in (("merge evidence", "actual matching merge evidence is required"),
+                             ("custody manifest", "custody manifest changed")):
+            with self.subTest(case=case):
+                if case == "merge evidence":
+                    self.configure(prs=[dict(pr, state="MERGED", mergedAt=None, mergeCommit=None)])
+                else:
+                    self.configure(prs=[pr])
+                    self.merge_pr()
+                    manifest.write_text("{}\n", encoding="utf-8")
+                result, r = self.complete(success=False)
+                self.assertEqual((r.returncode, result["status"]), (1, "BLOCKED"))
+                self.assertIn(reason, result["reason"])
+                receipt = read_json(self.receipt)
+                self.assertEqual((receipt["delivery"], receipt.get("status")), ("PR", None))
+                self.assertNotIn("workspace_cleanup", receipt)
+                self.assertTrue(self.task.exists())
+                self.assertEqual(self.g("rev-parse", "task/fixture"), self.sha)
+                self.assertEqual(self.g("ls-remote", "origin", "refs/heads/task/fixture").split()[0], self.sha)
+
+    def test_managed_delivery_evidence_failure_raises_with_delivery_unrecorded(self):
+        # Prediction: a managed receipt's changed custody manifest also raises before any removal, delivery unrecorded.
+        # Before: retained as CLEANUP_PENDING with delivery COMPLETE.
+        from unittest.mock import patch
+        self.allocate(); self.accept(unchanged=True)
+        self.cli('accept', '--receipt', self.receipt, '--acceptance', self.acceptance)
+        receipt = read_json(self.receipt)
+        receipt.update(mode='managed', allocation='managed_owned', storage={'decision': {'registration': {'fixture': True}}, 'request': {'operation_id': 'saved'}, 'result': {
+            'closure_result': {'established_by': 'never_admitted', 'operation_id': 'saved'}}})
+        atomic_json(self.receipt, receipt)
+        (self.receipt.parent / 'manifest.json').write_text('{}\n', encoding='utf-8')
+        args = argparse.Namespace(receipt=str(self.receipt), acceptance=None, mode=None, local_only=False, writers_stopped=True)
+        with patch.dict(os.environ, self.env), patch.dict(complete.__globals__, managed_registration=lambda receipt, **kwargs: {}):
+            with self.assertRaisesRegex(CompletionError, 'custody manifest changed'):
+                complete(args)
+        receipt = read_json(self.receipt)
+        self.assertEqual((receipt.get('delivery'), receipt.get('status')), (None, None))
+        self.assertNotIn('workspace_cleanup', receipt)
+        self.assertTrue(self.task.exists())
+
+    def test_remote_retargeted_during_delivery_checks_blocks_with_delivery_unrecorded(self):
+        # Prediction: origin is retargeted, after the first URL check, to another repository whose base holds the accepted
+        # commit, so both ancestry checks pass against it; the URL recheck after them stops completion BLOCKED with delivery
+        # unrecorded and nothing removed. Before: the tree was removed, the deletion-time URL refusal was retained and
+        # delivery was recorded COMPLETE for the receipt's repository, whose base lacks the commit.
+        from unittest.mock import patch
+        self.allocate(); self.accept()
+        fork = self.root / "fork.git"
+        self.run_cmd(["git", "clone", "--bare", "--quiet", str(self.bare), str(fork)])
+        self.g("push", str(fork), self.sha + ":refs/heads/main", work=self.task)
+        bare = ["git", "--git-dir", str(self.bare)]
+        base = self.run_cmd([*bare, "rev-parse", "refs/heads/main"]).stdout.strip()
+        real, retargeted = repo_policy, []
+        def retarget(receipt, **kwargs):
+            if not retargeted:
+                self.g("remote", "set-url", "origin", str(fork))
+                retargeted.append(str(fork))
+            return real(receipt, **kwargs)
+        args = argparse.Namespace(receipt=str(self.receipt), acceptance=str(self.acceptance), mode=None, local_only=False, writers_stopped=True)
+        with patch.dict(os.environ, self.env), patch.dict(complete.__globals__, repo_policy=retarget):
+            with self.assertRaisesRegex(CompletionError, "remote must unambiguously identify one GitHub repository"):
+                complete(args)
+        self.assertEqual(retargeted, [str(fork)])
+        receipt = read_json(self.receipt)
+        self.assertEqual((receipt.get("delivery"), receipt.get("status")), (None, None))
+        self.assertNotIn("workspace_cleanup", receipt)
+        self.assertTrue(self.task.exists())
+        self.assertEqual(self.g("rev-parse", "task/fixture"), self.sha)
+        self.assertEqual(self.g("rev-parse", receipt["recovery_ref"]), self.sha)
+        self.assertEqual(self.run_cmd([*bare, "rev-parse", "refs/heads/main"]).stdout.strip(), base)
+        self.assertEqual(self.run_cmd([*bare, "for-each-ref", "refs/heads/task/"]).stdout, "")
 
     def test_unchanged_foreign_remote_head_retains_worktree(self):
         # Prediction: a foreign remote task head refuses completion before worktree removal.
@@ -3416,6 +3715,9 @@ ctypes.CDLL(None).pthread_exit(None)
 
     @unittest.skipUnless(sys.platform == "darwin" or sys.platform.startswith("linux"), "writer observation requires POSIX")
     def test_nested_repository_or_worktree_retains_tree(self):
+        # Prediction: the first call merges; a nested worktree, then a nested repository, under an ignored path leaves the
+        # merged delivery COMPLETE (CLEANUP_PENDING) naming each, with the tree, the nested work and both task refs kept;
+        # once both are gone the printed resume removes everything. Before: BLOCKED, delivery unrecorded.
         self.allocate(); self.accept()
         _, r = self.cli("allocate", "--repo", self.work, "--task", "inner", "--branch", "task/inner", "--repository", "test/project",
                         "--base", "main", "--worktree", self.task / "ignored" / "inner", success=False)
@@ -3425,17 +3727,25 @@ ctypes.CDLL(None).pthread_exit(None)
         (nested / "product").write_text("unsaved nested work\n", encoding="utf-8")
         clone = self.task / "ignored" / "clone"
         self.run_cmd(["git", "init", "--initial-branch=main", str(clone)])
-        for remove in (lambda: self.g("worktree", "remove", "--force", str(nested)), lambda: shutil.rmtree(clone)):
-            _, r = self.complete("--mode", "auto", "--writers-stopped", success=False)
-            self.assertIn("nested repository or worktree", json.loads(r.stdout)["reason"])
+        for name, remove in (("ignored/nested/", lambda: self.g("worktree", "remove", "--force", str(nested))),
+                             ("ignored/clone/", lambda: shutil.rmtree(clone))):
+            result, _ = self.complete("--mode", "auto", "--writers-stopped")
+            self.assertEqual((result["status"], result["delivery_status"]), ("CLEANUP_PENDING", "COMPLETE"))
+            self.assertIn("nested repository or worktree inside the task tree: ", result["workspace_cleanup"]["reason"])
+            self.assertIn(name, result["workspace_cleanup"]["reason"])
+            self.assertEqual(read_json(self.receipt)["delivery"], "COMPLETE")
             self.assertTrue(self.task.exists())
-            self.assertNotEqual(self.g("branch", "--list", "task/fixture"), "")
+            self.assertEqual(self.g("rev-parse", "task/fixture"), self.sha)
+            self.assertEqual(self.g("ls-remote", "origin", "refs/heads/task/fixture").split()[0], self.sha)
             if nested.exists():
                 self.assertEqual((nested / "product").read_text(encoding="utf-8"), "unsaved nested work\n")
             remove()
-        result, _ = self.complete("--mode", "auto", "--writers-stopped")
-        self.assertEqual(result["status"], "COMPLETE")
+        result, _ = self.cli(*shlex.split(result["resume"])[2:])
+        self.assertEqual((result["status"], result["workspace_cleanup"]), ("COMPLETE", None))
         self.assertFalse(self.task.exists())
+        self.assertEqual(self.g("branch", "--list", "task/fixture"), "")
+        self.assertEqual(self.g("ls-remote", "origin", "refs/heads/task/fixture"), "")
+        self.assertEqual(read_json(self.data)["merges"], 1)
 
     @unittest.skipUnless(sys.platform == "darwin" or sys.platform.startswith("linux"), "writer observation requires POSIX")
     def test_default_mode_merges_when_possible_and_cleans(self):
@@ -3446,22 +3756,322 @@ ctypes.CDLL(None).pthread_exit(None)
         self.assertFalse(self.task.exists())
         self.assertEqual(self.g("branch", "--list", "task/fixture"), "")
 
-    def test_unobservable_writers_settle_a_merged_delivery_and_retain_the_workspace(self):
-        from unittest.mock import patch
+    def merged(self, *, released=True):
         self.allocate(); self.accept()
-        self.complete("--mode", "pr", "--writers-stopped")
+        self.complete("--mode", "pr", *(["--writers-stopped"] if released else []))
         self.merge_pr()
-        args = argparse.Namespace(receipt=str(self.receipt), acceptance=None, mode=None, local_only=False, writers_stopped=False)
-        with patch.object(sys, "platform", "win32"), patch.dict(os.environ, self.env):
-            result = complete(args)
+        return self.task.with_name(self.task.name + ".devlyn-removing")
+
+    def complete_on_windows(self, rename=None, *, writers_stopped=False, **names):
+        # As native Windows reports itself; `rename` replaces os.rename for the task tree only.
+        from unittest.mock import patch
+        real = os.rename
+        def tree_rename(source, target, *args, **kwargs):
+            if rename and Path(source) == self.task:
+                return rename(source, target)
+            return real(source, target, *args, **kwargs)
+        args = argparse.Namespace(receipt=str(self.receipt), acceptance=None, mode=None, local_only=False,
+                                  writers_stopped=writers_stopped)
+        with patch.object(sys, "platform", "win32"), patch.dict(os.environ, self.env), \
+                patch.object(os, "rename", tree_rename), patch.dict(complete.__globals__, names):
+            return complete(args)
+
+    def kill_after_the_move(self):
+        move = os.rename
+        def killed(source, target):
+            move(source, target)
+            raise RuntimeError("fixture kill after the move")
+        with self.assertRaisesRegex(RuntimeError, "fixture kill"):
+            self.complete_on_windows(killed)
+
+    def assert_windows_removal_completed(self, result, moved):
+        self.assertEqual((result["status"], result["delivery_status"], result["workspace_cleanup"]), ("COMPLETE", "COMPLETE", None))
+        self.assertFalse(os.path.lexists(self.task) or os.path.lexists(moved))
+        self.assertFalse({str(self.task), str(moved)} & set(registrations(read_json(self.receipt))))
+        self.assertEqual(self.g("branch", "--list", "task/fixture"), "")
+        self.assertEqual(self.g("ls-remote", "origin", "refs/heads/task/fixture"), "")
+
+    def assert_windows_removal_retained(self, result, reason):
+        # A refused removal of a merged delivery: delivery COMPLETE, the refusal and its resume recorded, both task refs kept.
         self.assertEqual((result["status"], result["delivery_status"]), ("CLEANUP_PENDING", "COMPLETE"))
-        self.assertIn("writer observation unsupported", result["workspace_cleanup"]["reason"])
-        receipt = json.loads(self.receipt.read_text(encoding="utf-8"))
-        self.assertEqual((receipt["delivery"], receipt.get("status")), ("COMPLETE", None))
-        self.assertTrue(self.task.exists())
-        self.assertNotEqual(self.g("branch", "--list", "task/fixture"), "")
+        self.assertIn(reason, result["workspace_cleanup"]["reason"])
+        self.assertIn("complete --receipt", result["resume"])
+        self.assertEqual(read_json(self.receipt)["delivery"], "COMPLETE")
+        self.assertEqual(self.g("rev-parse", "task/fixture"), self.sha)
         self.assertEqual(self.g("ls-remote", "origin", "refs/heads/task/fixture").split()[0], self.sha)
 
+    def test_windows_removal_waits_while_the_move_is_refused_and_completes_once_it_succeeds(self):
+        # Prediction: on win32 a merged delivery's tree is moved aside, then removed. A refused move keeps delivery
+        # COMPLETE and the tree, its registration and both task branches, with the in-use reason and the Windows error;
+        # the resume then moves and removes it. A Git without `worktree repair` or GIT_CONFIG_COUNT (2.30) keeps the tree
+        # without a move, naming the version needed. stopped_writers itself stays unsupported there.
+        # Before: every win32 removal was retained as "writer observation unsupported", without a move.
+        from unittest.mock import patch
+        moved = self.merged()
+        attempts = []
+        run = command
+        def older(argv, **kwargs):
+            return "git version 2.30.0" if argv == ["git", "--version"] else run(argv, **kwargs)
+        result = self.complete_on_windows(lambda source, target: attempts.append(target), command=older)
+        self.assertEqual((result["status"], attempts), ("CLEANUP_PENDING", []))
+        self.assertEqual(result["workspace_cleanup"]["reason"],
+                         "removing a task checkout on Windows needs Git 2.31 or later; update Git, then resume")
+        def held(source, target):
+            attempts.append(target)
+            raise PermissionError(13, "fixture: the process cannot access the file because it is being used by another process")
+        result = self.complete_on_windows(held)
+        self.assertEqual((result["status"], result["delivery_status"]), ("CLEANUP_PENDING", "COMPLETE"))
+        self.assertIn(f"a program still uses {self.task}", result["workspace_cleanup"]["reason"])
+        self.assertIn("being used by another process", result["workspace_cleanup"]["reason"])
+        self.assertEqual(attempts, [moved])
+        self.assertTrue(self.task.is_dir() and not os.path.lexists(moved))
+        self.assertIn(str(self.task), registrations(read_json(self.receipt)))
+        self.assertEqual(self.g("rev-parse", "task/fixture"), self.sha)
+        self.assertEqual(self.g("ls-remote", "origin", "refs/heads/task/fixture").split()[0], self.sha)
+        self.assert_windows_removal_completed(self.complete_on_windows(), moved)
+        with patch.object(sys, "platform", "win32"), self.assertRaisesRegex(WritersUnobservable, "unsupported on this platform"):
+            stopped_writers(self.root)
+
+    def test_windows_removal_refuses_populated_submodules_before_any_move(self):
+        # Prediction: Git's unforced removal would refuse a populated submodule after the move, so it is refused while the
+        # tree is in place: CLEANUP_PENDING with delivery COMPLETE naming the retained module repositories, never moved,
+        # nothing deleted. Before (this branch on the old base): BLOCKED with delivery unrecorded.
+        module = self.root / "module"
+        self.run_cmd(["git", "init", "--initial-branch=main", str(module)])
+        self.g("commit", "--allow-empty", "-m", "module", work=module)
+        self.g("submodule", "add", str(module), "module")
+        self.g("commit", "-m", "add module")
+        self.g("push", "origin", "main")
+        moved = self.merged()
+        self.g("submodule", "update", "--init", work=self.task)
+        attempts = []
+        self.assert_windows_removal_retained(self.complete_on_windows(lambda source, target: attempts.append(target)),
+                                             "retained populated submodules repositories block removal")
+        self.assertEqual(attempts, [])
+        self.assertTrue((self.task / "module/.git").exists() and not os.path.lexists(moved))
+
+    def test_windows_removal_refuses_a_destination_that_overlaps_a_registration_before_any_move(self):
+        # Prediction: a registration at the moved name, its folder absent, is refused as allocation refuses an overlap:
+        # CLEANUP_PENDING with delivery COMPLETE naming that path, never moved; once it is pruned the resume removes the
+        # tree. Before (this branch on the old base): BLOCKED with delivery unrecorded.
+        moved = self.merged()
+        self.g("worktree", "add", "-b", "other", str(moved), "main")
+        shutil.rmtree(moved)
+        attempts = []
+        self.assert_windows_removal_retained(self.complete_on_windows(lambda source, target: attempts.append(target)),
+                                             f"{moved} exists or overlaps a registered worktree")
+        self.assertEqual(attempts, [])
+        self.assertTrue(self.task.is_dir() and not os.path.lexists(moved))
+        self.g("worktree", "prune")
+        self.assert_windows_removal_completed(self.complete_on_windows(), moved)
+
+    def test_windows_removal_finishes_after_a_kill_following_the_move(self):
+        # Prediction: a kill after the move leaves the tree moved and still registered at its original path; the next
+        # completion repairs, checks and removes it. Before: no move happened, so no kill.
+        moved = self.merged()
+        self.kill_after_the_move()
+        self.assertTrue(moved.is_dir() and not os.path.lexists(self.task))
+        self.assertIn(str(self.task), registrations(read_json(self.receipt)))
+        self.assert_windows_removal_completed(self.complete_on_windows(), moved)
+
+    def test_windows_removal_finishes_after_a_kill_following_the_repair(self):
+        # Prediction: a kill after the repair leaves the moved tree registered at its new path only; the next completion
+        # removes it. Before: no repair ran, so no kill.
+        moved = self.merged()
+        run = gref
+        def killed(receipt, *args):
+            output = run(receipt, *args)
+            if args[:2] == ("worktree", "repair"):
+                raise RuntimeError("fixture kill after the repair")
+            return output
+        with self.assertRaisesRegex(RuntimeError, "fixture kill"):
+            self.complete_on_windows(gref=killed)
+        rows = registrations(read_json(self.receipt))
+        self.assertTrue(moved.is_dir() and str(moved) in rows and str(self.task) not in rows)
+        self.assert_windows_removal_completed(self.complete_on_windows(), moved)
+
+    def test_windows_removal_refuses_a_foreign_folder_of_the_moved_name(self):
+        # Prediction: a folder of the moved name that is not this checkout is refused with both paths named and is
+        # never touched, whether the checkout is still in place or was moved elsewhere by a person: each time
+        # CLEANUP_PENDING with delivery COMPLETE. Once the checkout is back and that folder gone, the resume removes it.
+        # Before (this branch on the old base): BLOCKED with delivery unrecorded.
+        moved = self.merged()
+        moved.mkdir()
+        (moved / "foreign").write_text("keep", encoding="utf-8")
+        attempts = []
+        self.assert_windows_removal_retained(self.complete_on_windows(lambda source, target: attempts.append(target)),
+                                             f"{moved} exists or overlaps a registered worktree; leave it, keep {self.task}")
+        self.assertEqual(attempts, [])
+        self.assertTrue(self.task.is_dir())
+        elsewhere = self.task.with_name("elsewhere")
+        self.task.rename(elsewhere)
+        (moved / ".git").write_text(f"gitdir: {self.root / 'foreign.git'}\n", encoding="utf-8")
+        self.assert_windows_removal_retained(self.complete_on_windows(),
+                                             f"{moved} cannot be verified as the task checkout moved from {self.task}")
+        self.assertEqual(sorted(path.name for path in moved.iterdir()), [".git", "foreign"])
+        self.assertTrue((elsewhere / "product").is_file())
+        shutil.rmtree(moved)
+        elsewhere.rename(self.task)
+        self.assert_windows_removal_completed(self.complete_on_windows(), moved)
+
+    def test_windows_removal_after_a_kill_never_deletes_a_record_saved_unseen(self):
+        # Prediction: a record saved into the moved tree after a kill is copied beside the receipt before removal; a
+        # symlink there refuses the removal with the tree kept (CLEANUP_PENDING, delivery COMPLETE). Before: no move
+        # happened, so no kill.
+        moved = self.merged()
+        self.kill_after_the_move()
+        link = moved / ".devlyn/link"
+        link.symlink_to("checks.txt")
+        self.assert_windows_removal_retained(self.complete_on_windows(), "symlink")
+        self.assertTrue((moved / ".devlyn/checks.txt").is_file() and link.is_symlink())
+        link.unlink()
+        (moved / ".devlyn/late.txt").write_text("saved after the kill\n", encoding="utf-8")
+        self.assert_windows_removal_completed(self.complete_on_windows(), moved)
+        self.assertEqual([path.read_text(encoding="utf-8") for path in self.receipt.parent.glob("records*/.devlyn/late.txt")],
+                         ["saved after the kill\n"])
+
+    def test_windows_recovery_needs_the_owners_recorded_release(self):
+        # Prediction: a checkout published without --writers-stopped and renamed by hand to the moved name after the merge
+        # is refused by a completion without that flag, naming it, with its ignored output kept (CLEANUP_PENDING, delivery
+        # COMPLETE); with the flag it is removed. Before: the recovery removed it and its ignored output without the release.
+        moved = self.merged(released=False)
+        (self.task / "ignored").mkdir()
+        (self.task / "ignored/output").write_text("kept", encoding="utf-8")
+        self.task.rename(moved)
+        self.assert_windows_removal_retained(self.complete_on_windows(), "resume with --writers-stopped")
+        self.assertEqual(((moved / "ignored/output").read_text(encoding="utf-8"), (moved / "product").read_text(encoding="utf-8")),
+                         ("kept", "accepted\n"))
+        self.assert_windows_removal_completed(self.complete_on_windows(writers_stopped=True), moved)
+
+    def test_windows_removal_gives_every_git_call_on_the_moved_tree_long_paths(self):
+        # Prediction: after the move, every Git call on the moved tree, in the removal (repair, remove) and in its recovery
+        # (repair, status, ls-files, remove), has core.longpaths=true in its environment after the entries already there;
+        # calls on the tree before the move and after the removal see those entries only. The removal's own `worktree
+        # remove` is recorded, then refused as Git would refuse it, so the recovery runs next. Before: only `worktree
+        # remove` had it, as an argument; the recovery's status and ls-files ran without it.
+        moved = self.merged()
+        self.env.update(GIT_CONFIG_COUNT="1", GIT_CONFIG_KEY_0="fixture.kept", GIT_CONFIG_VALUE_0="yes")
+        calls, refused = [], []
+        run = command
+        def recorded(argv, **kwargs):
+            env = kwargs.get("env") or os.environ
+            calls.append((argv, {name: value for name, value in env.items() if re.fullmatch(r"GIT_CONFIG_(COUNT|KEY_\d+|VALUE_\d+)", name)}))
+            if "remove" in argv and str(moved) in argv and not refused:
+                refused.append(len(calls))
+                raise CompletionError("fixture: Git refused the first removal")
+            return run(argv, **kwargs)
+        result = self.complete_on_windows(command=recorded)
+        self.assertEqual((result["status"], refused), ("CLEANUP_PENDING", [len(calls)]))
+        self.assertIn("fixture: Git refused the first removal", result["workspace_cleanup"]["reason"])
+        self.assertEqual([word for argv, seen in calls if str(moved) in argv for word in argv if word in {"repair", "remove"}],
+                         ["repair", "remove"])
+        self.assert_windows_removal_completed(self.complete_on_windows(command=recorded), moved)
+        kept = {"GIT_CONFIG_COUNT": "1", "GIT_CONFIG_KEY_0": "fixture.kept", "GIT_CONFIG_VALUE_0": "yes"}
+        longpaths = dict(kept, GIT_CONFIG_COUNT="2", GIT_CONFIG_KEY_1="core.longpaths", GIT_CONFIG_VALUE_1="true")
+        on_moved = [(argv, seen) for argv, seen in calls if str(moved) in argv]
+        self.assertLessEqual({"repair", "status", "ls-files", "remove"}, {word for argv, seen in on_moved for word in argv})
+        self.assertEqual([argv for argv, seen in on_moved if seen != longpaths], [])
+        self.assertEqual([argv for argv, seen in calls if (str(self.task) in argv or "push" in argv or "update-ref" in argv)
+                          and seen != kept], [])
+
+    def test_windows_recovery_of_a_moved_checkout_whose_registration_is_gone_is_left_to_a_person(self):
+        # Prediction: after a kill following the move and `git worktree prune`, every completion retains the tree with the
+        # sentence that the registration is gone (CLEANUP_PENDING, delivery COMPLETE) and deletes nothing; once the folder
+        # is removed by hand the completion finishes.
+        # Before: refused as "cannot be verified as the task checkout", which is not true of it.
+        moved = self.merged()
+        self.kill_after_the_move()
+        self.g("worktree", "prune")
+        gone = (f"{moved} is the task checkout moved from {self.task}, but its Git registration is gone; "
+                "inspect it and remove it by hand, then resume")
+        files = sorted(moved.rglob("*"))
+        for attempt in range(2):
+            self.assert_windows_removal_retained(self.complete_on_windows(), gone)
+            self.assertEqual(sorted(moved.rglob("*")), files)
+        shutil.rmtree(moved)
+        self.assert_windows_removal_completed(self.complete_on_windows(), moved)
+
+    def test_windows_recovery_never_calls_a_folder_naming_the_pruned_registration_the_task_checkout(self):
+        # Prediction: the checkout moved elsewhere by a person and `git worktree prune`, then a folder at the moved name
+        # whose .git names the recorded Gitdir: refused as not verifiable as the task checkout, both folders untouched
+        # (CLEANUP_PENDING, delivery COMPLETE).
+        # Before: called the task checkout whose registration is gone, and the reader was told to remove it by hand.
+        moved = self.merged()
+        gitdir = read_json(self.receipt)["worktree_gitdir"]
+        elsewhere = self.task.with_name("elsewhere")
+        self.task.rename(elsewhere)
+        self.g("worktree", "prune")
+        moved.mkdir()
+        (moved / "foreign").write_text("keep", encoding="utf-8")
+        (moved / ".git").write_text(f"gitdir: {gitdir}\n", encoding="utf-8")
+        files = sorted(elsewhere.rglob("*"))
+        foreign = f"{moved} cannot be verified as the task checkout moved from {self.task}; leave both, inspect them, then resume"
+        self.assert_windows_removal_retained(self.complete_on_windows(), foreign)
+        self.assertEqual(sorted(path.name for path in moved.iterdir()), [".git", "foreign"])
+        self.assertEqual((sorted(elsewhere.rglob("*")), (elsewhere / "product").read_text(encoding="utf-8")), (files, "accepted\n"))
+
+    def test_windows_recovery_never_removes_a_moved_checkout_its_anchor_names_by_another_path(self):
+        # Prediction: an anchor naming the moved checkout through a symlink is the same folder: the recovery refuses with
+        # the anchor reason and keeps it. Before: the paths were compared as strings and the checkout was removed.
+        from unittest.mock import patch
+        moved = self.merged()
+        self.kill_after_the_move()
+        link = self.root / "anchor"
+        link.symlink_to(moved, target_is_directory=True)
+        receipt = read_json(self.receipt)
+        with patch.object(sys, "platform", "win32"), patch.dict(os.environ, self.env), \
+                self.assertRaisesRegex(CompletionError, re.escape("anchor checkout: " + str(link))):
+            cleanup(receipt, self.receipt, receipt["merge"], anchor=link)
+        self.assertEqual((moved / "product").read_text(encoding="utf-8"), "accepted\n")
+
+    def test_windows_recovery_refuses_a_nested_repository_under_an_ignored_path_of_the_moved_tree(self):
+        # Prediction: a repository with uncommitted work that appears under an ignored path of the moved tree after a kill
+        # refuses the recovery ("nested repository"; CLEANUP_PENDING, delivery COMPLETE) and its file stays; once it is
+        # gone the resume removes the tree. Without the moved tree's removal checks, Git's removal deletes it.
+        moved = self.merged()
+        self.kill_after_the_move()
+        nested = moved / "ignored/nested"
+        self.run_cmd(["git", "init", "--initial-branch=main", str(nested)])
+        (nested / "work.txt").write_text("uncommitted\n", encoding="utf-8")
+        self.assert_windows_removal_retained(self.complete_on_windows(),
+                                             "nested repository or worktree inside the task tree: ignored/nested/")
+        self.assertEqual((nested / "work.txt").read_text(encoding="utf-8"), "uncommitted\n")
+        shutil.rmtree(nested)
+        self.assert_windows_removal_completed(self.complete_on_windows(), moved)
+
+    def test_windows_removal_refuses_a_gitlink_populated_by_a_plain_clone_before_any_move(self):
+        # Prediction: a gitlink whose path holds a repository cloned there, with nothing under the tree's Gitdir, is
+        # refused by the populated-gitlink check before any move, the tree in place (CLEANUP_PENDING, delivery COMPLETE).
+        # Without that check the tree is moved and Git's unforced removal refuses it at the moved name.
+        module = self.root / "module"
+        self.run_cmd(["git", "init", "--initial-branch=main", str(module)])
+        self.g("commit", "--allow-empty", "-m", "module", work=module)
+        self.g("submodule", "add", str(module), "module")
+        self.g("commit", "-m", "add module")
+        self.g("push", "origin", "main")
+        moved = self.merged()
+        self.run_cmd(["git", "clone", "--quiet", str(module), str(self.task / "module")])
+        attempts = []
+        self.assert_windows_removal_retained(self.complete_on_windows(lambda source, target: attempts.append(target)),
+                                             "working tree contains populated submodules")
+        self.assertEqual(attempts, [])
+        self.assertFalse(path_present(Path(read_json(self.receipt)["worktree_gitdir"]) / "modules"))
+        self.assertTrue((self.task / "module/.git").is_dir() and not os.path.lexists(moved))
+
+    def test_windows_removal_keeps_the_tree_when_its_move_fails_for_another_reason(self):
+        # Prediction: a move that fails with an OSError other than PermissionError keeps delivery COMPLETE and the tree,
+        # with "cannot move ... aside" and the error; the resume then removes it. Without that branch the raw error blocks.
+        moved = self.merged()
+        def failed(source, target):
+            raise OSError(errno.EXDEV, "fixture: not the same device")
+        result = self.complete_on_windows(failed)
+        self.assertEqual((result["status"], result["delivery_status"]), ("CLEANUP_PENDING", "COMPLETE"))
+        self.assertIn(f"cannot move {self.task} aside to remove it", result["workspace_cleanup"]["reason"])
+        self.assertIn("not the same device", result["workspace_cleanup"]["reason"])
+        self.assertTrue(self.task.is_dir() and not os.path.lexists(moved))
+        self.assertIn(str(self.task), registrations(read_json(self.receipt)))
+        self.assert_windows_removal_completed(self.complete_on_windows(), moved)
+
     def test_standalone_cleanup_checks_writers_before_reading_records(self):
         from unittest.mock import patch
         self.allocate(); self.accept()
@@ -3577,6 +4187,44 @@ ctypes.CDLL(None).pthread_exit(None)
         self.assertEqual(self.g("rev-parse", "task/fixture"), self.sha)
         self.assertEqual(self.g("ls-remote", "origin", "refs/heads/task/fixture").split()[0], self.sha)
 
+    def test_reconcile_checks_delivery_evidence_before_cleanup(self):
+        # Prediction: a merged standalone receipt whose recovery ref moved gives a RETAINED reconcile row naming it, with
+        # the tree and both task refs kept. Fails if reconcile's standalone cleanup skips verify_delivery.
+        self.allocate(); self.accept()
+        self.complete("--mode", "pr", "--writers-stopped")
+        self.merge_pr()
+        receipt, task = self.receipt, self.task
+        saved = read_json(receipt)
+        self.g("update-ref", saved["recovery_ref"], saved["baseline"])
+        result = self.allocate("next")
+        self.assertEqual([(row["receipt"], row["status"]) for row in result["reconciled"]], [(str(receipt), "RETAINED")])
+        self.assertIn("recovery reachability changed", result["reconciled"][0]["reason"])
+        self.assertTrue(task.exists())
+        self.assertEqual(self.g("rev-parse", "task/fixture"), self.sha)
+        self.assertEqual(self.g("ls-remote", "origin", "refs/heads/task/fixture").split()[0], self.sha)
+
+    def test_reconcile_replaces_a_retained_reason_with_its_latest_refusal(self):
+        # Prediction: complete retains a merged delivery for a nested repository; once that is gone and the remote task
+        # branch has moved, the next allocation's reconcile removes the tree, keeps the task ref and replaces the receipt's
+        # reason with the remote-branch refusal. Before: the receipt still named the nested repository.
+        self.allocate(); self.accept()
+        clone = self.task / "ignored" / "clone"
+        self.run_cmd(["git", "init", "--initial-branch=main", str(clone)])
+        result, _ = self.complete("--mode", "auto", "--writers-stopped")
+        self.assertEqual((result["status"], result["delivery_status"]), ("CLEANUP_PENDING", "COMPLETE"))
+        self.assertIn("ignored/clone/", result["workspace_cleanup"]["reason"])
+        shutil.rmtree(clone)
+        self.g("commit", "--allow-empty", "-m", "foreign commit")
+        self.g("push", "origin", "+" + self.g("rev-parse", "HEAD") + ":refs/heads/task/fixture")
+        receipt, task = self.receipt, self.task
+        [row] = self.allocate("next")["reconciled"]
+        self.assertEqual((row["receipt"], row["status"]), (str(receipt), "RETAINED"))
+        self.assertIn("remote branch changed after merge; retain ref", row["reason"])
+        self.assertFalse(task.exists())
+        saved = read_json(receipt)["workspace_cleanup"]
+        self.assertEqual((saved["status"], saved["reason"]), ("RETAINED", row["reason"]))
+        self.assertEqual(self.g("rev-parse", "task/fixture"), self.sha)
+
     def test_reconcile_skips_open_and_unaccepted_and_retains_in_use_tree(self):
         self.allocate(); self.accept()
         self.complete("--mode", "pr", "--writers-stopped")
@@ -3650,6 +4298,23 @@ ctypes.CDLL(None).pthread_exit(None)
         self.assertNotEqual(self.g("branch", "--list", "task/fixture"), "")
         self.assertEqual(self.g("ls-remote", "origin", "refs/heads/task/fixture").split()[0], self.sha)
 
+    def test_reconcile_never_removes_a_moved_checkout_an_allocation_is_anchored_in(self):
+        # Prediction: on win32, after a kill following the move, an allocation anchored in the moved checkout retains it
+        # with the anchor reason. Before: no move happened, so no kill.
+        from unittest.mock import patch
+        moved = self.merged()
+        self.kill_after_the_move()
+        before = self.anchor_state(moved)
+        args = self.allocation_args("next", self.root / "next")
+        args.repo = str(moved)
+        with patch.object(sys, "platform", "win32"), patch.dict(os.environ, self.env):
+            result = allocate(args)
+        self.assertEqual(result["status"], "ALLOCATED")
+        self.assertEqual([row["status"] for row in result["reconciled"]], ["RETAINED"])
+        self.assertIn("anchor checkout: " + str(moved), result["reconciled"][0]["reason"])
+        self.assertEqual(self.anchor_state(moved), before)
+        self.assertEqual(self.g("ls-remote", "origin", "refs/heads/task/fixture").split()[0], self.sha)
+
     def test_reconcile_reports_scratch_cleanup_pending(self):
         scratch = Path(self.allocate()["scratch"])
         self.accept()
@@ -3741,16 +4406,17 @@ ctypes.CDLL(None).pthread_exit(None)
         other.write_bytes(b"owner data")
         link = self.task / ".devlyn/link"
         link.symlink_to(other)
-        result, _ = self.complete(success=False)
-        self.assertIn("path escapes custody", result["reason"])
+        result, _ = self.complete()
+        self.assertEqual((result["status"], result["delivery_status"]), ("CLEANUP_PENDING", "COMPLETE"))
+        self.assertIn("path escapes custody", result["workspace_cleanup"]["reason"])
         self.assertTrue(self.task.exists())
         self.assertTrue(link.is_symlink())
         self.assertEqual(other.read_bytes(), b"owner data")
         link.unlink()
         if hasattr(os, "mkfifo"):
             os.mkfifo(link)
-            result, _ = self.complete(success=False)
-            self.assertIn("regular file", result["reason"])
+            result, _ = self.complete()
+            self.assertIn("regular file", result["workspace_cleanup"]["reason"])
             self.assertTrue(self.task.exists())
             link.unlink()
         saved = self.receipt.parent / "records/.devlyn"
@@ -3817,8 +4483,9 @@ ctypes.CDLL(None).pthread_exit(None)
         extra = generation / ".devlyn/unexpected"
         extra.write_bytes(b"keep this copy\n")
         mismatch = records_manifest(generation)
-        result, _ = self.complete(success=False)
-        self.assertIn(generation.name, result["reason"])
+        result, _ = self.complete()
+        self.assertEqual((result["status"], result["delivery_status"]), ("CLEANUP_PENDING", "COMPLETE"))
+        self.assertIn(generation.name, result["workspace_cleanup"]["reason"])
         self.assertTrue(self.task.exists())
         self.assertEqual(records_manifest(generation), mismatch)
         self.assertEqual(records_manifest(saved), original)
@@ -3845,8 +4512,9 @@ ctypes.CDLL(None).pthread_exit(None)
                 (work / ".devlyn/storage-cleanup.json").write_bytes(b"{}\n")
         args = argparse.Namespace(receipt=str(self.receipt), acceptance=None, mode=None, local_only=False, writers_stopped=False)
         with patch.dict(os.environ, self.env), patch.dict(cleanup.__globals__, {"removable": changed}):
-            with self.assertRaisesRegex(CompletionError, "changed after it was copied; stop its writer and resume"):
-                complete(args)
+            result = complete(args)
+        self.assertEqual((result["status"], result["delivery_status"]), ("CLEANUP_PENDING", "COMPLETE"))
+        self.assertIn("changed after it was copied; stop its writer and resume", result["workspace_cleanup"]["reason"])
         self.assertTrue(self.task.exists())
         self.assertEqual(records_manifest(saved), original)
         final = records_manifest(self.task)
@@ -3868,8 +4536,9 @@ ctypes.CDLL(None).pthread_exit(None)
             return result
         args = argparse.Namespace(receipt=str(self.receipt), acceptance=None, mode=None, local_only=False, writers_stopped=False)
         with patch.dict(os.environ, self.env), patch.object(shutil, "copytree", changed):
-            with self.assertRaisesRegex(CompletionError, "changed while it was copied; stop its writer and resume"):
-                complete(args)
+            result = complete(args)
+        self.assertEqual((result["status"], result["delivery_status"]), ("CLEANUP_PENDING", "COMPLETE"))
+        self.assertIn("changed while it was copied; stop its writer and resume", result["workspace_cleanup"]["reason"])
         self.assertTrue(self.task.exists())
         self.assertFalse((self.receipt.parent / "records").exists())
         self.assertEqual(list(self.receipt.parent.glob(".records-*")), [])
@@ -3877,8 +4546,8 @@ ctypes.CDLL(None).pthread_exit(None)
     def test_linked_custody_and_interrupted_removal(self):
         self.allocate(); self.accept()
         self.configure(interrupt_remove=True)
-        result, r = self.complete("--writers-stopped", "--mode", "auto", success=False)
-        self.assertNotEqual(r.returncode, 0)
+        result, _ = self.complete("--writers-stopped", "--mode", "auto")
+        self.assertEqual((result["status"], result["delivery_status"]), ("CLEANUP_PENDING", "COMPLETE"))
         self.assertFalse(self.task.exists())
         saved = json.loads(self.receipt.read_text(encoding="utf-8"))
         self.assertNotIn("cleanup_started", saved)
@@ -3923,15 +4592,24 @@ ctypes.CDLL(None).pthread_exit(None)
         self.assertEqual((d["pushs"], d["creates"], d["merges"]), (1, 1, 1))
 
     def test_retains_dirty_locked_and_active_tree(self):
+        # Prediction: the first call merges; each refused removal keeps the tree and task ref and reports CLEANUP_PENDING
+        # with delivery COMPLETE, while a caller inside the tree is refused (BLOCKED) before anything. Before: all BLOCKED.
         self.allocate(); self.accept()
+        reasons = {"no-yield": "resume with --writers-stopped", "dirty": "dirty/untracked workspace",
+                   "untracked": "dirty/untracked workspace", "locked": "detached or locked"}
         for case in ("no-yield", "dirty", "untracked", "locked", "cwd"):
             path = self.task / ("product" if case == "dirty" else "unknown")
             if case in {"dirty", "untracked"}:
                 path.parent.mkdir(exist_ok=True); path.write_text("do not delete", encoding="utf-8")
             if case == "locked": self.g("worktree", "lock", str(self.task))
             with self.subTest(case=case):
-                _, r = self.complete("--mode", "auto", *([] if case == "no-yield" else ["--writers-stopped"]), cwd=self.task if case == "cwd" else None, success=False)
-                self.assertNotEqual(r.returncode, 0)
+                result, r = self.complete("--mode", "auto", *([] if case == "no-yield" else ["--writers-stopped"]), cwd=self.task if case == "cwd" else None, success=False)
+                if case == "cwd":
+                    self.assertEqual((r.returncode, result["status"]), (1, "BLOCKED"))
+                    self.assertIn("caller cwd is inside", result["reason"])
+                else:
+                    self.assertEqual((r.returncode, result["status"], result["delivery_status"]), (0, "CLEANUP_PENDING", "COMPLETE"))
+                    self.assertIn(reasons[case], result["workspace_cleanup"]["reason"])
                 self.assertTrue(self.task.exists())
                 self.assertNotEqual(self.g("branch", "--list", "task/fixture"), "")
             if case == "untracked": path.unlink()
@@ -4004,10 +4682,11 @@ ctypes.CDLL(None).pthread_exit(None)
             self.assertTrue(self.task.exists())
         finally:
             child.terminate(); child.wait(timeout=5)
-        # A foreign branch in the same registered tree never inherits ownership.
+        # A foreign branch in the same registered tree never inherits ownership; the merged delivery stays COMPLETE.
         self.g("switch", "-c", "foreign", work=self.task)
-        _, r = self.complete("--writers-stopped", success=False)
-        self.assertNotEqual(r.returncode, 0)
+        result, _ = self.complete("--writers-stopped")
+        self.assertEqual((result["status"], result["delivery_status"]), ("CLEANUP_PENDING", "COMPLETE"))
+        self.assertIn("foreign worktree branch", result["workspace_cleanup"]["reason"])
         self.assertTrue(self.task.exists())
         self.assertNotEqual(self.g("branch", "--list", "task/fixture"), "")
 
@@ -4015,8 +4694,8 @@ ctypes.CDLL(None).pthread_exit(None)
         self.allocate(); self.accept()
         race = self.g("rev-parse", "main")
         self.configure(remote_delete_race=True, race_sha=race)
-        _, r = self.complete("--writers-stopped", "--mode", "auto", success=False)
-        self.assertNotEqual(r.returncode, 0)
+        result, _ = self.complete("--writers-stopped", "--mode", "auto")
+        self.assertEqual((result["status"], result["delivery_status"]), ("CLEANUP_PENDING", "COMPLETE"))
         self.assertEqual(self.g("ls-remote", "origin", "refs/heads/task/fixture").split()[0], race)
         self.assertNotEqual(self.g("branch", "--list", "task/fixture"), "")
 
@@ -4032,16 +4711,37 @@ ctypes.CDLL(None).pthread_exit(None)
         self.assertEqual(d["prs"][0]["state"], "MERGED")
         self.assertIsNone(d["prs"][0]["autoMergeRequest"])
 
-    def test_auto_disallowed_blocked_refuses_without_merge(self):
+    def test_auto_disallowed_blocked_waits_and_its_resume_merges(self):
+        # Prediction (B3): with auto-merge off, required checks or reviews not passing yet (BLOCKED) make no merge call
+        # and report PENDING with merge_waits; once the PR is CLEAN the printed resume merges it directly and cleans.
+        # Before: PR with merge_refused "not mergeable: BLOCKED", a refusal left for a person.
+        self.allocate(); self.accept()
+        self.configure(auto_allowed=False, merge_state="BLOCKED")
+        result, _ = self.complete("--mode", "auto", "--writers-stopped")
+        self.assertEqual((result["status"], result.get("merge_waits")), ("PENDING", "BLOCKED"))
+        self.assertNotIn("merge_refused", result)
+        d = json.loads(self.data.read_text(encoding="utf-8"))
+        self.assertEqual((d.get("merge_calls", []), d["prs"][0]["state"]), ([], "OPEN"))
+        self.assertEqual(read_json(self.receipt)["delivery"], "PENDING")
+        self.configure(merge_state="CLEAN")
+        result, _ = self.cli(*shlex.split(result["resume"])[2:])
+        self.assertEqual(result["status"], "COMPLETE")
+        d = json.loads(self.data.read_text(encoding="utf-8"))
+        self.assertEqual(d["merge_calls"], [["pr", "merge", "1", "--merge", "--match-head-commit", self.sha,
+                                            "--repo", "github.com/test/project"]])
+        self.assertEqual(d["prs"][0]["state"], "MERGED")
+        self.assertFalse(self.task.exists())
+
+    def test_auto_disallowed_unmergeable_states_refuse_without_merge(self):
         self.allocate(); self.accept()
-        for state in ("BLOCKED", "BEHIND", "DIRTY", "DRAFT", "NEW_STATE"):
+        for state in ("BEHIND", "DIRTY", "DRAFT", "NEW_STATE"):
             with self.subTest(state=state):
                 self.configure(auto_allowed=False, merge_state=state)
                 result, _ = self.complete("--mode", "auto")
                 self.assertEqual(result["status"], "PR")
                 self.assertIn("not mergeable: " + state, result["merge_refused"])
         d = json.loads(self.data.read_text(encoding="utf-8"))
-        self.assertEqual(d["merge_state_views"], ["BLOCKED", "BEHIND", "DIRTY", "DRAFT", "NEW_STATE"])
+        self.assertEqual(d["merge_state_views"], ["BEHIND", "DIRTY", "DRAFT", "NEW_STATE"])
         self.assertEqual(d.get("merge_calls", []), [])
         self.assertEqual(d["prs"][0]["state"], "OPEN")
         self.assertIsNone(d["prs"][0]["autoMergeRequest"])
@@ -4065,12 +4765,12 @@ ctypes.CDLL(None).pthread_exit(None)
         self.assertEqual(result["status"], "PENDING")
         self.assertEqual(json.loads(self.data.read_text(encoding="utf-8"))["auto_setting_reads"], 1)
 
-    def test_auto_disallowed_unknown_bound_refuses_without_merge(self):
+    def test_auto_disallowed_unknown_bound_waits_without_merge(self):
         self.allocate(); self.accept()
         self.configure(auto_allowed=False, merge_state="UNKNOWN")
         result, _ = self.complete("--mode", "auto")
-        self.assertEqual(result["status"], "PR")
-        self.assertIn("not mergeable: UNKNOWN", result["merge_refused"])
+        self.assertEqual((result["status"], result.get("merge_waits")), ("PENDING", "UNKNOWN"))
+        self.assertNotIn("merge_refused", result)
         d = json.loads(self.data.read_text(encoding="utf-8"))
         self.assertEqual(d["merge_state_views"], ["UNKNOWN"] * 10)
         self.assertEqual(d.get("merge_calls", []), [])
@@ -4154,8 +4854,8 @@ ctypes.CDLL(None).pthread_exit(None)
         self.assertNotIn("merge_refused", result)
         self.configure(merge_allowed=True, auto_allowed=False, pending=True)
         result, _ = self.complete("--mode", "auto")
-        self.assertEqual(result["status"], "PR")
-        self.assertIn("not mergeable: BLOCKED", result["merge_refused"])
+        self.assertEqual((result["status"], result.get("merge_waits")), ("PENDING", "BLOCKED"))
+        self.assertNotIn("merge_refused", result)
         self.assertTrue(self.task.exists())
         # Local-only cannot rewrite the delivery of a pushed PR; a local allocation keeps it (test_local_chain_*).
         result, _ = self.complete("--no-push", success=False)
@@ -4214,8 +4914,8 @@ ctypes.CDLL(None).pthread_exit(None)
         user_file.write_text("retained user data", encoding="utf-8")
         before = self.anchor_state()
         self.configure(interrupt_delete=True)
-        _, r = self.complete(acceptance=False, success=False)
-        self.assertNotEqual(r.returncode, 0)
+        result, _ = self.complete(acceptance=False)
+        self.assertEqual((result["status"], result["delivery_status"]), ("CLEANUP_PENDING", "COMPLETE"))
         self.assertEqual(self.anchor_state(), before)
         other = self.root / "advance"
         self.run_cmd(["git", "clone", str(self.bare), str(other)])