devlyn-cli 4.2.23 → 4.2.25

package/bin/skill-history.json

@@ -23,15 +23,18 @@
       "21723943c52573124ce3c74e9090a8ae7d7c9ecdeb78fdfa52b89c45ff1b3374",
       "247904cad29c1c3ed810f848e66f982e8765e5c627ef3a18a876fd95eed9c29c",
       "24f73bd06d359296088e43ce2e7bf5178e3f69752b559639585563ec35fc33f5",
+      "2692865ee864aebedb2b385384b2a8220bc780bd92310bc1cf2f56927de1e0b8",
       "27d4da7863ed4652187f6a101da0e56b1d3d18e4565c720d5f8150ad0a193402",
       "2a4361bca0a9fadc4a8e5e4578c383171cd64c65296fe882990502250df44d53",
       "2bcac1ab5995e474c7dd46705413982876384d8b4da704126a66c10770a1a4d2",
       "2bcae17ca31adaf306d1e5d21ad0c211bbd6f57605f68168f656e078dbf524e2",
       "326a71c447fe4d98f3460eda3fc541920b7cc2205b8288743e8622d90215a49d",
       "34282740d421a65fc75dc95edf260aa0d0fc6b90472f7b4641cb80110df0a359",
+      "3429daf66b5130b3ff6e48f3015afbf7a8d7fd84d09aace462aadb3099aa3f09",
       "353b483942a62b79d1c5bf31e30060ef7ed9a67ae2d8b27450a53acb98e4e23c",
       "3554398c2be144938e4837d9b60c0976f685cfc2c0dd0451cda714fd053f3c7d",
       "35c7e6c069c847ff147f2bf4f3b67a296652c122aa91a3966457a00dd0597b78",
+      "364aa97ec4065d8b78188f40281dfa575120a8fb91089120363e532566ef0dcb",
       "37acccbdc76aee15311b5f47fd26c50b1652dbe7cbcbacfc37774841ab464028",
       "393ad728eb0906ae61110fde3820c4fce015d8f94643a2877372b74a6b6eeb02",
       "3b6193eabc83d815804533010ca7bff1f240286e7898380a5fc2adac71dcb513",
@@ -99,6 +102,7 @@
       "9162fc2fed6f4a611d299485be3a397080beb3304865ce59b95576ba7d00650e",
       "94a14a1b87df1d7297d12949a24e47a0d6c16a8fe30495ee759fcabb2e1aa398",
       "978e4210e49b42827c98cf6e40c868c87dc6e3533a2b779ca2fa05abfc16ad0f",
+      "97e7ad89c74c609b15dfbf6f9f7ac61df8b50e97e4bc318f72922e058ecffba4",
       "9815b6e6963e068872a6dbeae24068143bf92042bb035f67bafd1a224d65bcb0",
       "998343c148618b937556b58b83749c05d5aa3283280d751c118da6a542fb87f2",
       "9dd3ec225818efe0ad3726192db94ff129154e995617a9d3c150fc58ad0f9f2c",
@@ -338,9 +342,11 @@
       "9d62f726c5ac7ed8b3989c6ab3705b5c9e4b44bb70eeece0d43bd76142b9b75b",
       "a12b24d2a70917b5d4e698af5478b6cce4d09ddf021f63ab7129402867433a72",
       "a3b852c30898b572021b32721638f67d9f44cae98653da3362456a7b88208de7",
+      "a3c1de9718724e26c095af6f35baf3b7af1afc25ff33657ff3e8db066c692408",
       "a7d7d65fd5f672cb404e6069fdc42ad7077deaa80ed8500cfa8b382dab2e3e29",
       "aba66b674683935e4c28c93333896dc116ffe67e7a35fe30b3599a8be507e94e",
       "b2e4437fa981317362d03ee032e1cfd8b686316e966c6ba12ecd619a009c80a6",
+      "bdd0751eea04532c050334fda3bc5c61c6b429e485d97e0b8ebb4fae154da2c7",
       "c1b8e3ebf38e2be8972aa003e9614a782cb4f195c69d20b95a475ebf9aaaab9e",
       "c8e375aab574148542f392b093cbbf3f2e8dc623826b45e35df0a1a2c3862226",
       "ce282a55328c2d071cacc377670fbebea4da4b9a7fee81b25293fb26763f17c9",

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

@@ -186,6 +186,37 @@ def policy(receipt, override):
     return override or value or "auto"
 
 
+def ignore_task_records(work):
+    """Keep task records ignored without changing existing files or shared Git configuration."""
+    ignorecase = command(["git", "-C", str(work), "config", "--type=bool", "--get", "core.ignorecase"], ok=(0, 1)) == "true"
+    pathspec = ":(icase)" if ignorecase else ""
+
+    def ignored():
+        all_ignored = True
+        for probe in (".devlyn/acceptance.json", ".devlyn/loop/evidence"):
+            result = subprocess.run(["git", "-C", str(work), "--no-literal-pathspecs", "check-ignore", "-q", "--", probe], capture_output=True, text=True, encoding="utf-8")
+            require(result.returncode in (0, 1), f"git check-ignore {probe}: {result.stderr.strip()}")
+            if result.returncode == 1:
+                all_ignored = False
+        return all_ignored
+
+    directory = work / ".devlyn"
+    require(not directory.is_symlink() and (not directory.exists() or directory.is_dir())
+            and all((path.casefold() if ignorecase else path) != ".devlyn"
+                    for path in git(work, "--no-literal-pathspecs", "ls-files", "--", pathspec + ".devlyn").splitlines()),
+            f"{directory} is not a real directory; move it out of .devlyn in the starting commit before allocating")
+    if ignored():
+        return
+    rule = directory / ".gitignore"
+    require(not os.path.lexists(rule) and not git(work, "--no-literal-pathspecs", "ls-files", "--", pathspec + ".devlyn/.gitignore"),
+            f"{rule} already exists or is tracked; make it ignore acceptance.json and loop/evidence in the starting commit before allocating")
+    directory.mkdir(exist_ok=True)
+    with rule.open("x", encoding="utf-8") as stream:
+        stream.write("*\n")
+    require(ignored() and not git(work, "--no-literal-pathspecs", "status", "--porcelain", "--untracked-files=all", "--", ".devlyn"),
+            f"{directory} records are not ignored or .devlyn is dirty; repair the starting commit's .devlyn paths and ignore rules before allocating")
+
+
 def allocate(args, *, exclude_receipts=()):
     """Reconcile older tasks, except receipts the queue has identified as invalid."""
     work = Path(git(Path(args.repo).resolve(), "rev-parse", "--show-toplevel")).resolve()
@@ -225,11 +256,20 @@ def allocate(args, *, exclude_receipts=()):
     # stays visibly incomplete; a later call may not adopt whatever now exists.
     atomic_json(path, receipt)
     gref(receipt, "worktree", "add", "-b", args.branch, str(target), receipt["baseline"])
+    try:
+        ignore_task_records(target)
+    except CompletionError as exc:
+        raise CompletionError(f"{exc}; remove worktree {target} and branch {args.branch}, delete receipt directory {directory}, then allocate again") from exc
     receipt["worktree_gitdir"] = git(target, "rev-parse", "--absolute-git-dir")
     receipt["worktree_identity"] = workspace_identity(target, Path(receipt["worktree_gitdir"]))
     receipt["allocation"] = "owned"
     atomic_json(path, receipt)
+    # Owned first: an interrupted warm-up leaves a usable allocation whose build starts cold.
+    with locked_receipt(path) as owned:
+        owned["build_dirs"] = shared("warm-build-dirs")["warm"](target, work, scratch)
+        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)}
 
 
@@ -1106,6 +1146,201 @@ class CompletionTests(unittest.TestCase):
                 self.g("status", "--porcelain", "--untracked-files=all", work=work), (work / "product").read_bytes(),
                 (Path(self.g("rev-parse", "--absolute-git-dir", work=work)) / "index").read_bytes())
 
+    def test_unignored_base_delivers_only_product_and_preserves_records(self):
+        # Prediction: with the ignore rule only in the anchor's dirty .gitignore, remote, --start, --local-base
+        # and --from-receipt allocations complete in their requested modes; only product is delivered, evidence
+        # survives custody/cleanup, and the anchor's .gitignore, info/exclude and HEAD remain byte-identical.
+        ignore = self.work / ".gitignore"
+        ignore.write_text("ignored/\nnode_modules/\n.env\n", encoding="utf-8")
+        self.g("commit", "-am", "base without .devlyn ignore")
+        self.g("push", "origin", "main")
+        base = self.g("rev-parse", "HEAD")
+        ignore.write_text(ignore.read_text(encoding="utf-8") + ".devlyn/\n", encoding="utf-8")
+        exclude = self.work / ".git/info/exclude"
+        anchor = (ignore.read_bytes(), exclude.read_bytes(), self.anchor_state())
+        predecessor = None
+        for route, status in (("remote", "COMPLETE"), ("start", "PR"), ("local_base", "LOCAL_ONLY"),
+                              ("from_receipt", "LOCAL_ONLY")):
+            with self.subTest(route=route):
+                source = {} if route == "remote" else {route: predecessor if route == "from_receipt" else base}
+                self.allocate_local(route, **source)
+                baseline = json.loads(self.receipt.read_text(encoding="utf-8"))["baseline"]
+                (self.task / "product").write_text(route + "\n", encoding="utf-8")
+                self.g("add", "product", work=self.task)
+                self.g("commit", "-m", "scoped product", work=self.task)
+                self.sha = self.g("rev-parse", "HEAD", work=self.task)
+                evidence = self.task / ".devlyn/loop/evidence/check.txt"
+                evidence.parent.mkdir(parents=True, exist_ok=True)
+                evidence.write_text("actual fixture check: " + route + "\n", encoding="utf-8")
+                self.assertEqual((self.task / "product").read_text(encoding="utf-8"), route + "\n")
+                self.acceptance = self.task / ".devlyn/acceptance.json"
+                self.acceptance.write_text(json.dumps({"kind": "direct", "task": route, "source_sha": self.sha,
+                    "checks": [{"command": "fixture byte assertion", "evidence": ".devlyn/loop/evidence/check.txt"}]}), encoding="utf-8")
+                records = snapshot_files(self.task, [".devlyn"])
+                flags = ["--mode", "auto" if route == "remote" else "pr"] if route in {"remote", "start"} else ["--local-only"]
+                result, _ = self.complete("--writers-stopped", *flags)
+                self.assertEqual(result["status"], status)
+                self.assertEqual(self.g("diff", "--name-only", baseline, self.sha), "product")
+                self.assertEqual(self.g("ls-tree", "-r", "--name-only", self.sha, "--", ".devlyn"), "")
+                verify_files(self.receipt.parent / "custody", {p: v for p, v in records.items() if Path(p) != Path(".devlyn/.gitignore")})
+                if route == "remote":
+                    self.assertFalse(self.task.exists())
+                    verify_files(self.receipt.parent / "records", records)
+                    self.assertEqual(self.run_cmd(["git", "--git-dir", str(self.bare), "diff", "--name-only", base, "main"]).stdout.strip(), "product")
+                elif route == "start":
+                    self.assertEqual(self.run_cmd(["git", "--git-dir", str(self.bare), "rev-parse", "refs/heads/task/start"]).stdout.strip(), self.sha)
+                self.assertEqual((ignore.read_bytes(), exclude.read_bytes(), self.anchor_state()), anchor)
+                predecessor = self.receipt
+
+    def test_ignored_base_needs_no_task_ignore_file(self):
+        # Prediction: a base that already ignores both record paths creates no .devlyn directory or ignore file.
+        self.allocate()
+        self.assertFalse((self.task / ".devlyn").exists())
+        self.assertEqual(self.g("status", "--porcelain", "--untracked-files=all", work=self.task), "")
+
+    @unittest.skipIf(os.name == "nt", "the dirty checkout uses a POSIX shell hook")
+    def test_ignored_base_with_unrelated_checkout_dirt_is_owned(self):
+        # Prediction: an already-ignoring base reaches owned despite unrelated checkout-hook dirt,
+        # without creating .devlyn/.gitignore; round 0 refuses it because it checks the whole tree.
+        hook = self.work / ".git/hooks/post-checkout"
+        hook.write_text("#!/bin/sh\nprintf 'checkout dirt\\n' > unrelated\n", encoding="utf-8")
+        hook.chmod(0o755)
+        result = self.allocate()
+        self.assertEqual(result["status"], "ALLOCATED")
+        self.assertEqual(json.loads(self.receipt.read_text(encoding="utf-8"))["allocation"], "owned")
+        self.assertFalse((self.task / ".devlyn/.gitignore").exists())
+        self.assertEqual(self.g("status", "--porcelain", "--untracked-files=all", work=self.task), "?? unrelated")
+
+    def test_allocation_refuses_existing_devlyn_paths(self):
+        # Prediction: a tracked .devlyn file, symlink, submodule or non-covering .gitignore is refused with a named
+        # repair, remains untouched, and never becomes an owned allocation.
+        base = self.g("rev-parse", "HEAD")
+        for kind in ("file", "symlink", "ignore", "submodule"):
+            with self.subTest(kind=kind):
+                self.g("reset", "--hard", base)
+                (self.work / ".gitignore").write_text("ignored/\n", encoding="utf-8")
+                path = self.work / ".devlyn"
+                if kind == "submodule":
+                    self.g("update-index", "--add", "--cacheinfo", f"160000,{base},.devlyn")
+                    path.mkdir()
+                else:
+                    if kind == "file":
+                        path.write_text("owned file\n", encoding="utf-8")
+                    elif kind == "symlink":
+                        path.symlink_to("product")
+                    else:
+                        path.mkdir()
+                        (path / ".gitignore").write_text("unrelated\n", encoding="utf-8")
+                    self.g("add", ".devlyn")
+                self.g("commit", "-am", "existing .devlyn " + kind)
+                start = self.g("rev-parse", "HEAD")
+                tree = self.root / kind
+                result, run = self.cli("allocate", "--repo", self.work, "--task", kind, "--branch", "task/" + kind,
+                                       "--worktree", tree, "--local-base", start, success=False)
+                self.assertNotEqual(run.returncode, 0)
+                self.assertEqual(result["status"], "BLOCKED")
+                self.assertIn(str(tree / ".devlyn"), result["reason"])
+                self.assertIn("starting commit", result["reason"])
+                self.assertEqual(self.g("status", "--porcelain", "--untracked-files=all", work=tree), "")
+                if kind == "ignore":
+                    self.assertEqual((tree / ".devlyn/.gitignore").read_text(encoding="utf-8"), "unrelated\n")
+                receipt = self.work / ".git/devlyn-completion" / hashlib.sha256(("task/" + kind).encode()).hexdigest()[:24] / "receipt.json"
+                self.assertEqual(json.loads(receipt.read_text(encoding="utf-8"))["allocation"], "allocating")
+                self.assertIn(f"remove worktree {tree} and branch task/{kind}, delete receipt directory {receipt.parent}, then allocate again", result["reason"])
+
+    def test_sparse_allocation_refuses_hidden_tracked_devlyn_paths(self):
+        # Prediction: sparse checkout hiding a tracked .devlyn file/symlink or .devlyn/.gitignore (including a case
+        # alias with core.ignorecase=true) refuses allocation before creating either path; contents/index stay unchanged.
+        base = self.g("rev-parse", "HEAD")
+        ignorecase = self.run_cmd(["git", "-C", str(self.work), "config", "--local", "--get", "core.ignorecase"], success=False)
+        self.assertIn(ignorecase.returncode, (0, 1))
+        for kind in ("file", "symlink", "ignore", "ignore_alias"):
+            with self.subTest(kind=kind):
+                self.g("reset", "--hard", base)
+                (self.work / ".gitignore").write_text("ignored/\n", encoding="utf-8")
+                path = self.work / ".devlyn"
+                if kind == "file":
+                    path.write_text("owned file\n", encoding="utf-8")
+                elif kind == "symlink":
+                    path.symlink_to("product")
+                else:
+                    path.mkdir()
+                    (path / (".GITIGNORE" if kind == "ignore_alias" else ".gitignore")).write_text("unrelated\n", encoding="utf-8")
+                self.g("add", "-f", ".devlyn")
+                self.g("commit", "-am", "tracked .devlyn " + kind)
+                start = self.g("rev-parse", "HEAD")
+                self.g("sparse-checkout", "init", "--no-cone")
+                try:
+                    if kind == "ignore_alias":
+                        self.g("config", "core.ignorecase", "true")
+                    self.g("sparse-checkout", "set", "/product")
+                    self.assertFalse(os.path.lexists(path))
+                    tree = self.root / kind
+                    result, run = self.cli("allocate", "--repo", self.work, "--task", kind, "--branch", "task/" + kind,
+                                           "--worktree", tree, "--local-base", start, success=False)
+                    self.assertNotEqual(run.returncode, 0)
+                    self.assertEqual(result["status"], "BLOCKED")
+                    self.assertIn(str(tree / ".devlyn"), result["reason"])
+                    receipt_dir = self.work / ".git/devlyn-completion" / hashlib.sha256(("task/" + kind).encode()).hexdigest()[:24]
+                    self.assertIn(f"remove worktree {tree} and branch task/{kind}, delete receipt directory {receipt_dir}, then allocate again", result["reason"])
+                    self.assertFalse(os.path.lexists(tree / ".devlyn"))
+                    self.assertEqual(self.g("status", "--porcelain", "--untracked-files=all", work=tree), "")
+                    self.assertEqual(self.g("write-tree", work=tree), self.g("rev-parse", start + "^{tree}"))
+                finally:
+                    self.g("sparse-checkout", "disable")
+                    if kind == "ignore_alias":
+                        if ignorecase.returncode == 0:
+                            self.g("config", "core.ignorecase", ignorecase.stdout.strip())
+                        else:
+                            self.g("config", "--unset", "core.ignorecase")
+
+    def test_case_sensitive_allocation_allows_distinct_devlyn_paths(self):
+        # Prediction: with core.ignorecase=false, tracked .DEVLYN and .devlyn/.GITIGNORE are distinct from the
+        # record paths: both allocate as owned, preserve the tracked file, and gain an ignored .devlyn/.gitignore.
+        # Round 1 refuses both because its index guards always ignore case.
+        with tempfile.TemporaryDirectory(dir=self.root) as scratch:
+            probe = Path(scratch)
+            (probe / ".DEVLYN").write_text("probe\n", encoding="utf-8")
+            if (probe / ".devlyn").exists():
+                self.skipTest("distinct .DEVLYN/.devlyn paths require a case-sensitive filesystem")
+            (probe / ".GITIGNORE").write_text("probe\n", encoding="utf-8")
+            if (probe / ".gitignore").exists():
+                self.skipTest("distinct .GITIGNORE/.gitignore paths require a case-sensitive filesystem")
+        self.g("config", "core.ignorecase", "false")
+        base = self.g("rev-parse", "HEAD")
+        for kind, relative in (("file_alias", ".DEVLYN"), ("ignore_alias", ".devlyn/.GITIGNORE")):
+            with self.subTest(kind=kind):
+                self.g("reset", "--hard", base)
+                (self.work / ".gitignore").write_text("ignored/\n", encoding="utf-8")
+                path = self.work / relative
+                path.parent.mkdir(exist_ok=True)
+                path.write_text("tracked alias\n", encoding="utf-8")
+                self.g("add", "-f", relative)
+                self.g("commit", "-am", "distinct .devlyn " + kind)
+                result = self.allocate_local(kind, local_base=self.g("rev-parse", "HEAD"))
+                self.assertEqual(result["status"], "ALLOCATED")
+                self.assertEqual(json.loads(self.receipt.read_text(encoding="utf-8"))["allocation"], "owned")
+                self.assertEqual((self.task / relative).read_text(encoding="utf-8"), "tracked alias\n")
+                self.assertEqual((self.task / ".devlyn/.gitignore").read_text(encoding="utf-8"), "*\n")
+                for record in (".devlyn/acceptance.json", ".devlyn/loop/evidence"):
+                    self.g("check-ignore", "-q", "--", record, work=self.task)
+                self.assertEqual(self.g("status", "--porcelain", "--untracked-files=all", work=self.task), "")
+
+    def test_allocation_with_literal_pathspecs_ignores_records(self):
+        # Prediction: GIT_LITERAL_PATHSPECS=1 still allows an unignored base to allocate as owned and ignore records,
+        # including with core.ignorecase=true; round 1 fails at check-ignore with exit 128.
+        (self.work / ".gitignore").write_text("ignored/\n", encoding="utf-8")
+        self.g("commit", "-am", "base without .devlyn ignore")
+        self.g("config", "core.ignorecase", "true")
+        self.env["GIT_LITERAL_PATHSPECS"] = "1"
+        result = self.allocate_local("literal", local_base=self.g("rev-parse", "HEAD"))
+        self.assertEqual(result["status"], "ALLOCATED")
+        self.assertEqual(json.loads(self.receipt.read_text(encoding="utf-8"))["allocation"], "owned")
+        self.assertEqual((self.task / ".devlyn/.gitignore").read_text(encoding="utf-8"), "*\n")
+        for record in (".devlyn/acceptance.json", ".devlyn/loop/evidence"):
+            self.g("--no-literal-pathspecs", "check-ignore", "-q", "--", record, work=self.task)
+        self.assertEqual(self.g("status", "--porcelain", "--untracked-files=all", work=self.task), "")
+
     def test_allocate_base_with_same_named_tag(self):
         self.g("tag", "main")
         result = self.allocate()

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

@@ -106,10 +106,21 @@ require the affected checks again.
 Keep the original edits through pending or failed delivery; only reconciliation
 removes them. Preserve all other work and report anything left behind.
 
-Allocation also returns a receipt-owned `scratch` directory. Put disposable
-build intermediates there (for example, set
-`CARGO_TARGET_DIR` to `<scratch>/target`). Keep source checkouts, Git data,
-lockfiles, reports and restart evidence outside scratch. Do not create unowned
+Build in the task worktree's own default build directory, never in one
+another checkout builds in, even one build at a time: tools such as Cargo take
+one checkout's outputs as fresh for the other. When a Cargo workspace's
+Cargo.toml sets `[workspace.metadata.devlyn] warm-build-dirs = true`,
+allocation seeds that directory from a built checkout of the repository, so
+the first build does not rebuild every dependency; `build_dirs` in its result
+and receipt says what it did, and a skip means an ordinary cold build. The
+opt-in is the workspace's: seeding keeps dependency outputs that may hold the
+other checkout's paths, and those follow that checkout's later rebuilds. `warm-build-dirs.py <worktree>` does the same for a
+worktree made without allocation. A warmed directory leaves with the worktree
+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.
 Prefer `TemporaryDirectory`/`finally` for short-lived test fixtures.
 
@@ -139,7 +150,7 @@ inputs when needed; cleanup is not an instruction to restart parked work.
 In the allocated worktree, finish the candidate's decisive checks and diff
 review, then stage and commit only accepted task changes. The helper never
 stages product files. Write a
-root acceptance file in the checkout (usually ignored `.devlyn/acceptance.json`):
+root acceptance file in the task worktree (`.devlyn/acceptance.json`):
 
 ```json
 {"kind":"direct","task":"<task identity>","source_sha":"<full commit>","checks":[{"command":"<actual check>","evidence":".devlyn/checks.log"}]}