devlyn-cli 4.3.4 → 4.3.6

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

@@ -239,14 +239,25 @@ def allocate(args, *, exclude_receipts=()):
         policy(receipt, None)
         receipt["remote_url"] = remote_url(receipt)
         require("\n" not in receipt["remote_url"]["push"] and receipt["remote_url"]["push"] == receipt["remote_url"]["fetch"], "split/multiple remote URLs are unsupported")
-    receipt["baseline"] = local or exact_commit(receipt, args.start, "--start") or remote_base(receipt)
     target = Path(args.worktree).resolve()  # A relative, `..` or symlinked (macOS /tmp) path names its real location.
     require(not target.exists() and all(not target.is_relative_to(p) and not p.is_relative_to(target) for p in map(Path, registrations(receipt))), "linked worktree must be an absent path disjoint from every registered worktree")
     receipt["worktree"] = str(target)
     key = hashlib.sha256(args.branch.encode()).hexdigest()[:24]
     directory = common / "devlyn-completion" / key
-    directory.mkdir(parents=True, exist_ok=False)
     path = directory / "receipt.json"
+    reconciled = [] if local else reconcile(common, path, work, exclude_receipts=exclude_receipts)
+    measured = target
+    while not measured.exists():
+        require(measured.parent != measured, f"no existing ancestor of {target} to measure free space")
+        measured = measured.parent
+    usage = shutil.disk_usage(measured)
+    floor = max(10 * 1024**3, (usage.total + 49) // 50)
+    require(usage.free >= floor,
+            f"BLOCKED:disk {usage.free} bytes ({usage.free / 1024**3:.2f} GiB) free is below the "
+            f"{floor} byte ({floor / 1024**3:.2f} GiB) floor on {measured}; free space "
+            "(for example, run Devlyn disk cleanup or remove finished task worktrees' build output), then allocate again")
+    receipt["baseline"] = local or exact_commit(receipt, args.start, "--start") or remote_base(receipt)
+    directory.mkdir(parents=True, exist_ok=False)
     receipt["id"] = key
     receipt["recovery_ref"] = "refs/devlyn/completed/" + key
     scratch = directory / "scratch"
@@ -270,7 +281,7 @@ def allocate(args, *, exclude_receipts=()):
         atomic_json(path, owned)
     return {"status": "ALLOCATED", "receipt": str(path), "worktree": str(target), "scratch": str(scratch),
             "build_dirs": owned["build_dirs"],
-            "reconciled": [] if local else reconcile(common, path, work, exclude_receipts=exclude_receipts)}
+            "reconciled": reconciled}
 
 
 def exact_commit(receipt, value, flag):
@@ -451,7 +462,15 @@ def validate_pr(receipt, pr):
 
 
 def workspace_identity(work, gitdir):
-    return [[p.stat().st_dev, p.stat().st_ino] for p in (work, gitdir)]
+    return [[info.st_dev, info.st_ino] for info in (work.stat(), gitdir.stat())]
+
+
+def same_workspace_identity(current, recorded):
+    # Device numbers change across restarts: compare inodes and whether the pair shares a filesystem.
+    def shape(identity):
+        (first_dev, first_ino), (second_dev, second_ino) = identity
+        return first_ino, second_ino, first_dev == second_dev
+    return shape(current) == shape(recorded)
 
 
 def inspect_workspace(receipt):
@@ -461,7 +480,7 @@ def inspect_workspace(receipt):
     expected = "refs/heads/" + receipt["branch"]
     require(row.get("branch") == expected, "foreign worktree branch; retain workspace")
     require(git(work, "rev-parse", "--absolute-git-dir") == receipt["worktree_gitdir"] and str(Path(git(work, "rev-parse", "--path-format=absolute", "--git-common-dir")).resolve()) == receipt["common_gitdir"], "worktree Gitdir ownership changed")
-    require(workspace_identity(work, Path(receipt["worktree_gitdir"])) == receipt["worktree_identity"], "worktree/registration was replaced; receipt no longer owns it")
+    require(same_workspace_identity(workspace_identity(work, Path(receipt["worktree_gitdir"])), receipt["worktree_identity"]), "worktree/registration was replaced; receipt no longer owns it")
     require(git(work, "rev-parse", "HEAD") == receipt.get("publish_sha", receipt["baseline"]), "task HEAD changed")
     require(not git(work, "status", "--porcelain", "--untracked-files=all"), "dirty/untracked workspace; retain files and commit only accepted scope")
 
@@ -581,8 +600,8 @@ def clean_scratch(receipt, path, writers_stopped):
         return {"status": "NOT_OWNED"}
     require(writers_stopped, "stop/yield scratch writers, then use --writers-stopped")
     require(scratch == scratch.resolve() and scratch.is_dir(), "owned scratch missing or redirected; retain and inspect")
-    identity = receipt["scratch_identity"]
-    require(workspace_identity(scratch, path.parent) == identity, "scratch directory was replaced; retain")
+    identity = workspace_identity(scratch, path.parent)
+    require(same_workspace_identity(identity, receipt["scratch_identity"]), "scratch directory was replaced; retain")
     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)
@@ -592,6 +611,7 @@ def clean_scratch(receipt, path, writers_stopped):
         for name in dirs + files:
             item = Path(directory) / name
             info = item.lstat()
+            # During this cleanup, device numbers must stay exact, including every child's device.
             require(info.st_dev == identity[0][0], "scratch contains a mounted filesystem; retain")
             size += info.st_size if stat.S_ISREG(info.st_mode) else 0
     stopped_writers(scratch)
@@ -1061,9 +1081,21 @@ sys.exit(r.returncode)
 
 class CompletionTests(unittest.TestCase):
     def setUp(self):
+        from unittest.mock import Mock, patch
         self.temp = tempfile.TemporaryDirectory(prefix="devlyn-completion-")
         self.addCleanup(self.temp.cleanup)
         self.root = Path(self.temp.name).resolve()
+        (self.root / "sitecustomize.py").write_text(
+            "import importlib.machinery, importlib.util, pathlib, sys\n"
+            "spec = importlib.machinery.PathFinder.find_spec('sitecustomize', [p for p in sys.path if pathlib.Path(p or '.').resolve() != pathlib.Path(__file__).resolve().parent])\n"
+            "if spec is not None and spec.loader is not None:\n"
+            "    spec.loader.exec_module(importlib.util.module_from_spec(spec))\n"
+            "import shutil\nfrom types import SimpleNamespace\n"
+            "shutil.disk_usage = lambda path: SimpleNamespace(total=100 * 1024**3, free=100 * 1024**3)\n",
+            encoding="utf-8")
+        disk_usage = patch.object(shutil, "disk_usage", return_value=Mock(total=100 * 1024**3, free=100 * 1024**3))
+        disk_usage.start()
+        self.addCleanup(disk_usage.stop)
         self.work = self.root / "work"
         self.bare = self.root / "remote.git"
         self.bin = self.root / "bin"
@@ -1075,6 +1107,8 @@ class CompletionTests(unittest.TestCase):
                     "GIT_COMMITTER_NAME": "Fixture", "GIT_COMMITTER_EMAIL": "fixture@example.invalid",
                     "FIXTURE_GH": str(self.data), "REAL_GIT": shutil.which("git"),
                     "GIT_CONFIG_COUNT": "0", "GIT_ALLOW_PROTOCOL": "file"}
+        self.env["PYTHONPATH"] = str(self.root) + os.pathsep + self.env.get("PYTHONPATH", "")
+        self.env["PYTHONDONTWRITEBYTECODE"] = "1"
         for key in list(self.env):
             if key in {"GIT_DIR", "GIT_WORK_TREE", "GIT_INDEX_FILE", "GIT_COMMON_DIR"}:
                 del self.env[key]
@@ -1118,6 +1152,80 @@ class CompletionTests(unittest.TestCase):
         self.task = Path(result["worktree"])
         return result
 
+    def allocation_args(self, name, worktree):
+        return argparse.Namespace(repo=str(self.work), task=name, branch="task/" + name,
+                                  repository="test/project", base="main", remote="origin", worktree=str(worktree),
+                                  local_base=None, from_receipt=None, start=None)
+
+    def test_disk_gate_refuses_without_allocation_artifacts(self):
+        # Prediction: below 10 GiB on a 100 GiB filesystem, no receipt, branch or worktree is created.
+        from unittest.mock import Mock, patch
+        target = self.root / "absent" / "new"
+        before = self.g("worktree", "list", "--porcelain")
+        with patch.dict(os.environ, self.env), patch.object(shutil, "disk_usage", return_value=Mock(total=100 * 1024**3, free=9 * 1024**3)) as usage:
+            with self.assertRaisesRegex(CompletionError, r"^BLOCKED:disk") as raised:
+                allocate(self.allocation_args("new", target))
+        usage.assert_called_once_with(self.root)
+        self.assertIn(str(9 * 1024**3), str(raised.exception))
+        self.assertIn(str(10 * 1024**3), str(raised.exception))
+        self.assertIn(str(self.root), str(raised.exception))
+        self.assertIn("allocate again", str(raised.exception))
+        self.assertFalse((self.work / ".git/devlyn-completion").exists())
+        self.assertFalse(target.exists())
+        self.assertFalse(target.parent.exists())
+        self.assertEqual(self.g("branch", "--list", "task/new"), "")
+        self.assertEqual(self.g("worktree", "list", "--porcelain"), before)
+
+    def test_disk_gate_refuses_when_no_ancestor_exists(self):
+        # Prediction: even if the filesystem root is absent, the walk stops before disk usage or artifact creation.
+        from unittest.mock import patch
+        target = self.root / "absent" / "new"
+        exists = Path.exists
+        with patch.object(Path, "exists", lambda path: False if path == target or path in target.parents else exists(path)), \
+                patch.object(shutil, "disk_usage") as usage:
+            with self.assertRaisesRegex(CompletionError, f"no existing ancestor of {re.escape(str(target))} to measure free space"):
+                allocate(self.allocation_args("new", target))
+        usage.assert_not_called()
+        self.assertFalse(target.parent.exists())
+        self.assertFalse(target.exists())
+        self.assertFalse((self.work / ".git/devlyn-completion").exists())
+        self.assertEqual(self.g("branch", "--list", "task/new"), "")
+
+    def test_disk_gate_uses_larger_floor_and_admits_boundary(self):
+        # Prediction: 100 GiB uses a 10 GiB floor; 2 TiB uses the ceiling of 2%, and exactly-at-floor allocates.
+        from unittest.mock import Mock, patch
+        for name, total in (("small", 100 * 1024**3), ("large", 2 * 1024**4)):
+            floor = max(10 * 1024**3, (total + 49) // 50)
+            with self.subTest(name=name):
+                target = self.root / name
+                with patch.dict(os.environ, self.env), patch.object(shutil, "disk_usage", return_value=Mock(total=total, free=floor - 1)):
+                    with self.assertRaisesRegex(CompletionError, r"^BLOCKED:disk"):
+                        allocate(self.allocation_args(name, target))
+                self.assertFalse(target.exists())
+                with patch.dict(os.environ, self.env), patch.object(shutil, "disk_usage", return_value=Mock(total=total, free=floor)):
+                    result = allocate(self.allocation_args(name, target))
+                self.assertEqual((result["status"], result["reconciled"]), ("ALLOCATED", []))
+                self.assertTrue(Path(result["receipt"]).exists())
+                self.assertEqual(Path(result["worktree"]), target)
+
+    def test_reconcile_precedes_refused_disk_gate(self):
+        # Prediction: an earlier MERGED remote delivery is cleaned before the new allocation fails its disk gate.
+        from unittest.mock import Mock, patch
+        self.allocate(); self.accept()
+        self.complete("--mode", "pr", "--writers-stopped")
+        self.merge_pr()
+        previous_receipt, previous_tree = self.receipt, self.task
+        target = self.root / "next"
+        with patch.dict(os.environ, self.env), patch.object(shutil, "disk_usage", return_value=Mock(total=100 * 1024**3, free=9 * 1024**3)):
+            with self.assertRaisesRegex(CompletionError, r"^BLOCKED:disk"):
+                allocate(self.allocation_args("next", target))
+        self.assertEqual(json.loads(previous_receipt.read_text(encoding="utf-8"))["status"], "COMPLETE")
+        self.assertFalse(previous_tree.exists())
+        self.assertEqual(self.g("branch", "--list", "task/fixture"), "")
+        self.assertFalse(target.exists())
+        self.assertFalse((self.work / ".git/devlyn-completion" / hashlib.sha256(b"task/next").hexdigest()[:24]).exists())
+        self.assertEqual(self.g("branch", "--list", "task/next"), "")
+
     def allocate_legacy(self):
         common = Path(self.g("rev-parse", "--absolute-git-dir"))
         key = hashlib.sha256(b"task/fixture").hexdigest()[:24]
@@ -2621,6 +2729,118 @@ ctypes.CDLL(None).pthread_exit(None)
         self.assertEqual(self.g("branch", "--list", "task/fixture"), "")
         self.assertEqual(self.g("ls-remote", "origin", "refs/heads/task/fixture"), "")
 
+    def renumber_receipt_devices(self):
+        receipt = read_json(self.receipt)
+        for key in ("worktree_identity", "scratch_identity"):
+            for entry in receipt[key]:
+                entry[0] += 10000
+        atomic_json(self.receipt, receipt)
+        return receipt
+
+    def test_device_renumbering_allows_completion(self):
+        # Prediction: old device numbers do not invalidate unchanged inodes or require receipt migration.
+        scratch = Path(self.allocate()["scratch"])
+        self.accept()
+        receipt = self.renumber_receipt_devices()
+        (scratch / "target").mkdir()
+        (scratch / "target/object").write_bytes(b"rebuildable")
+        result, _ = self.complete("--mode", "auto", "--writers-stopped")
+        self.assertEqual(result["status"], "COMPLETE")
+        self.assertEqual(result["scratch_cleanup"], {"status": "CLEAN", "logical_bytes_removed": 11})
+        self.assertFalse(self.task.exists())
+        self.assertFalse(any(scratch.iterdir()))
+        saved = read_json(self.receipt)
+        for key in ("worktree_identity", "scratch_identity"):
+            self.assertEqual(saved[key], receipt[key])
+
+    def test_device_renumbering_allows_reconcile(self):
+        # Prediction: allocation reconciles an earlier merged receipt after the same renumbering.
+        scratch = Path(self.allocate()["scratch"])
+        self.accept()
+        self.complete("--mode", "pr", "--writers-stopped")
+        self.merge_pr()
+        self.renumber_receipt_devices()
+        (scratch / "object").write_bytes(b"rebuildable")
+        receipt, task = self.receipt, self.task
+        result = self.allocate("next")
+        self.assertEqual([(row["receipt"], row["status"]) for row in result["reconciled"]], [(str(receipt), "COMPLETE")])
+        self.assertFalse(task.exists())
+        self.assertFalse(any(scratch.iterdir()))
+
+    def test_device_renumbering_rejects_replaced_directories(self):
+        # Keep each original alive so the replacement cannot accidentally reuse its inode.
+        from unittest.mock import patch
+        scratch = Path(self.allocate()["scratch"])
+        receipt = self.renumber_receipt_devices()
+        for directory in (self.task, Path(receipt["worktree_gitdir"]), scratch, self.receipt.parent):
+            with self.subTest(directory=directory):
+                original = self.root / "original"
+                directory.rename(original)
+                if directory == self.receipt.parent:
+                    directory.mkdir()
+                    (original / "scratch").rename(scratch)
+                else:
+                    shutil.copytree(original, directory)
+                try:
+                    self.assertNotEqual(directory.stat().st_ino, original.stat().st_ino)
+                    if directory == self.receipt.parent:
+                        self.assertEqual(scratch.stat().st_ino, receipt["scratch_identity"][0][1])
+                    with patch.dict(os.environ, self.env), self.assertRaisesRegex(CompletionError, "replaced"):
+                        if directory in (scratch, self.receipt.parent):
+                            clean_scratch(receipt, self.receipt, True)
+                        else:
+                            inspect_workspace(receipt)
+                    self.assertTrue(directory.is_dir())
+                finally:
+                    if directory == self.receipt.parent:
+                        scratch.rename(original / "scratch")
+                    shutil.rmtree(directory)
+                    original.rename(directory)
+
+    def test_device_renumbering_rejects_changed_filesystem_relation(self):
+        # Matching inodes alone must not accept a peer that moved to another filesystem.
+        from unittest.mock import patch
+        scratch = Path(self.allocate()["scratch"])
+        receipt = self.renumber_receipt_devices()
+        original_stat = Path.stat
+        for directory in (self.task, Path(receipt["worktree_gitdir"]), scratch, self.receipt.parent):
+            def moved_stat(path, *args, **kwargs):
+                info = original_stat(path, *args, **kwargs)
+                if path == directory:
+                    fields = list(info)
+                    fields[2] += 1
+                    return os.stat_result(fields)
+                return info
+            with self.subTest(directory=directory), patch.dict(os.environ, self.env), patch.object(Path, "stat", moved_stat):
+                with self.assertRaisesRegex(CompletionError, "replaced"):
+                    if directory in (scratch, self.receipt.parent):
+                        clean_scratch(receipt, self.receipt, True)
+                    else:
+                        inspect_workspace(receipt)
+        # Preserve distinct-device relationships too: they must not collapse into one device.
+        for key in ("worktree_identity", "scratch_identity"):
+            receipt[key][0][0] += 1
+            with self.subTest(identity=key), patch.dict(os.environ, self.env), self.assertRaisesRegex(CompletionError, "replaced"):
+                if key == "scratch_identity":
+                    clean_scratch(receipt, self.receipt, True)
+                else:
+                    inspect_workspace(receipt)
+            receipt[key][0][0] -= 1
+
+    def test_device_renumbering_preserves_different_filesystems(self):
+        self.assertTrue(same_workspace_identity([[10, 101], [20, 202]], [[-1, 101], [-2, 202]]))
+
+    def test_device_renumbering_during_scratch_cleanup_is_refused(self):
+        # Reboot tolerance is only for persisted receipts, never a change during this operation.
+        from unittest.mock import Mock, patch
+        scratch = Path(self.allocate()["scratch"])
+        receipt = self.renumber_receipt_devices()
+        identity = workspace_identity(scratch, self.receipt.parent)
+        changed = [[dev + 1, ino] for dev, ino in identity]
+        with patch.dict(clean_scratch.__globals__, {"workspace_identity": Mock(side_effect=[identity, changed])}):
+            with self.assertRaisesRegex(CompletionError, "changed before removal"):
+                clean_scratch(receipt, self.receipt, True)
+
     def test_replaced_tree_and_unsafe_custody(self):
         self.allocate(); self.accept()
         elsewhere = self.root / "elsewhere"

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

@@ -60,6 +60,8 @@ python3 "$DEVLYN_SHARED_DIR/task-complete.py" allocate --repo . \
 
 Every delivery allocation owns a linked worktree; `--worktree` is required and
 must name an absent path.
+Remote allocation first cleans earlier merged deliveries, then allocation refuses with `BLOCKED:disk`
+without creating a receipt, branch or worktree when that filesystem has less than max(10 GiB, 2%) free; free space and allocate again.
 A publication allocation normally starts at the exact fetched remote base,
 independent of the anchor's branch or dirty state, and leaves the anchor's
 HEAD, index and files untouched. For a commit request, local-only work or
@@ -123,8 +125,9 @@ after merge, so a pending, failed or local-only task keeps it.
 
 Allocation also returns a receipt-owned `scratch` directory for other
 disposable build files, such as writable tool caches. Keep source checkouts,
-Git data, lockfiles, reports and restart evidence outside scratch. Do not create unowned
-temporary build trees or preserve them by copying them into evidence custody.
+Git data, lockfiles, reports and restart evidence outside scratch.
+Direct work keeps its temporary files (logs, downloads, review outputs and build trees) outside the checkout: use scratch when allocated, otherwise the system temporary directory, and never create new top-level `.devlyn/<name>` folders for them.
+Do not preserve temporary build trees by copying them into evidence custody.
 Prefer `TemporaryDirectory`/`finally` for short-lived test fixtures.
 
 After waiting for task writers, `complete --writers-stopped` empties this

package/native/codex/plugins/devlyn/skills/_shared/warm-build-dirs.py

@@ -678,6 +678,14 @@ class WarmTests(unittest.TestCase):
         temporary = tempfile.TemporaryDirectory(prefix="warm-build-dirs-")
         self.addCleanup(temporary.cleanup)
         self.root = Path(temporary.name).resolve()
+        (self.root / "sitecustomize.py").write_text(
+            "import importlib.machinery, importlib.util, pathlib, sys\n"
+            "spec = importlib.machinery.PathFinder.find_spec('sitecustomize', [p for p in sys.path if pathlib.Path(p or '.').resolve() != pathlib.Path(__file__).resolve().parent])\n"
+            "if spec is not None and spec.loader is not None:\n"
+            "    spec.loader.exec_module(importlib.util.module_from_spec(spec))\n"
+            "import shutil\nfrom types import SimpleNamespace\n"
+            "shutil.disk_usage = lambda path: SimpleNamespace(total=100 * 1024**3, free=100 * 1024**3)\n",
+            encoding="utf-8")
         self.anchor, self.work = self.root / "anchor", self.root / "work"
         self.staging = self.root / "scratch"
         self.staging.mkdir()
@@ -689,6 +697,8 @@ class WarmTests(unittest.TestCase):
         self.environment = mock.patch.dict(os.environ, {
             "PATH": f"{bin_dir}{os.pathsep}{os.environ['PATH']}", "FAKE_CARGO": str(self.fixture),
             "FAKE_CARGO_LOG": str(self.log), "GIT_CONFIG_GLOBAL": os.devnull, "GIT_CONFIG_NOSYSTEM": "1",
+            "PYTHONPATH": str(self.root) + os.pathsep + os.environ.get("PYTHONPATH", ""),
+            "PYTHONDONTWRITEBYTECODE": "1",
             "GIT_AUTHOR_NAME": "t", "GIT_AUTHOR_EMAIL": "t@t", "GIT_COMMITTER_NAME": "t", "GIT_COMMITTER_EMAIL": "t@t"})
         self.environment.start()
         self.addCleanup(self.environment.stop)

package/native/codex/plugins/devlyn/skills/devlyn-ideate/references/loop.md

@@ -12,7 +12,7 @@ python3 "$DEVLYN_SKILL_DIR/scripts/queue.py" drain --repo . [--local-only] [--wo
 Both print one JSON object; exit 1 is `BLOCKED` with a `reason`.
 
 - `status` takes `queue.lock` in the repository's Git directory and finishes `add`'s cleanup (step 1); it reports the running `skill` root and version, any `warnings`, reconciled counts (`pending`, `active`, `accepted`, `failed`, `blocked`, `legacy_pending`), the `next` task, `blockers`, deliveries still pending with their resume (drain again until the terminal commit is attached, then the printed completion command; add `--writers-stopped` only after stopping the task's writers), and under `cleanup` the package copies `add` kept or could not remove.
-- `drain` ends `DRAINED` (no runnable task remains; open deliveries show per task), `WAITING` (a task waits with its reason, or legacy rows need planning) or `BLOCKED` (unreadable or ambiguous authoritative queue, invalid invocation, preflight refusal or held drain lock). Progress lines `devlyn-loop: <task>: <event>` go to stderr.
+- `drain` ends `DRAINED` (no runnable task remains; open deliveries show per task), `WAITING` (a task waits with its reason, or legacy rows need planning) or `BLOCKED` (unreadable or ambiguous authoritative queue, invalid invocation, preflight refusal, held drain lock or `BLOCKED:disk` allocation refusal that stops new starts and leaves its task pending). Progress lines `devlyn-loop: <task>: <event>` go to stderr.
 - `--local-only` (alias `--no-push`) keeps the loop local. A manifest `delivery: local-only` and any earlier local receipt of the loop keep that restriction for later drains. A local loop needs no remote; nothing is fetched or pushed. An `auto`/`pr` loop none of whose tasks has a pushed PR runs as a local loop from its capture and the branch it was added on. Once one has, that PR is never rewritten to local and the loop is never run locally: its tasks wait, naming the PR, while other work continues.
 - Worktrees default to `<repo parent>/<repo name>.devlyn.noindex/<loop-id>/<task-id>`; tasks already allocated under an earlier default resume where their receipts record them. On Windows, a default root newly created by the drain gets the not-content-indexed attribute, inherited by new children (content only; names stay indexed). Microsoft Defender scanning is unaffected; use a Dev Drive via `--worktree-root` or an administrator's Defender exclusion for the root.
 

package/native/codex/plugins/devlyn/skills/devlyn-ideate/scripts/queue.py

@@ -1542,11 +1542,18 @@ def drain(args):
                 except (LoopError, OSError) as exc:
                     phase = last["states"][row["identity"]].get("phase", "allocation")
                     wait = f"{phase} blocked: {exc}"
-                    if phase in {"allocation", "inputs", "acceptance", "custody binding", "terminal transition"}:
+                    disk_blocked = phase == "allocation" and str(exc).startswith("task-complete allocate: BLOCKED:disk")
+                    if disk_blocked:
+                        status, reason = "BLOCKED", str(exc)
+                    if not disk_blocked and phase in {"allocation", "inputs", "acceptance", "custody binding", "terminal transition"}:
                         wait += f"; inspect and repair {row['identity']}'s {phase} state, then drain again"
                 if wait:
                     refused[row["identity"]] = wait
-            if any(state["kind"] in {"pending", "active"} for state in last["states"].values()) or counts(last)["legacy_pending"] or refused:
+                    if status == "BLOCKED":
+                        break
+            if status == "BLOCKED" and reason and reason.startswith("task-complete allocate: BLOCKED:disk"):
+                last = view(anchor, common, args.local_only)
+            if status != "BLOCKED" and (any(state["kind"] in {"pending", "active"} for state in last["states"].values()) or counts(last)["legacy_pending"] or refused):
                 status = "WAITING"
         except (LoopError, OSError) as exc:
             status, reason = "BLOCKED", str(exc)
@@ -1799,9 +1806,19 @@ class QueueTests(unittest.TestCase):
         self.temp = tempfile.TemporaryDirectory(prefix="devlyn-queue ✓ ")
         self.addCleanup(self.temp.cleanup)
         self.root = Path(self.temp.name).resolve()
+        (self.root / "sitecustomize.py").write_text(
+            "import importlib.machinery, importlib.util, pathlib, sys\n"
+            "spec = importlib.machinery.PathFinder.find_spec('sitecustomize', [p for p in sys.path if pathlib.Path(p or '.').resolve() != pathlib.Path(__file__).resolve().parent])\n"
+            "if spec is not None and spec.loader is not None:\n"
+            "    spec.loader.exec_module(importlib.util.module_from_spec(spec))\n"
+            "import shutil\nfrom types import SimpleNamespace\n"
+            "shutil.disk_usage = lambda path: SimpleNamespace(total=100 * 1024**3, free=100 * 1024**3)\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"}
+        self.env["PYTHONPATH"] = str(self.root) + os.pathsep + self.env.get("PYTHONPATH", "")
+        self.env["PYTHONDONTWRITEBYTECODE"] = "1"
         self.anchor = self.root / "repo"
         subprocess.run(["git", "init", "-q", "--initial-branch=main", str(self.anchor)], check=True, env=self.env)
         (self.anchor / ".gitignore").write_text(".devlyn/\n", encoding="utf-8")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "devlyn-cli",
-  "version": "4.3.4",
+  "version": "4.3.6",
   "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.4",
+  "version": "4.3.6",
   "principles": {
     "defaults": "config/skills/_shared/runtime-principles.md",
     "memory": {
@@ -129,7 +129,7 @@
     },
     {
       "path": "bin/devlyn.js",
-      "sha256": "8ba08fe52c9529dee1bf13498ab3237fc25830f7f7305337fd832f32d158be7e",
+      "sha256": "6eb4d078cc4fe235517b7a08e8d6965462cd6c91ab1853cc2f8a9f0b829f6191",
       "executable": true
     },
     {
@@ -164,7 +164,7 @@
     },
     {
       "path": "bin/skill-history.json",
-      "sha256": "714337eb0686097292fb464a053a7645bc1e44b15fa7c34077fd714d0ad4739e",
+      "sha256": "c0aa4b8a25ec6873011859bc5c76cad58d1cd468e13018ea85761b8db51b81e9",
       "executable": false
     },
     {
@@ -244,17 +244,17 @@
     },
     {
       "path": "config/skills/_shared/task-complete.py",
-      "sha256": "94ea2f1434549762f88927eacf5e894a31f2e2c8e3bacb56a0d060d3970f4801",
+      "sha256": "06419e0133379880dc2e55523b8abd787b1b32023c02b8c6bb6a63a2fd8dd8c1",
       "executable": false
     },
     {
       "path": "config/skills/_shared/task-completion.md",
-      "sha256": "789d7f4fe17e9388c312c93db143a0f393a62e862e2013a3cf530aa6d0784181",
+      "sha256": "cb1601c0054fc5ad47fc8af3da27384af27af320ec1e4254fb9b08744d76d58c",
       "executable": false
     },
     {
       "path": "config/skills/_shared/warm-build-dirs.py",
-      "sha256": "99206701ff2768ca0539caa44b12eccc6b6b3754c4228b122f7d132718638315",
+      "sha256": "ee9ccbc94b614ff5ae04142bca415a4d7d6a4f569066b494ffcf3d9c612051d7",
       "executable": false
     },
     {
@@ -274,7 +274,7 @@
     },
     {
       "path": "config/skills/devlyn-ideate/references/loop.md",
-      "sha256": "ec786708d6ccb840a113e4bd0f0df82fe2d9ad8ac1641c21d786f70d2328e8b2",
+      "sha256": "1ecd5e8e53086c4b702fb1023904232aefc50405f86f792c8286255183b674cc",
       "executable": false
     },
     {
@@ -294,7 +294,7 @@
     },
     {
       "path": "config/skills/devlyn-ideate/scripts/queue.py",
-      "sha256": "7eb9f2c1bc42ae3635de4f83d2284512f1a0a74f33731f9829fcdec12aa56a9a",
+      "sha256": "a170b4f23f02707a05356f31b184cc15978cbc75faf332b4d3e0eeee3073503d",
       "executable": false
     },
     {
@@ -309,7 +309,7 @@
     },
     {
       "path": "native/claude/.claude-plugin/plugin.json",
-      "sha256": "c5925d81d5a6d26b54271f6d85b4856dfccd2333dfbe5c8bf3e7c60a288a25fd",
+      "sha256": "4ca0474d48fdbee91769be02bd6a0b612313a390b0b0fe244679df0a43bc2e37",
       "executable": false
     },
     {
@@ -384,17 +384,17 @@
     },
     {
       "path": "native/claude/skills/_shared/task-complete.py",
-      "sha256": "94ea2f1434549762f88927eacf5e894a31f2e2c8e3bacb56a0d060d3970f4801",
+      "sha256": "06419e0133379880dc2e55523b8abd787b1b32023c02b8c6bb6a63a2fd8dd8c1",
       "executable": false
     },
     {
       "path": "native/claude/skills/_shared/task-completion.md",
-      "sha256": "789d7f4fe17e9388c312c93db143a0f393a62e862e2013a3cf530aa6d0784181",
+      "sha256": "cb1601c0054fc5ad47fc8af3da27384af27af320ec1e4254fb9b08744d76d58c",
       "executable": false
     },
     {
       "path": "native/claude/skills/_shared/warm-build-dirs.py",
-      "sha256": "99206701ff2768ca0539caa44b12eccc6b6b3754c4228b122f7d132718638315",
+      "sha256": "ee9ccbc94b614ff5ae04142bca415a4d7d6a4f569066b494ffcf3d9c612051d7",
       "executable": false
     },
     {
@@ -414,7 +414,7 @@
     },
     {
       "path": "native/claude/skills/devlyn-ideate/references/loop.md",
-      "sha256": "ec786708d6ccb840a113e4bd0f0df82fe2d9ad8ac1641c21d786f70d2328e8b2",
+      "sha256": "1ecd5e8e53086c4b702fb1023904232aefc50405f86f792c8286255183b674cc",
       "executable": false
     },
     {
@@ -434,17 +434,17 @@
     },
     {
       "path": "native/claude/skills/devlyn-ideate/scripts/queue.py",
-      "sha256": "7eb9f2c1bc42ae3635de4f83d2284512f1a0a74f33731f9829fcdec12aa56a9a",
+      "sha256": "a170b4f23f02707a05356f31b184cc15978cbc75faf332b4d3e0eeee3073503d",
       "executable": false
     },
     {
       "path": "native/codex/.agents/plugins/marketplace.json",
-      "sha256": "8b6d5165236fd2c0e6bdbe58b1f1b2659cf6852c268db8483f7a2e25f870002c",
+      "sha256": "f8189a7e93f4e5ff3334d8ad884fffa679a2729f10fff815d24c4f0067534c73",
       "executable": false
     },
     {
       "path": "native/codex/plugins/devlyn/.codex-plugin/plugin.json",
-      "sha256": "c5925d81d5a6d26b54271f6d85b4856dfccd2333dfbe5c8bf3e7c60a288a25fd",
+      "sha256": "4ca0474d48fdbee91769be02bd6a0b612313a390b0b0fe244679df0a43bc2e37",
       "executable": false
     },
     {
@@ -519,17 +519,17 @@
     },
     {
       "path": "native/codex/plugins/devlyn/skills/_shared/task-complete.py",
-      "sha256": "94ea2f1434549762f88927eacf5e894a31f2e2c8e3bacb56a0d060d3970f4801",
+      "sha256": "06419e0133379880dc2e55523b8abd787b1b32023c02b8c6bb6a63a2fd8dd8c1",
       "executable": false
     },
     {
       "path": "native/codex/plugins/devlyn/skills/_shared/task-completion.md",
-      "sha256": "789d7f4fe17e9388c312c93db143a0f393a62e862e2013a3cf530aa6d0784181",
+      "sha256": "cb1601c0054fc5ad47fc8af3da27384af27af320ec1e4254fb9b08744d76d58c",
       "executable": false
     },
     {
       "path": "native/codex/plugins/devlyn/skills/_shared/warm-build-dirs.py",
-      "sha256": "99206701ff2768ca0539caa44b12eccc6b6b3754c4228b122f7d132718638315",
+      "sha256": "ee9ccbc94b614ff5ae04142bca415a4d7d6a4f569066b494ffcf3d9c612051d7",
       "executable": false
     },
     {
@@ -549,7 +549,7 @@
     },
     {
       "path": "native/codex/plugins/devlyn/skills/devlyn-ideate/references/loop.md",
-      "sha256": "ec786708d6ccb840a113e4bd0f0df82fe2d9ad8ac1641c21d786f70d2328e8b2",
+      "sha256": "1ecd5e8e53086c4b702fb1023904232aefc50405f86f792c8286255183b674cc",
       "executable": false
     },
     {
@@ -569,7 +569,7 @@
     },
     {
       "path": "native/codex/plugins/devlyn/skills/devlyn-ideate/scripts/queue.py",
-      "sha256": "7eb9f2c1bc42ae3635de4f83d2284512f1a0a74f33731f9829fcdec12aa56a9a",
+      "sha256": "a170b4f23f02707a05356f31b184cc15978cbc75faf332b4d3e0eeee3073503d",
       "executable": false
     },
     {
@@ -1619,12 +1619,12 @@
     },
     {
       "path": "package.json",
-      "sha256": "c222c0658671710f90c77884f1582a860abf3e5f074ef8e5f485648ab17d6871",
+      "sha256": "4d754dc7026976c1e37d7d74b6733459fcd07b6a498bc3e8b4c4d575b02a7700",
       "executable": false
     }
   ],
   "digest": {
     "algorithm": "sha256",
-    "value": "dfb6e72ab508aa4e0a9929e812d8881c186689c37b08e6340eb40cf1865015af"
+    "value": "f4ee05e55111300285e2ec7b435934786fee40501365c8a2a2706b7ee168bc20"
   }
 }