devlyn-cli 4.2.15 → 4.2.17

package/bin/skill-history.json

@@ -58,6 +58,7 @@
       "5995fcdb203a6b98c3e7cae4fe6cc7a3fb57f06a5d32069576e58350d50eab6f",
       "59f0ecc2c1fd9620e4cac06be370e0bf9965a35c20616047445dbc42da6a1677",
       "5be2e643f96b6ce503ae8d631c67729f0c24b6c5d2b431c087161b520ccbe417",
+      "60cdd1a8b220e629bcba3a24652323d16e3e6a15ba5b07c69ef2785a9c2eca70",
       "61ec4c0435a2f0b307df8e88d81d9862c3abc1bf758648f2c18039581596659b",
       "628a40e873d156e9179fd5a6bb3da9f910b6dde0886055804a506cdf8a631aaa",
       "628ee7de57717804cb2b4f4c9357751578276f241eb3ab53fdee49ae92d57513",
@@ -337,6 +338,7 @@
       "aba66b674683935e4c28c93333896dc116ffe67e7a35fe30b3599a8be507e94e",
       "b2e4437fa981317362d03ee032e1cfd8b686316e966c6ba12ecd619a009c80a6",
       "c1b8e3ebf38e2be8972aa003e9614a782cb4f195c69d20b95a475ebf9aaaab9e",
+      "c8e375aab574148542f392b093cbbf3f2e8dc623826b45e35df0a1a2c3862226",
       "ce282a55328c2d071cacc377670fbebea4da4b9a7fee81b25293fb26763f17c9",
       "cf61a917a804503ef1e26fbb1cf498181e843a0758ec001f84edb7bcac837448",
       "d6433bf0f96dd9dd485c3623885255738654674b3e23cfcc1a2cfd24f3cda96e",

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

@@ -521,6 +521,18 @@ def raise_walk_error(error):
     raise error
 
 
+def records_manifest(root):
+    require(root == root.resolve() and root.is_dir(), f"records root must be a nonsymlink directory; repair and resume: {root}")
+    devlyn = safe_path(root, ".devlyn")
+    if not devlyn.exists():
+        return {}
+    require(devlyn.is_dir(), f".devlyn records must be a directory; repair and resume: {devlyn}")
+    paths = [str((Path(directory) / name).relative_to(root))
+             for directory, dirs, files in os.walk(devlyn, onerror=raise_walk_error)
+             for name in files + [name for name in dirs if (Path(directory) / name).is_symlink()]]
+    return snapshot_files(root, paths) if paths else {}
+
+
 def clean_scratch(receipt, path, writers_stopped):
     """Empty the owned build directory; keep its identity across resume/reuse."""
     scratch = path.parent / "scratch"
@@ -583,23 +595,20 @@ def cleanup(receipt, path, pr):
             require(receipt.get("writers_released"), "wait actual children, stop/yield known writers, then resume with --writers-stopped")
             require(work != Path(receipt["anchor"]) and work != Path(receipt["common_gitdir"]).parent, "cannot remove retained/main checkout")
             removable(receipt, work)
-            devlyn = safe_path(work, ".devlyn")
-            if devlyn.exists():
-                require(devlyn.is_dir(), ".devlyn records must be a directory; retain tree")
-                paths = [str((Path(directory) / name).relative_to(work))
-                         for directory, dirs, files in os.walk(devlyn, onerror=raise_walk_error)
-                         for name in files + [name for name in dirs if (Path(directory) / name).is_symlink()]]
-                if paths:
-                    records = snapshot_files(work, paths)
-                    destination = path.parent / "records"
-                    if not destination.exists():
-                        with tempfile.TemporaryDirectory(prefix=".records-", dir=path.parent) as temporary:
-                            shutil.copytree(devlyn, Path(temporary) / ".devlyn", symlinks=True)
-                            verify_files(Path(temporary), records)
-                            Path(temporary).rename(destination)
-                    verify_files(destination, records)
-                    verify_files(work, records)
+            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}")
             removable(receipt, work)
+            require(records_manifest(work) == records, ".devlyn changed after it was copied; stop its writer and resume")
             gref(receipt, "worktree", "remove", str(work))
         else:
             require(str(work) not in registrations(receipt), "missing worktree is still registered; retain")
@@ -1637,10 +1646,16 @@ ctypes.CDLL(None).pthread_exit(None)
         self.assertEqual(result["status"], "PR")
         self.assertTrue(json.loads(receipt.read_text())["writers_released"])
         self.merge_pr()
+        original = records_manifest(task)
+        shutil.copytree(task / ".devlyn", receipt.parent / "records/.devlyn")
+        (task / ".devlyn/storage-cleanup.json").write_bytes(b"{}\n")
+        final = records_manifest(task)
         server = json.loads(self.data.read_text())
         result = self.allocate("released")
         self.assertEqual([(row["receipt"], row["status"]) for row in result["reconciled"]], [(str(receipt), "COMPLETE")])
         self.assertFalse(task.exists())
+        self.assertEqual(records_manifest(receipt.parent / "records"), original)
+        self.assertEqual(records_manifest(next(receipt.parent.glob("records.*"))), final)
         self.assertEqual(self.g("branch", "--list", "task/fixture"), "")
         self.assertEqual(self.g("ls-remote", "origin", "refs/heads/task/fixture"), "")
         current = json.loads(self.data.read_text())
@@ -1840,16 +1855,123 @@ ctypes.CDLL(None).pthread_exit(None)
         saved = self.receipt.parent / "records/.devlyn"
         shutil.copytree(self.task / ".devlyn", saved)
         (saved / "checks.txt").write_bytes(b"tampered copy")
-        result, _ = self.complete(success=False)
-        self.assertIn("bytes/mode changed", result["reason"])
+        final = records_manifest(self.task)
+        result, _ = self.complete()
+        self.assertEqual(result["status"], "COMPLETE")
+        self.assertFalse(self.task.exists())
         self.assertEqual((saved / "checks.txt").read_bytes(), b"tampered copy")
+        self.assertEqual(records_manifest(next(self.receipt.parent.glob("records.*"))), final)
+
+    def test_records_resume_preserves_added_and_changed_files(self):
+        self.allocate(); self.accept()
+        self.complete("--mode", "pr", "--writers-stopped")
+        self.merge_pr()
+        extra = self.task / ".devlyn/extra.log"
+        extra.write_bytes(b"before\n")
+        saved = self.receipt.parent / "records"
+        shutil.copytree(self.task / ".devlyn", saved / ".devlyn")
+        original = records_manifest(saved)
+        extra.write_bytes(b"after\n")
+        extra.chmod(0o640)
+        (self.task / ".devlyn/storage-cleanup.json").write_bytes(b'{"status":"retained"}\n')
+        final = records_manifest(self.task)
+        digest = hashlib.sha256(json.dumps(final, sort_keys=True, separators=(",", ":")).encode()).hexdigest()[:12]
+        result, _ = self.complete()
+        self.assertEqual(result["status"], "COMPLETE")
+        self.assertFalse(self.task.exists())
+        self.assertEqual(records_manifest(saved), original)
+        self.assertEqual(records_manifest(self.receipt.parent / ("records." + digest)), final)
+
+    def test_records_resume_preserves_deleted_file_only_in_earlier_copy(self):
+        self.allocate(); self.accept()
+        self.complete("--mode", "pr", "--writers-stopped")
+        self.merge_pr()
+        extra = self.task / ".devlyn/extra.log"
+        extra.write_bytes(b"before\n")
+        saved = self.receipt.parent / "records"
+        shutil.copytree(self.task / ".devlyn", saved / ".devlyn")
+        original = records_manifest(saved)
+        extra.unlink()
+        final = records_manifest(self.task)
+        result, _ = self.complete()
+        self.assertEqual(result["status"], "COMPLETE")
+        self.assertFalse(self.task.exists())
+        self.assertEqual(records_manifest(saved), original)
+        generation = next(self.receipt.parent.glob("records.*"))
+        self.assertEqual(records_manifest(generation), final)
+        self.assertFalse((generation / ".devlyn/extra.log").exists())
+
+    def test_records_generation_reuse_and_mismatch(self):
+        self.allocate(); self.accept()
+        self.complete("--mode", "pr", "--writers-stopped")
+        self.merge_pr()
+        saved = self.receipt.parent / "records"
+        shutil.copytree(self.task / ".devlyn", saved / ".devlyn")
+        original = records_manifest(saved)
+        (self.task / ".devlyn/storage-cleanup.json").write_bytes(b"{}\n")
+        final = records_manifest(self.task)
+        digest = hashlib.sha256(json.dumps(final, sort_keys=True, separators=(",", ":")).encode()).hexdigest()[:12]
+        generation = self.receipt.parent / ("records." + digest)
+        shutil.copytree(self.task / ".devlyn", generation / ".devlyn")
+        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"])
         self.assertTrue(self.task.exists())
-        self.assertNotEqual(self.g("branch", "--list", "task/fixture"), "")
-        self.assertEqual(self.g("ls-remote", "origin", "refs/heads/task/fixture").split()[0], self.sha)
-        shutil.copy2(self.task / ".devlyn/checks.txt", saved / "checks.txt")
+        self.assertEqual(records_manifest(generation), mismatch)
+        self.assertEqual(records_manifest(saved), original)
+        extra.unlink()  # Owner repairs the mismatched copy before resuming.
+        identity = generation.stat()
+        result, _ = self.complete()
+        self.assertEqual(result["status"], "COMPLETE")
+        self.assertFalse(self.task.exists())
+        self.assertEqual(records_manifest(saved), original)
+        self.assertEqual(records_manifest(generation), final)
+        self.assertEqual(generation.stat(), identity)
+
+    def test_records_change_after_copy_retains_until_resume(self):
+        from unittest.mock import patch
+        self.allocate(); self.accept()
+        self.complete("--mode", "pr", "--writers-stopped")
+        self.merge_pr()
+        original = records_manifest(self.task)
+        saved = self.receipt.parent / "records"
+        check = removable
+        def changed(receipt, work):
+            check(receipt, work)
+            if saved.exists():
+                (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)
+        self.assertTrue(self.task.exists())
+        self.assertEqual(records_manifest(saved), original)
+        final = records_manifest(self.task)
         result, _ = self.complete()
         self.assertEqual(result["status"], "COMPLETE")
         self.assertFalse(self.task.exists())
+        self.assertEqual(records_manifest(saved), original)
+        self.assertEqual(records_manifest(next(self.receipt.parent.glob("records.*"))), final)
+
+    def test_records_staged_extra_file_retains_without_publishing(self):
+        from unittest.mock import patch
+        self.allocate(); self.accept()
+        self.complete("--mode", "pr", "--writers-stopped")
+        self.merge_pr()
+        copy = shutil.copytree
+        def changed(source, destination, **kwargs):
+            result = copy(source, destination, **kwargs)
+            (destination / "unexpected").write_bytes(b"late write\n")
+            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)
+        self.assertTrue(self.task.exists())
+        self.assertFalse((self.receipt.parent / "records").exists())
+        self.assertEqual(list(self.receipt.parent.glob(".records-*")), [])
 
     def test_linked_custody_and_interrupted_removal(self):
         self.allocate(); self.accept()

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

@@ -218,8 +218,10 @@ The receipt directory holds byte-verified `custody/`, `manifest.json` and a guar
 before publication; removal rechecks it, the recovery ref and the merge commit on base.
 Ignored build output and other ignored files are disposable under native
 non-force worktree removal. The tree's `.devlyn/` files are byte/mode-verified
-and preserved as `<receipt dir>/records/.devlyn`; non-regular files or symlinks
-there retain the tree. Partial/corrupt custody or records retain it for repair.
+and preserved as `<receipt dir>/records/.devlyn`; changes after an earlier copy
+are preserved beside it as `records.<digest>/.devlyn`, never rewriting earlier copies.
+Non-regular files or symlinks there, partial/corrupt custody, an unreadable
+earlier copy or a mismatched `records.<digest>` copy retain the tree for repair.
 
 Legacy in-place receipts retire refs only once their task branch is no longer
 checked out; their checkout is never modified. Local ref deletion is guarded by

package/config/skills/devlyn-ideate/SKILL.md

@@ -96,7 +96,7 @@ An absolute path to a package's `meta.md` is added as it is; anything else is pl
 
 ## status
 
-Run `python3 "$DEVLYN_SKILL_DIR/scripts/queue.py" status --repo .` and report its counts, `next`, `blockers`, pending deliveries with their resume commands and any `cleanup` entry.
+Run `python3 "$DEVLYN_SKILL_DIR/scripts/queue.py" status --repo .` and report its counts, `next`, `blockers`, `warnings`, pending deliveries with their resume commands and any `cleanup` entry.
 
 ## drain
 
@@ -125,4 +125,4 @@ A drain can run for hours. Do not end the turn until it exits: run it in the for
 - Other `WAITING`: report each task’s reason and recovery command. Task-local failures leave dependents and barrier-held siblings waiting while independent work continues; the next drain retries eligible work once. An interrupted executor is observed once per drain and cannot be adopted or respawned until it stops. `BLOCKED` means authoritative queue reconstruction or preflight failed, including a held drain lock. Never edit receipts, refs or queue rows to get past either result.
 - An interrupted drain is resumed by running `drain` again; accepted work is never replayed, and a failed task is never rerun: plan its work again as a new loop.
 
-Report each task's product result, delivery status, PR URL, resume command, assumptions and unresolved questions, plus whole-loop acceptance, the package's `## Decisions and assumptions`, the drain report paths and its exact `Bring into` command; leave running it to the user. Report every `cleanup` diagnostic, including unavailable reports and retained parents; completed products keep their verdict. A package copy left in the checkout can prevent the `Bring into` command until it is removed.
+Report each task's product result, delivery status, PR URL, resume command, assumptions and unresolved questions, plus whole-loop acceptance, the package's `## Decisions and assumptions`, the drain report paths and its exact `Bring into` command; leave running it to the user. Report every `cleanup` diagnostic, including unavailable reports and retained parents, and all `warnings`; completed products keep their verdict. A package copy left in the checkout can prevent the `Bring into` command until it is removed.

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

@@ -11,7 +11,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 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.
+- `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.
 - `--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/<loop-id>/<task-id>`.

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

@@ -112,6 +112,34 @@ def read_json(path):
         raise LoopError(f"{path}: {exc}") from exc
 
 
+def skill_diagnostics(anchor):
+    running = SKILLS / ".devlyn-install.json"
+    markers = dict.fromkeys([running, *(anchor / host / "skills/.devlyn-install.json" for host in (".claude", ".agents"))])
+    versions, errors = {}, {}
+    for marker in markers:
+        try:
+            data = json.loads(marker.read_text(encoding="utf-8"))
+            if not isinstance(data, dict) or not isinstance(data.get("version"), (str, type(None))):
+                raise ValueError("install marker must be an object with a string or null version")
+            versions[marker] = data.get("version")
+        except FileNotFoundError:
+            continue  # Global-only and source checkouts need no repository install marker.
+        except (OSError, ValueError, RecursionError) as exc:
+            errors[marker] = str(exc)
+    skill = {"root": str(SKILLS), "version": versions.get(running)}
+    warnings = []
+    for marker in markers:
+        if marker in errors:
+            detail = f"unreadable: {errors[marker]}"
+        elif running not in errors and marker in versions and versions[marker] != skill["version"]:
+            detail = f"version {json.dumps(versions[marker])}"
+        else:
+            continue
+        warnings.append(f"Running skill {skill['root']} (version {json.dumps(skill['version'])}); "
+                        f"install marker {marker} ({detail}); run npx devlyn-cli@latest update.")
+    return {"skill": skill, "warnings": warnings}
+
+
 def write_json(path, value):
     acceptance()["write_json"](path, value)
 
@@ -1314,7 +1342,7 @@ def bring_in(v, loop):
     return f"{receipt['base']}: git merge --ff {receipt['remote']}/{receipt['base']}"
 
 
-def write_reports(v, status, reason):
+def write_reports(v, status, reason, warnings):
     paths = []
     for loop in dict.fromkeys(row["loop"] for row in v["rows"] if row["identity"]):
         path = v["common"] / "devlyn-loops" / loop / "drain-report.md"
@@ -1324,6 +1352,8 @@ def write_reports(v, status, reason):
                      f"- Queue: {f'{CAPTURES}{loop}:{loop_queue(loop)}' if loop in v['records'] else v['anchor'] / loop_queue(loop)}",
                      f"- Drain: {status}" + (f" — {reason}" if reason else ""), f"- Whole-loop acceptance: {loop_acceptance(v, loop, items)}",
                      *([f"- Bring into {line}"] if (line := bring_in(v, loop)) else []), ""]
+            if warnings:
+                lines += ["## Warnings", "", *(f"- {warning}" for warning in warnings), ""]
             try:
                 meta, _ = load_manifest(v["anchor"], loop, capture(v, loop))
                 decisions = sections(
@@ -1393,6 +1423,8 @@ def prune_parents(v, root):
 
 def drain(args):
     anchor, common = repository(args.repo)
+    args.repo = anchor  # Preserve the repository root for failures reported by main.
+    diagnostics = skill_diagnostics(anchor)
     require(any("{packet}" in part for part in args.executor), "executor argv must contain {packet}, replaced by the task packet path")
     args.worktree_root = Path(args.worktree_root).resolve() if args.worktree_root else anchor.parent / f"{anchor.name}.devlyn"
     with lock(common, "drain.lock", blocking=False):
@@ -1422,20 +1454,22 @@ def drain(args):
             with contextlib.suppress(LoopError, OSError):
                 last = view(anchor, common, args.local_only)
         if last is None:
-            return {"status": status, "reason": reason}
+            return {"status": status, "reason": reason, **diagnostics}
         annotate(last, refused)
         prune_parents(last, args.worktree_root)
-        return {"status": status, "reason": reason, "reports": write_reports(last, status, reason), "counts": counts(last),
+        return {"status": status, "reason": reason, **diagnostics,
+                "reports": write_reports(last, status, reason, diagnostics["warnings"]), "counts": counts(last),
                 "tasks": [summary(last, row) for row in last["rows"] if row["identity"]], "cleanup": last["cleanup"]}
 
 
 def status(args):
     anchor, common = repository(args.repo)
+    args.repo = anchor  # Preserve the repository root for failures reported by main.
     v = view(anchor, common, args.local_only)
     row = next_task(v, set())
     annotate(v, {})
     tasks = [summary(v, r) for r in v["rows"] if r["identity"]]
-    return {"status": "OK", "counts": counts(v), "next": row["identity"] if row else None,
+    return {"status": "OK", **skill_diagnostics(anchor), "counts": counts(v), "next": row["identity"] if row else None,
             "blockers": [f"{t['identity']}: {t['reason']}" for t in tasks if t.get("reason") and t["result"] in {"pending", "active", "blocked"}]
             + [f"legacy row {r['index'] + 1} needs planning: {r['text']}" for r in v["rows"] if not r["identity"] and r["mark"] == " "]
             + [f"unreadable receipt {item}" for item in v["unreadable"]],
@@ -1997,6 +2031,8 @@ def main():
         result = {"check": check, "add": add, "status": status, "drain": drain}[args.action](args)
     except (LoopError, OSError) as exc:
         result = {"status": "BLOCKED", "reason": str(exc)}
+        if args.action in {"status", "drain"}:
+            result.update(skill_diagnostics(Path(args.repo)))
     print(json.dumps(result, ensure_ascii=False, sort_keys=True))
     return 1 if result["status"] == "BLOCKED" else 0
 

package/package.json

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