devlyn-cli 4.3.14 → 4.3.16

package/bin/skill-history.json

@@ -106,6 +106,7 @@
       "865e26f38b04dbaae6b0b91616110d6bd748909b7dec68f20cd7c2a240d2fa5a",
       "8ab08b8f3d19e7fffc36fbc4d8c4dad83df02bcb83a9aabcb8db8b82fe12b384",
       "8b34167328e88c73538b5ae2a30e452b544a44bc03f70a2c4f0278b33953afc4",
+      "8b87eadbb611342029cb9c153b32e2a483bb272dee70b49f0cae251b76a72ecf",
       "8c80926ab03b2477e52264495b35c2116f65fc51b02e8c56e441b5705872392a",
       "8fb73c0d2472b3643ac6e3f0ad87d818694afebaf68fcad596496e703893c43d",
       "9162fc2fed6f4a611d299485be3a397080beb3304865ce59b95576ba7d00650e",
@@ -771,6 +772,8 @@
     "4.3.12",
     "4.3.13",
     "4.3.14",
+    "4.3.15",
+    "4.3.16",
     "4.3.2",
     "4.3.3",
     "4.3.4",

package/config/skills/_shared/task-complete.py

@@ -8,6 +8,7 @@ from __future__ import annotations
 
 import argparse
 import contextlib
+import ctypes
 import errno
 import functools
 import hashlib
@@ -628,6 +629,18 @@ def linux_process_status(process):
         raise WritersUnobservable("unknown process status; retain tree until writer cessation can be established") from exc
 
 
+def darwin_executable(pid):
+    # The real executable (ps prints argv[0]); only names a retention reason.
+    with contextlib.suppress(OSError):
+        proc_pidpath = ctypes.CDLL("/usr/lib/libproc.dylib").proc_pidpath
+        proc_pidpath.argtypes = [ctypes.c_int, ctypes.c_void_p, ctypes.c_uint32]
+        proc_pidpath.restype = ctypes.c_int
+        buffer = ctypes.create_string_buffer(4096)  # PROC_PIDPATHINFO_MAXSIZE
+        if proc_pidpath(pid, buffer, ctypes.sizeof(buffer)) > 0:
+            return os.fsdecode(buffer.value)
+    return None
+
+
 def stopped_writers(work):
     outside(work)
     # The owner assertion covers its actual children; an OS observation catches
@@ -637,10 +650,18 @@ def stopped_writers(work):
         if result.returncode not in {0, 1} or result.stderr.strip():
             raise WritersUnobservable("writer observation unavailable; retain tree and inspect writers")
         pid = None
-        for line in result.stdout.splitlines():
+        for line in result.stdout.split("\n"):
             if line.startswith("p"):
                 pid = int(line[1:])
             elif line.startswith("n") and pid != os.getpid():
+                executable = darwin_executable(pid)
+                if (executable is not None
+                        and executable.startswith("/System/Library/Frameworks/Virtualization.framework/")
+                        and executable.endswith("/com.apple.Virtualization.VirtualMachine")):
+                    raise WriterActive(
+                        f"active process {pid} is a virtual machine (Docker Desktop or another Virtualization.framework VM) "
+                        "and holds task files, as it can after a bind mount until restarted; "
+                        "stop containers using them and restart the VM's app before resume")
                 raise WriterActive(f"active process {pid} uses task files; stop/yield actual writers before resume")
     elif sys.platform.startswith("linux"):
         for process in Path("/proc").iterdir():
@@ -1835,6 +1856,86 @@ class CompletionTests(unittest.TestCase):
             child.wait(timeout=5)
         self.cli("clean-scratch", "--receipt", self.receipt, "--writers-stopped")
 
+    def test_darwin_writer_scan_retains_all_holders_and_names_virtual_machines(self):
+        from unittest.mock import Mock, call, patch
+        pid = os.getpid() + 1
+        vm = "/System/Library/Frameworks/Virtualization.framework/Versions/A/XPCServices/com.apple.Virtualization.VirtualMachine.xpc/Contents/MacOS/com.apple.Virtualization.VirtualMachine"
+        ordinary = f"active process {pid} uses task files; stop/yield actual writers before resume"
+        vm_reason = (f"active process {pid} is a virtual machine (Docker Desktop or another Virtualization.framework VM) "
+                     "and holds task files, as it can after a bind mount until restarted; "
+                     "stop containers using them and restart the VM's app before resume")
+        own = f"p{os.getpid()}\nn{self.work}\nn{self.work / 'product'}\n"
+        lsof = call(["lsof", "-Fpn", "+D", str(self.work)], capture_output=True, text=True, encoding="utf-8")
+        executable = Mock()
+        with patch.object(sys, "platform", "darwin"), patch.object(subprocess, "run") as run, patch.dict(globals(), darwin_executable=executable):
+            for path, reason in ((vm, vm_reason), (vm.replace("VirtualMachine", "EventTap"), ordinary),
+                                 ("/bin/bash", ordinary), (None, ordinary)):
+                for name in ("product", "product\u2028p", "product\u2029p"):
+                    with self.subTest(executable=path, name=name):
+                        run.reset_mock()
+                        executable.reset_mock()
+                        executable.return_value = path
+                        records = (f"p{os.getpid()}\nn{self.work / name}\np{pid}\n"
+                                   f"n{self.work / ('product' if name == 'product' else 'held')}\n")
+                        run.return_value = subprocess.CompletedProcess([], 0, records, "")
+                        with self.assertRaises(WriterActive) as raised:
+                            stopped_writers(self.work)
+                        self.assertEqual(str(raised.exception), reason)
+                        self.assertEqual(run.call_args_list, [lsof])
+                        executable.assert_called_once_with(pid)
+            run.reset_mock()
+            executable.reset_mock()
+            run.return_value = subprocess.CompletedProcess([], 0, own, "")
+            stopped_writers(self.work)
+            self.assertEqual(run.call_args_list, [lsof])
+            executable.assert_not_called()
+            for code, stderr in ((0, "warning"), (1, "warning"), (2, ""), (-1, "")):
+                with self.subTest(code=code, stderr=stderr):
+                    run.return_value = subprocess.CompletedProcess([], code, f"p{pid}\nn{self.work}\n", stderr)
+                    with self.assertRaises(WritersUnobservable):
+                        stopped_writers(self.work)
+                    executable.assert_not_called()
+            run.return_value = subprocess.CompletedProcess([], 1, "", "")
+            stopped_writers(self.work)
+            executable.assert_not_called()
+
+    @unittest.skipUnless(sys.platform == "darwin", "requires macOS proc_pidpath")
+    def test_darwin_executable(self):
+        from unittest.mock import patch
+        with self.subTest(process="self"):
+            executable = darwin_executable(os.getpid())
+            self.assertEqual(executable, os.path.realpath(executable))
+            self.assertTrue(os.path.isfile(executable))
+            self.assertTrue(os.access(executable, os.X_OK))
+        with self.subTest(process="reaped"):
+            with subprocess.Popen([sys.executable, "-c", "pass"]) as child:
+                child.wait(timeout=5)
+            self.assertIsNone(darwin_executable(child.pid))
+        with self.subTest(error="lookup failed"), patch.object(ctypes, "CDLL") as library:
+            library.return_value.proc_pidpath.return_value = 0
+            self.assertIsNone(darwin_executable(os.getpid()))
+        with self.subTest(error="library unavailable"), patch.object(ctypes, "CDLL", side_effect=OSError("libproc unavailable")):
+            self.assertIsNone(darwin_executable(os.getpid()))
+
+    @unittest.skipUnless(sys.platform == "darwin", "requires macOS lsof descriptor access")
+    def test_darwin_real_read_only_descriptors_and_scripts_block(self):
+        script = self.work / "loop.sh"
+        script.write_text("printf 'ready\\n'\nwhile :; do sleep 1; done\n", encoding="utf-8")
+        for command in ([sys.executable, "-c",
+                         "import os, sys, time; f = open(sys.argv[1], 'rb'); "
+                         "d = os.open(sys.argv[2], os.O_RDONLY); print('ready', flush=True); time.sleep(30)",
+                         str(self.work / "product"), str(self.work)], ["/bin/bash", str(script)]):
+            with self.subTest(command=command[0]):
+                child = subprocess.Popen(command, cwd=self.root, stdout=subprocess.PIPE, text=True)
+                try:
+                    self.assertEqual(child.stdout.readline(), "ready\n")
+                    with self.assertRaisesRegex(WriterActive, f"active process {child.pid} uses task files"):
+                        stopped_writers(self.work)
+                finally:
+                    child.kill()
+                    child.wait(timeout=5)
+                    child.stdout.close()
+
     def test_linux_writer_scan_continues_after_vanished_fd(self):
         from unittest.mock import patch
         process = Path("/proc") / str(os.getpid() + 1)

package/config/skills/_shared/task-completion.md

@@ -237,6 +237,9 @@ files inside the tree, inaccessible process state (on Linux, other users'
 processes unless run as root), caller cwd inside the tree, dirty/untracked files,
 a nested repository or worktree, or changed refs/Gitdir/registration retain
 affected resources. Use `git worktree lock` to keep a tree.
+A VM that shared the tree (Docker Desktop after a bind mount) can keep files open
+until it restarts; the helper names it when identifiable and retries cleanup on
+the next allocation or resume after the restart.
 On native Windows, locking and file durability are supported, but the helper cannot prove writer cessation and reports `writer observation unsupported on this platform; retain workspace`. Even `--writers-stopped` cannot authorize deletion without that observation: retain the workspace, its task refs and external receipt/custody, report delivery separately, and preserve the receipt-based resume command. A merged delivery therefore reports `CLEANUP_PENDING` (delivery `COMPLETE`) with `workspace_cleanup` naming the reason and resume. Do not kill unknown processes or force worktree removal to make completion pass.
 
 The receipt directory holds byte-verified `custody/`, `manifest.json` and a guarded

package/native/claude/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "devlyn",
-  "version": "4.3.14",
+  "version": "4.3.16",
   "description": "Devlyn harness skills",
   "skills": "./skills/"
 }

package/native/claude/skills/_shared/task-complete.py

@@ -8,6 +8,7 @@ from __future__ import annotations
 
 import argparse
 import contextlib
+import ctypes
 import errno
 import functools
 import hashlib
@@ -628,6 +629,18 @@ def linux_process_status(process):
         raise WritersUnobservable("unknown process status; retain tree until writer cessation can be established") from exc
 
 
+def darwin_executable(pid):
+    # The real executable (ps prints argv[0]); only names a retention reason.
+    with contextlib.suppress(OSError):
+        proc_pidpath = ctypes.CDLL("/usr/lib/libproc.dylib").proc_pidpath
+        proc_pidpath.argtypes = [ctypes.c_int, ctypes.c_void_p, ctypes.c_uint32]
+        proc_pidpath.restype = ctypes.c_int
+        buffer = ctypes.create_string_buffer(4096)  # PROC_PIDPATHINFO_MAXSIZE
+        if proc_pidpath(pid, buffer, ctypes.sizeof(buffer)) > 0:
+            return os.fsdecode(buffer.value)
+    return None
+
+
 def stopped_writers(work):
     outside(work)
     # The owner assertion covers its actual children; an OS observation catches
@@ -637,10 +650,18 @@ def stopped_writers(work):
         if result.returncode not in {0, 1} or result.stderr.strip():
             raise WritersUnobservable("writer observation unavailable; retain tree and inspect writers")
         pid = None
-        for line in result.stdout.splitlines():
+        for line in result.stdout.split("\n"):
             if line.startswith("p"):
                 pid = int(line[1:])
             elif line.startswith("n") and pid != os.getpid():
+                executable = darwin_executable(pid)
+                if (executable is not None
+                        and executable.startswith("/System/Library/Frameworks/Virtualization.framework/")
+                        and executable.endswith("/com.apple.Virtualization.VirtualMachine")):
+                    raise WriterActive(
+                        f"active process {pid} is a virtual machine (Docker Desktop or another Virtualization.framework VM) "
+                        "and holds task files, as it can after a bind mount until restarted; "
+                        "stop containers using them and restart the VM's app before resume")
                 raise WriterActive(f"active process {pid} uses task files; stop/yield actual writers before resume")
     elif sys.platform.startswith("linux"):
         for process in Path("/proc").iterdir():
@@ -1835,6 +1856,86 @@ class CompletionTests(unittest.TestCase):
             child.wait(timeout=5)
         self.cli("clean-scratch", "--receipt", self.receipt, "--writers-stopped")
 
+    def test_darwin_writer_scan_retains_all_holders_and_names_virtual_machines(self):
+        from unittest.mock import Mock, call, patch
+        pid = os.getpid() + 1
+        vm = "/System/Library/Frameworks/Virtualization.framework/Versions/A/XPCServices/com.apple.Virtualization.VirtualMachine.xpc/Contents/MacOS/com.apple.Virtualization.VirtualMachine"
+        ordinary = f"active process {pid} uses task files; stop/yield actual writers before resume"
+        vm_reason = (f"active process {pid} is a virtual machine (Docker Desktop or another Virtualization.framework VM) "
+                     "and holds task files, as it can after a bind mount until restarted; "
+                     "stop containers using them and restart the VM's app before resume")
+        own = f"p{os.getpid()}\nn{self.work}\nn{self.work / 'product'}\n"
+        lsof = call(["lsof", "-Fpn", "+D", str(self.work)], capture_output=True, text=True, encoding="utf-8")
+        executable = Mock()
+        with patch.object(sys, "platform", "darwin"), patch.object(subprocess, "run") as run, patch.dict(globals(), darwin_executable=executable):
+            for path, reason in ((vm, vm_reason), (vm.replace("VirtualMachine", "EventTap"), ordinary),
+                                 ("/bin/bash", ordinary), (None, ordinary)):
+                for name in ("product", "product\u2028p", "product\u2029p"):
+                    with self.subTest(executable=path, name=name):
+                        run.reset_mock()
+                        executable.reset_mock()
+                        executable.return_value = path
+                        records = (f"p{os.getpid()}\nn{self.work / name}\np{pid}\n"
+                                   f"n{self.work / ('product' if name == 'product' else 'held')}\n")
+                        run.return_value = subprocess.CompletedProcess([], 0, records, "")
+                        with self.assertRaises(WriterActive) as raised:
+                            stopped_writers(self.work)
+                        self.assertEqual(str(raised.exception), reason)
+                        self.assertEqual(run.call_args_list, [lsof])
+                        executable.assert_called_once_with(pid)
+            run.reset_mock()
+            executable.reset_mock()
+            run.return_value = subprocess.CompletedProcess([], 0, own, "")
+            stopped_writers(self.work)
+            self.assertEqual(run.call_args_list, [lsof])
+            executable.assert_not_called()
+            for code, stderr in ((0, "warning"), (1, "warning"), (2, ""), (-1, "")):
+                with self.subTest(code=code, stderr=stderr):
+                    run.return_value = subprocess.CompletedProcess([], code, f"p{pid}\nn{self.work}\n", stderr)
+                    with self.assertRaises(WritersUnobservable):
+                        stopped_writers(self.work)
+                    executable.assert_not_called()
+            run.return_value = subprocess.CompletedProcess([], 1, "", "")
+            stopped_writers(self.work)
+            executable.assert_not_called()
+
+    @unittest.skipUnless(sys.platform == "darwin", "requires macOS proc_pidpath")
+    def test_darwin_executable(self):
+        from unittest.mock import patch
+        with self.subTest(process="self"):
+            executable = darwin_executable(os.getpid())
+            self.assertEqual(executable, os.path.realpath(executable))
+            self.assertTrue(os.path.isfile(executable))
+            self.assertTrue(os.access(executable, os.X_OK))
+        with self.subTest(process="reaped"):
+            with subprocess.Popen([sys.executable, "-c", "pass"]) as child:
+                child.wait(timeout=5)
+            self.assertIsNone(darwin_executable(child.pid))
+        with self.subTest(error="lookup failed"), patch.object(ctypes, "CDLL") as library:
+            library.return_value.proc_pidpath.return_value = 0
+            self.assertIsNone(darwin_executable(os.getpid()))
+        with self.subTest(error="library unavailable"), patch.object(ctypes, "CDLL", side_effect=OSError("libproc unavailable")):
+            self.assertIsNone(darwin_executable(os.getpid()))
+
+    @unittest.skipUnless(sys.platform == "darwin", "requires macOS lsof descriptor access")
+    def test_darwin_real_read_only_descriptors_and_scripts_block(self):
+        script = self.work / "loop.sh"
+        script.write_text("printf 'ready\\n'\nwhile :; do sleep 1; done\n", encoding="utf-8")
+        for command in ([sys.executable, "-c",
+                         "import os, sys, time; f = open(sys.argv[1], 'rb'); "
+                         "d = os.open(sys.argv[2], os.O_RDONLY); print('ready', flush=True); time.sleep(30)",
+                         str(self.work / "product"), str(self.work)], ["/bin/bash", str(script)]):
+            with self.subTest(command=command[0]):
+                child = subprocess.Popen(command, cwd=self.root, stdout=subprocess.PIPE, text=True)
+                try:
+                    self.assertEqual(child.stdout.readline(), "ready\n")
+                    with self.assertRaisesRegex(WriterActive, f"active process {child.pid} uses task files"):
+                        stopped_writers(self.work)
+                finally:
+                    child.kill()
+                    child.wait(timeout=5)
+                    child.stdout.close()
+
     def test_linux_writer_scan_continues_after_vanished_fd(self):
         from unittest.mock import patch
         process = Path("/proc") / str(os.getpid() + 1)

package/native/claude/skills/_shared/task-completion.md

@@ -237,6 +237,9 @@ files inside the tree, inaccessible process state (on Linux, other users'
 processes unless run as root), caller cwd inside the tree, dirty/untracked files,
 a nested repository or worktree, or changed refs/Gitdir/registration retain
 affected resources. Use `git worktree lock` to keep a tree.
+A VM that shared the tree (Docker Desktop after a bind mount) can keep files open
+until it restarts; the helper names it when identifiable and retries cleanup on
+the next allocation or resume after the restart.
 On native Windows, locking and file durability are supported, but the helper cannot prove writer cessation and reports `writer observation unsupported on this platform; retain workspace`. Even `--writers-stopped` cannot authorize deletion without that observation: retain the workspace, its task refs and external receipt/custody, report delivery separately, and preserve the receipt-based resume command. A merged delivery therefore reports `CLEANUP_PENDING` (delivery `COMPLETE`) with `workspace_cleanup` naming the reason and resume. Do not kill unknown processes or force worktree removal to make completion pass.
 
 The receipt directory holds byte-verified `custody/`, `manifest.json` and a guarded

package/native/codex/.agents/plugins/marketplace.json

@@ -1,5 +1,5 @@
 {
-  "name": "devlyn-harness-v4-3-14",
+  "name": "devlyn-harness-v4-3-16",
   "plugins": [
     {
       "name": "devlyn",

package/native/codex/plugins/devlyn/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "devlyn",
-  "version": "4.3.14",
+  "version": "4.3.16",
   "description": "Devlyn harness skills",
   "skills": "./skills/"
 }

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

@@ -8,6 +8,7 @@ from __future__ import annotations
 
 import argparse
 import contextlib
+import ctypes
 import errno
 import functools
 import hashlib
@@ -628,6 +629,18 @@ def linux_process_status(process):
         raise WritersUnobservable("unknown process status; retain tree until writer cessation can be established") from exc
 
 
+def darwin_executable(pid):
+    # The real executable (ps prints argv[0]); only names a retention reason.
+    with contextlib.suppress(OSError):
+        proc_pidpath = ctypes.CDLL("/usr/lib/libproc.dylib").proc_pidpath
+        proc_pidpath.argtypes = [ctypes.c_int, ctypes.c_void_p, ctypes.c_uint32]
+        proc_pidpath.restype = ctypes.c_int
+        buffer = ctypes.create_string_buffer(4096)  # PROC_PIDPATHINFO_MAXSIZE
+        if proc_pidpath(pid, buffer, ctypes.sizeof(buffer)) > 0:
+            return os.fsdecode(buffer.value)
+    return None
+
+
 def stopped_writers(work):
     outside(work)
     # The owner assertion covers its actual children; an OS observation catches
@@ -637,10 +650,18 @@ def stopped_writers(work):
         if result.returncode not in {0, 1} or result.stderr.strip():
             raise WritersUnobservable("writer observation unavailable; retain tree and inspect writers")
         pid = None
-        for line in result.stdout.splitlines():
+        for line in result.stdout.split("\n"):
             if line.startswith("p"):
                 pid = int(line[1:])
             elif line.startswith("n") and pid != os.getpid():
+                executable = darwin_executable(pid)
+                if (executable is not None
+                        and executable.startswith("/System/Library/Frameworks/Virtualization.framework/")
+                        and executable.endswith("/com.apple.Virtualization.VirtualMachine")):
+                    raise WriterActive(
+                        f"active process {pid} is a virtual machine (Docker Desktop or another Virtualization.framework VM) "
+                        "and holds task files, as it can after a bind mount until restarted; "
+                        "stop containers using them and restart the VM's app before resume")
                 raise WriterActive(f"active process {pid} uses task files; stop/yield actual writers before resume")
     elif sys.platform.startswith("linux"):
         for process in Path("/proc").iterdir():
@@ -1835,6 +1856,86 @@ class CompletionTests(unittest.TestCase):
             child.wait(timeout=5)
         self.cli("clean-scratch", "--receipt", self.receipt, "--writers-stopped")
 
+    def test_darwin_writer_scan_retains_all_holders_and_names_virtual_machines(self):
+        from unittest.mock import Mock, call, patch
+        pid = os.getpid() + 1
+        vm = "/System/Library/Frameworks/Virtualization.framework/Versions/A/XPCServices/com.apple.Virtualization.VirtualMachine.xpc/Contents/MacOS/com.apple.Virtualization.VirtualMachine"
+        ordinary = f"active process {pid} uses task files; stop/yield actual writers before resume"
+        vm_reason = (f"active process {pid} is a virtual machine (Docker Desktop or another Virtualization.framework VM) "
+                     "and holds task files, as it can after a bind mount until restarted; "
+                     "stop containers using them and restart the VM's app before resume")
+        own = f"p{os.getpid()}\nn{self.work}\nn{self.work / 'product'}\n"
+        lsof = call(["lsof", "-Fpn", "+D", str(self.work)], capture_output=True, text=True, encoding="utf-8")
+        executable = Mock()
+        with patch.object(sys, "platform", "darwin"), patch.object(subprocess, "run") as run, patch.dict(globals(), darwin_executable=executable):
+            for path, reason in ((vm, vm_reason), (vm.replace("VirtualMachine", "EventTap"), ordinary),
+                                 ("/bin/bash", ordinary), (None, ordinary)):
+                for name in ("product", "product\u2028p", "product\u2029p"):
+                    with self.subTest(executable=path, name=name):
+                        run.reset_mock()
+                        executable.reset_mock()
+                        executable.return_value = path
+                        records = (f"p{os.getpid()}\nn{self.work / name}\np{pid}\n"
+                                   f"n{self.work / ('product' if name == 'product' else 'held')}\n")
+                        run.return_value = subprocess.CompletedProcess([], 0, records, "")
+                        with self.assertRaises(WriterActive) as raised:
+                            stopped_writers(self.work)
+                        self.assertEqual(str(raised.exception), reason)
+                        self.assertEqual(run.call_args_list, [lsof])
+                        executable.assert_called_once_with(pid)
+            run.reset_mock()
+            executable.reset_mock()
+            run.return_value = subprocess.CompletedProcess([], 0, own, "")
+            stopped_writers(self.work)
+            self.assertEqual(run.call_args_list, [lsof])
+            executable.assert_not_called()
+            for code, stderr in ((0, "warning"), (1, "warning"), (2, ""), (-1, "")):
+                with self.subTest(code=code, stderr=stderr):
+                    run.return_value = subprocess.CompletedProcess([], code, f"p{pid}\nn{self.work}\n", stderr)
+                    with self.assertRaises(WritersUnobservable):
+                        stopped_writers(self.work)
+                    executable.assert_not_called()
+            run.return_value = subprocess.CompletedProcess([], 1, "", "")
+            stopped_writers(self.work)
+            executable.assert_not_called()
+
+    @unittest.skipUnless(sys.platform == "darwin", "requires macOS proc_pidpath")
+    def test_darwin_executable(self):
+        from unittest.mock import patch
+        with self.subTest(process="self"):
+            executable = darwin_executable(os.getpid())
+            self.assertEqual(executable, os.path.realpath(executable))
+            self.assertTrue(os.path.isfile(executable))
+            self.assertTrue(os.access(executable, os.X_OK))
+        with self.subTest(process="reaped"):
+            with subprocess.Popen([sys.executable, "-c", "pass"]) as child:
+                child.wait(timeout=5)
+            self.assertIsNone(darwin_executable(child.pid))
+        with self.subTest(error="lookup failed"), patch.object(ctypes, "CDLL") as library:
+            library.return_value.proc_pidpath.return_value = 0
+            self.assertIsNone(darwin_executable(os.getpid()))
+        with self.subTest(error="library unavailable"), patch.object(ctypes, "CDLL", side_effect=OSError("libproc unavailable")):
+            self.assertIsNone(darwin_executable(os.getpid()))
+
+    @unittest.skipUnless(sys.platform == "darwin", "requires macOS lsof descriptor access")
+    def test_darwin_real_read_only_descriptors_and_scripts_block(self):
+        script = self.work / "loop.sh"
+        script.write_text("printf 'ready\\n'\nwhile :; do sleep 1; done\n", encoding="utf-8")
+        for command in ([sys.executable, "-c",
+                         "import os, sys, time; f = open(sys.argv[1], 'rb'); "
+                         "d = os.open(sys.argv[2], os.O_RDONLY); print('ready', flush=True); time.sleep(30)",
+                         str(self.work / "product"), str(self.work)], ["/bin/bash", str(script)]):
+            with self.subTest(command=command[0]):
+                child = subprocess.Popen(command, cwd=self.root, stdout=subprocess.PIPE, text=True)
+                try:
+                    self.assertEqual(child.stdout.readline(), "ready\n")
+                    with self.assertRaisesRegex(WriterActive, f"active process {child.pid} uses task files"):
+                        stopped_writers(self.work)
+                finally:
+                    child.kill()
+                    child.wait(timeout=5)
+                    child.stdout.close()
+
     def test_linux_writer_scan_continues_after_vanished_fd(self):
         from unittest.mock import patch
         process = Path("/proc") / str(os.getpid() + 1)

package/native/codex/plugins/devlyn/skills/_shared/task-completion.md

@@ -237,6 +237,9 @@ files inside the tree, inaccessible process state (on Linux, other users'
 processes unless run as root), caller cwd inside the tree, dirty/untracked files,
 a nested repository or worktree, or changed refs/Gitdir/registration retain
 affected resources. Use `git worktree lock` to keep a tree.
+A VM that shared the tree (Docker Desktop after a bind mount) can keep files open
+until it restarts; the helper names it when identifiable and retries cleanup on
+the next allocation or resume after the restart.
 On native Windows, locking and file durability are supported, but the helper cannot prove writer cessation and reports `writer observation unsupported on this platform; retain workspace`. Even `--writers-stopped` cannot authorize deletion without that observation: retain the workspace, its task refs and external receipt/custody, report delivery separately, and preserve the receipt-based resume command. A merged delivery therefore reports `CLEANUP_PENDING` (delivery `COMPLETE`) with `workspace_cleanup` naming the reason and resume. Do not kill unknown processes or force worktree removal to make completion pass.
 
 The receipt directory holds byte-verified `custody/`, `manifest.json` and a guarded

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "devlyn-cli",
-  "version": "4.3.14",
+  "version": "4.3.16",
   "description": "Loop & harness engineering for AI coding agents (Claude Code, Codex, and any AGENTS.md-driven agent) — core engineering principles for CLAUDE.md/AGENTS.md and a loop designer that splits one intent into tasks agents drain hands-free",
   "homepage": "https://github.com/fysoul17/devlyn-cli#readme",
   "bin": {

package/release.json

@@ -1,7 +1,7 @@
 {
   "schemaVersion": 1,
   "package": "devlyn-cli",
-  "version": "4.3.14",
+  "version": "4.3.16",
   "principles": {
     "defaults": "config/skills/_shared/runtime-principles.md",
     "memory": {
@@ -129,7 +129,7 @@
     },
     {
       "path": "bin/devlyn.js",
-      "sha256": "bbf2a2ee5309eab804cc3e03fd4c9bd0e0c71db67cfacc764c2f5e611968b4bf",
+      "sha256": "616c6cd8c52d310dc5c5040c4d40e1dedb6bc50ca088428a5dcea8ac805ea188",
       "executable": true
     },
     {
@@ -164,7 +164,7 @@
     },
     {
       "path": "bin/skill-history.json",
-      "sha256": "eb54a16283da49f9817a7b306f3be3c26bb0a01b8372a8377ee68461789ae43a",
+      "sha256": "bb0616e1499249bfa9f2bbe5d36adefb1c4fd8e671f7c62be248db444619630e",
       "executable": false
     },
     {
@@ -244,12 +244,12 @@
     },
     {
       "path": "config/skills/_shared/task-complete.py",
-      "sha256": "f9709f6855f511401205788aecf8aa59e268855b7673b84ed617adee56a245dc",
+      "sha256": "4d01c1a9d9c5dd54d884e8248f922404959def9a6e3b96da6497d2940295b8df",
       "executable": false
     },
     {
       "path": "config/skills/_shared/task-completion.md",
-      "sha256": "8b9a8706ab912165f2eef66bc39f2261f88df2b1b682d8d90d7f05f6014e965e",
+      "sha256": "dc608ff5de6cf03b0649cdb35b7ed6ded64f1b2164bf41cc522fd12ac93a2730",
       "executable": false
     },
     {
@@ -309,7 +309,7 @@
     },
     {
       "path": "native/claude/.claude-plugin/plugin.json",
-      "sha256": "69ae38cdcbcd7e7c695bf44241103657690be50e971baba15ec592b3e29c71df",
+      "sha256": "66df694e66f27457ab9b801058af9a06ed6a9ad4c22805f6a35d2e500e0fc624",
       "executable": false
     },
     {
@@ -384,12 +384,12 @@
     },
     {
       "path": "native/claude/skills/_shared/task-complete.py",
-      "sha256": "f9709f6855f511401205788aecf8aa59e268855b7673b84ed617adee56a245dc",
+      "sha256": "4d01c1a9d9c5dd54d884e8248f922404959def9a6e3b96da6497d2940295b8df",
       "executable": false
     },
     {
       "path": "native/claude/skills/_shared/task-completion.md",
-      "sha256": "8b9a8706ab912165f2eef66bc39f2261f88df2b1b682d8d90d7f05f6014e965e",
+      "sha256": "dc608ff5de6cf03b0649cdb35b7ed6ded64f1b2164bf41cc522fd12ac93a2730",
       "executable": false
     },
     {
@@ -439,12 +439,12 @@
     },
     {
       "path": "native/codex/.agents/plugins/marketplace.json",
-      "sha256": "9cd5c06de1b20c1fec885ad85ee1409505c4d03e74e60ca6774247aa93269b8d",
+      "sha256": "c218c7b7ee50bd44da1c4f173322cc2f4bca9bcca89beff870a730aaaf504ae5",
       "executable": false
     },
     {
       "path": "native/codex/plugins/devlyn/.codex-plugin/plugin.json",
-      "sha256": "69ae38cdcbcd7e7c695bf44241103657690be50e971baba15ec592b3e29c71df",
+      "sha256": "66df694e66f27457ab9b801058af9a06ed6a9ad4c22805f6a35d2e500e0fc624",
       "executable": false
     },
     {
@@ -519,12 +519,12 @@
     },
     {
       "path": "native/codex/plugins/devlyn/skills/_shared/task-complete.py",
-      "sha256": "f9709f6855f511401205788aecf8aa59e268855b7673b84ed617adee56a245dc",
+      "sha256": "4d01c1a9d9c5dd54d884e8248f922404959def9a6e3b96da6497d2940295b8df",
       "executable": false
     },
     {
       "path": "native/codex/plugins/devlyn/skills/_shared/task-completion.md",
-      "sha256": "8b9a8706ab912165f2eef66bc39f2261f88df2b1b682d8d90d7f05f6014e965e",
+      "sha256": "dc608ff5de6cf03b0649cdb35b7ed6ded64f1b2164bf41cc522fd12ac93a2730",
       "executable": false
     },
     {
@@ -1714,12 +1714,12 @@
     },
     {
       "path": "package.json",
-      "sha256": "bac25159f616f9a0583452dbf8eb902d2d746d095f2f70526792efa6e34fac0f",
+      "sha256": "031b1e8086ddf9f247312a33a95c5a02d7553b1eb41e93d61d8733ea258fe776",
       "executable": false
     }
   ],
   "digest": {
     "algorithm": "sha256",
-    "value": "4f420dc3d285818f7e5ed5bc007c4a718a2d2ed690c862321cc84fc14b907b2f"
+    "value": "43b2c6d34c3fd114335d0952e258d8637b420978aa97d311a64c38e96701c0d1"
   }
 }