devlyn-cli 4.2.2 → 4.2.4

package/bin/instructions.js

@@ -183,6 +183,12 @@ function retainFile(file, bytes) {
 // `withBlock` false removes the devlyn defaults the file holds, keeping everything else. `write` false writes nothing
 // and returns whether the file needs an update, a merge included.
 function updateInstructions(name, initial = '', withBlock = true, write = true) {
+  const projectPackage = path.join(process.cwd(), 'package.json');
+  if (fs.existsSync(path.join(process.cwd(), 'bin', 'devlyn.js')) && fs.existsSync(projectPackage)
+      && JSON.parse(fs.readFileSync(projectPackage, 'utf8'))?.name === 'devlyn-cli') {
+    console.log(`  → Skipping ${name}; shipped instruction template in devlyn-cli source checkout`);
+    return false;
+  }
   const templatePath = path.join(__dirname, '..', name);
   const template = fs.readFileSync(templatePath, 'utf8');
   if (template.includes(BEGIN) || template.includes(END)) {

package/bin/skill-history.json

@@ -1,9 +1,10 @@
 {
-  "source": "devlyn-cli@4.1.0 (npm tarball sha1 398ff07d3d689b56cc22e18ac50260bc6e4e9e85); devlyn-cli@4.2.0 (npm tarball sha1 c93c2fb1cf5630b18d2eba0085182c14fddbe2d5); whole-tree fingerprints from bin/skill-ownership.js; deprecated commands: commands/ and optional-commands/*/ files of devlyn-cli 0.0.1-0.5.8 (every published version that shipped them), LF-normalized SHA-256",
+  "source": "devlyn-cli@4.1.0 (npm tarball sha1 398ff07d3d689b56cc22e18ac50260bc6e4e9e85); devlyn-cli@4.2.0 (npm tarball sha1 c93c2fb1cf5630b18d2eba0085182c14fddbe2d5); devlyn-cli@4.2.4 (_shared and devlyn-ideate, fingerprinted from an install of its packed tarball); whole-tree fingerprints from bin/skill-ownership.js; deprecated commands: commands/ and optional-commands/*/ files of devlyn-cli 0.0.1-0.5.8 (every published version that shipped them), LF-normalized SHA-256",
   "skills": {
     "_shared": [
       "eb3327d5e6940bd5e0459fa28c9ab323d9c58ccfdeb9426c19cd027cc4e5c4ed",
-      "8c80926ab03b2477e52264495b35c2116f65fc51b02e8c56e441b5705872392a"
+      "8c80926ab03b2477e52264495b35c2116f65fc51b02e8c56e441b5705872392a",
+      "3c81c575cc43d70488865b440204cb399091405d9b7f81dbf047a32d3d5ac045"
     ],
     "devlyn-design-ui": [
       "91080266232fb62b6f1d45932184f065589e12eb66f02fb6442527c6dfcd81b6"
@@ -14,7 +15,8 @@
     ],
     "devlyn-ideate": [
       "8ff5148cc65b4608c35b29afd6fef20d42d8da93a094144d98cfc63e74089b6e",
-      "5824f07e455fe1c3942bf595a12e935258d4c0a851ca1bf741db915603d1c4e0"
+      "5824f07e455fe1c3942bf595a12e935258d4c0a851ca1bf741db915603d1c4e0",
+      "7f451e48e391643b34f6249244bc47d93d6303875e7b092771e3af0718343bc1"
     ],
     "devlyn-queue": [
       "4c7d988dcd154c7bf658d2d24cd7868955df9d854ed87eb784742d6d4bb229e0"

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

@@ -22,6 +22,7 @@ import subprocess
 import sys
 import tempfile
 import unittest
+import uuid
 
 
 class CompletionError(Exception):
@@ -122,21 +123,22 @@ def verify_files(root, files):
 
 
 def custody(work, destination, files):
-    destination.mkdir(exist_ok=True)
-    for relative, expected in files.items():
-        source = safe_path(work, relative)
-        target = safe_path(destination, relative)
-        target.parent.mkdir(parents=True, exist_ok=True)
-        if not target.exists():
-            # Interrupted partial copies are diagnosed, never silently overwritten.
+    # Publish only a complete copy. A hard crash's private staging directory is never reused.
+    with tempfile.TemporaryDirectory(prefix=".custody-", dir=destination.parent) as temporary:
+        root = Path(temporary)
+        for relative, expected in files.items():
+            source = safe_path(work, relative)
+            target = safe_path(root, relative)
+            target.parent.mkdir(parents=True, exist_ok=True)
             with source.open("rb") as incoming, target.open("xb") as outgoing:
                 shutil.copyfileobj(incoming, outgoing)
                 outgoing.flush()
                 os.fsync(outgoing.fileno())
             target.chmod(expected["mode"])
-        require(file_record(target) == expected, f"custody copy mismatch; retain original: {relative}")
-    verify_files(work, files)
-    verify_files(destination, files)
+            require(file_record(target) == expected, f"custody copy mismatch; retain original: {relative}")
+        verify_files(work, files)
+        verify_files(root, files)
+        root.rename(destination)
     atomic_json(destination.parent / "manifest.json", files)
 
 
@@ -309,7 +311,12 @@ def bind_acceptance(receipt, path, supplied):
     else:
         raise CompletionError("acceptance kind must be direct|loop")
     files = snapshot_files(work, paths)
-    custody(work, path.parent / "custody", files)
+    destination = safe_path(path.parent, "custody")
+    if destination.exists():
+        # An unbound copy is never authoritative; retain it like an orphan staging directory.
+        require(destination.is_dir(), "custody is not a directory; retain and inspect")
+        destination.rename(path.parent / (".custody-" + uuid.uuid4().hex))
+    custody(work, destination, files)
     recovery = ref_sha(receipt, receipt["recovery_ref"])
     require(recovery in {None, sha}, "recovery ref changed")
     if recovery is None:
@@ -1793,21 +1800,37 @@ class CompletionTests(unittest.TestCase):
 
     def test_custody_failure_and_evidence_tamper(self):
         self.allocate(); self.accept()
+        self.cli("accept", "--receipt", self.receipt, "--acceptance", self.acceptance)
         bad = self.receipt.parent / "custody/.devlyn/checks.txt"
-        bad.parent.mkdir(parents=True)
-        bad.write_text("partial interrupted copy", encoding="utf-8")
+        bad.write_text("corrupted bound copy", encoding="utf-8")
         _, r = self.complete("--writers-stopped", success=False)
         self.assertNotEqual(r.returncode, 0)
         self.assertTrue(self.task.exists())
         self.assertEqual((self.task / ".devlyn/checks.txt").read_text(encoding="utf-8"), "actual fixture check: accepted bytes\n")
         self.assertEqual(self.g("ls-remote", "origin", "refs/heads/task/fixture"), "")
-        bad.unlink()  # Owner repairs only the identified corrupt fixture copy.
+        shutil.copy2(self.task / ".devlyn/checks.txt", bad)  # Repair only the identified corrupt fixture copy.
         self.complete("--mode", "pr")
         (self.task / ".devlyn/checks.txt").write_text("altered after acceptance", encoding="utf-8")
         _, r = self.complete("--mode", "auto", success=False)
         self.assertNotEqual(r.returncode, 0)
         self.assertEqual(json.loads(self.data.read_text(encoding="utf-8")).get("merges",0), 0)
 
+    def test_unbound_partial_custody_is_retained_through_cleanup(self):
+        self.allocate(); self.accept()
+        partial = self.receipt.parent / "custody/.devlyn/checks.txt"
+        partial.parent.mkdir(parents=True)
+        partial.write_text("partial interrupted copy", encoding="utf-8")
+        original = file_record(partial)
+        result, _ = self.complete("--writers-stopped", "--mode", "auto")
+        self.assertEqual(result["status"], "COMPLETE")
+        self.assertEqual(result["scratch_cleanup"]["status"], "CLEAN")
+        self.assertFalse(self.task.exists())
+        retained = list(self.receipt.parent.glob(".custody-*"))
+        self.assertEqual(len(retained), 1)
+        self.assertEqual(file_record(retained[0] / ".devlyn/checks.txt"), original)
+        self.assertEqual(self.complete(acceptance=False)[0]["status"], "COMPLETE")
+        self.assertEqual(file_record(retained[0] / ".devlyn/checks.txt"), original)
+
     def test_actual_foreign_writer_and_registration(self):
         # H4. Prediction: a process still using the merged task's tree settles the delivery COMPLETE with the workspace
         # retained (CLEANUP_PENDING) and the process named, as unobservable writers do. Before: complete ended BLOCKED

package/config/skills/devlyn-ideate/references/loop.md

@@ -41,6 +41,7 @@ The host supplies the executor and maps its configured engine to the argv; the l
     | Inputs commit | A branch head equal to the expected inputs tree is adopted; anything else blocks. |
     | During execution | Each attempt's start is recorded before its spawn and its exit after it. A start without an exit waits until task-complete observes no process using the worktree, then adopts the submission that executor wrote or runs the executor again; where writers cannot be observed (native Windows) the task becomes `[F] interrupted-unobservable` with its workspace retained, its dependents become prerequisite-blocked and independent work continues. Exactly-once execution is not promised. |
     | During checks | Acceptance reruns; incomplete evidence stays unreferenced. |
+    | During custody binding | Acceptance reruns while the receipt is unbound. Any unbound custody copy, complete or partial, is set aside in a unique hidden sibling before fresh custody is published; it and orphan staging copies stay retained and unreferenced. A bound receipt resumes its original result with strict evidence validation. |
     | Accepted, before terminal commit | Only the missing transition is created. |
     | Terminal committed, before attachment | The commit is validated and attached, also when attachment already moved the recovery ref; nothing reruns. |
     | Terminal committed, before delivery | Only the missing delivery effects run. |

package/config/skills/devlyn-ideate/scripts/queue.py

@@ -1069,6 +1069,8 @@ def advance(v, row, opts):
         except LoopError as exc:
             return f"delivery blocked: {exc}"
         progress(identity, f"delivery {result['status']}")
+        if result.get("merge_refused"):
+            return f"merge refused: {result['merge_refused']}; a person merges the PR"
     return None
 
 
@@ -1093,9 +1095,11 @@ def summary(v, row):
                     questions=[r.removeprefix("needs-review: ") for r in acceptance_record.get("reasons", []) if r.startswith("needs-review: ")],
                     worktree=receipt["worktree"] if receipt.get("worktree") and Path(receipt["worktree"]).exists() else None,
                     cleanup=f"{c['status']} — {c['reason']}; resume: {c['resume']}" if (c := receipt.get("workspace_cleanup")) else None,
-                    branch=receipt.get("branch"), recovery_ref=receipt.get("recovery_ref"),
+                    branch=receipt.get("branch") if receipt.get("branch") and ref_value(v["anchor"], "refs/heads/" + receipt["branch"]) else None,
+                    recovery_ref=receipt.get("recovery_ref"),
                     custody=str(Path(state["path"]).parent / "custody") if receipt.get("files") else None,
-                    scratch=(receipt.get("scratch_cleanup") or {}).get("status", "NOT_CLEANED"))
+                    scratch=(f"{c['status']} — {c['reason']}; resume: {c['resume']}" if (c := receipt.get("scratch_cleanup") or {}).get("reason")
+                             else c.get("status", "NOT_CLEANED")))
     return item
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "devlyn-cli",
-  "version": "4.2.2",
+  "version": "4.2.4",
   "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": {