devlyn-cli 4.2.23 → 4.2.24

package/bin/skill-history.json

@@ -29,6 +29,7 @@
       "2bcae17ca31adaf306d1e5d21ad0c211bbd6f57605f68168f656e078dbf524e2",
       "326a71c447fe4d98f3460eda3fc541920b7cc2205b8288743e8622d90215a49d",
       "34282740d421a65fc75dc95edf260aa0d0fc6b90472f7b4641cb80110df0a359",
+      "3429daf66b5130b3ff6e48f3015afbf7a8d7fd84d09aace462aadb3099aa3f09",
       "353b483942a62b79d1c5bf31e30060ef7ed9a67ae2d8b27450a53acb98e4e23c",
       "3554398c2be144938e4837d9b60c0976f685cfc2c0dd0451cda714fd053f3c7d",
       "35c7e6c069c847ff147f2bf4f3b67a296652c122aa91a3966457a00dd0597b78",
@@ -338,6 +339,7 @@
       "9d62f726c5ac7ed8b3989c6ab3705b5c9e4b44bb70eeece0d43bd76142b9b75b",
       "a12b24d2a70917b5d4e698af5478b6cce4d09ddf021f63ab7129402867433a72",
       "a3b852c30898b572021b32721638f67d9f44cae98653da3362456a7b88208de7",
+      "a3c1de9718724e26c095af6f35baf3b7af1afc25ff33657ff3e8db066c692408",
       "a7d7d65fd5f672cb404e6069fdc42ad7077deaa80ed8500cfa8b382dab2e3e29",
       "aba66b674683935e4c28c93333896dc116ffe67e7a35fe30b3599a8be507e94e",
       "b2e4437fa981317362d03ee032e1cfd8b686316e966c6ba12ecd619a009c80a6",

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,6 +256,10 @@ 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"
@@ -1106,6 +1141,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

@@ -139,7 +139,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"}]}

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

@@ -24,7 +24,7 @@ The host supplies the executor and maps its configured engine to the argv; the l
 
 1. **Reconcile.** First finish `add`'s cleanup of package copies ([package-format.md](package-format.md) Commands). Then read the queue view: the legacy rows, each replaced row as its loop's rows, then each loop's rows, from its capture or, without a record, from the checkout's tracked queue file ([package-format.md](package-format.md) Queue rows); every `<common Gitdir>/devlyn-completion/*/receipt.json` and their recovery refs. A row's identity, its receipt's branch `devlyn/<loop-id>/<task-id>`, the recovery ref (equal to the receipt's `publish_sha`, or to its validated terminal commit while that attachment is unfinished), the terminal commit's mark and, while active, the committed contract digests must agree. A receipt's terminal result supplements a `[ ]` row. Receipt, recovery-ref and packet conflicts invalidate the implicated tasks with an inspection/recovery reason; a missing queued prerequisite invalidates its dependent. Invalid evidence proves neither acceptance nor a frontier. A possible writer or package carrier retains its loop’s safety barrier while independent loops continue. An occupied receipt directory without a receipt waits for verified interrupted-allocation recovery; nothing is fabricated, rewritten or deleted. An unfinished allocation makes its task wait (step 10). Unreadable authoritative queue bytes, duplicate identities, missing/malformed queue files and invalid add records block the whole drain. A captured package never changes; for a loop without a record, an active task whose contract or expected acceptance changed in the checkout, also when that text is now missing or invalid, becomes `[F] inputs-changed` without executing again, its workspace retained, other work continuing while the revision is planned as a new task, and a pending task whose package text fails validation waits with that error, as do its dependents. Unsettled receipts (active, terminal commit unattached, or delivery not final) resume before any new allocation.
 2. **Select** the earliest pending row whose prerequisites are accepted with a receipt in every mode (a hand-written `[x]` never counts) and, for `auto`/`pr`, delivered (merged). A failed or blocked prerequisite makes its dependent `[F] blocked-prerequisite:<id>` without invoking the executor; that derived mark is proven by the prerequisite's receipt and travels into later checkouts and the report. A prerequisite awaiting delivery leaves its dependent pending while independent work continues; so does an `auto`/`pr` carrier in flight (step 3), or a local loop's active task (a local loop runs one task at a time), for every other task of its loop. Legacy rows wait for `add --materialize`.
-3. **Allocate** a new owned worktree on the absent branch `devlyn/<loop-id>/<task-id>` with `task-complete.py allocate`. First, the commit the task starts from must ignore `.devlyn/` (a committed `.gitignore` entry there, or `<common Gitdir>/info/exclude`), or nothing is allocated and the task waits naming the fix while independent work continues. It must also hold this checkout's `CLAUDE.md` and `AGENTS.md` (each identical, or both absent), so the task runs under the installed instructions, and, where it holds the loop's queue file, every captured package file unchanged, so the task binds its captured contract; otherwise the task waits, naming the fix, while independent work continues.
+3. **Allocate** a new owned worktree on the absent branch `devlyn/<loop-id>/<task-id>` with `task-complete.py allocate`. The commit the task starts from must hold this checkout's `CLAUDE.md` and `AGENTS.md` (each identical, or both absent), so the task runs under the installed instructions, and, where it holds the loop's queue file, every captured package file unchanged, so the task binds its captured contract; otherwise the task waits, naming the fix, while independent work continues.
    - Local: the first task uses `--local-base <HEAD of the branch the loop was added on>`, the add record's branch, never whichever branch is checked out; that HEAD must descend from the manifest `base_sha`, or the task waits naming it. Instructions committed there before this first allocation are therefore used. Its receipt keeps that start, and a later task with no accepted predecessor reuses it, also after the first task failed; a fixed start is never recalculated. Later tasks use `--from-receipt <latest accepted receipt of the loop>`, which starts from that receipt's exact `source_sha`, never its terminal commit, current HEAD or workspace. Every prerequisite's accepted source must be an ancestor of that frontier; divergent dependencies need a planned integration task, because the driver never merges. A failure leaves the frontier unchanged.
    - `auto`/`pr`: `--start` the refreshed remote base, never an anchor-local commit, so no unpushed anchor commit reaches a task PR; push whatever the plan depends on. A task allocated while that base lacks `docs/specs/<loop-id>/` is the loop's carrier; a carrier that fails is never published, and the next task allocated becomes the carrier. The start must contain each prerequisite's merge commit, checked before allocation and again before every execution or resume. A squash merge needs no original-source ancestry. A refresh failure waits for restored remote access or the base ref. A missing merge before allocation waits for that merge to be restored on the remote base; an allocated baseline is immutable and needs a new loop or verified recovery of a never-executed allocation.
 4. **Commit scoped inputs** on the owned branch before any executor write, only what the allocation base lacks. A base without `docs/specs/<loop-id>/` gets the package directory from the capture with the loop's queue file, its settled rows keeping their marks (receipt-proven `[x]` and `[F]`, prerequisite-blocked `[F]`): a local loop's first task, or an `auto`/`pr` carrier, whose PR lands the package before tasks diverge. Otherwise a local task commits the base's queue file with the loop's receipt-proven terminal rows (typically a predecessor's `[x]`), every other byte unchanged, and an `auto`/`pr` task commits nothing, so its PR changes only its own row and its product. A base that already carries them gets no inputs commit; unrelated product commits stay out.

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

@@ -1002,17 +1002,6 @@ def instruction_drift(anchor, rev):
     return ", ".join(name for name in names if name in differ)
 
 
-def evidence_ignored(anchor, common, start):
-    """Whether a checkout of `start` ignores .devlyn/: its .gitignore files on that path, info/exclude, core.excludesFile."""
-    with tempfile.TemporaryDirectory(prefix="devlyn-loop-ignore-") as temp:
-        for rel in (".gitignore", ".devlyn/.gitignore", ".devlyn/loop/.gitignore"):
-            if (rules := show(anchor, start, rel)) is not None:
-                (Path(temp) / rel).parent.mkdir(parents=True, exist_ok=True)
-                (Path(temp) / rel).write_bytes(rules)
-        return git_run(temp, "--git-dir", str(common), "--work-tree", temp, "check-ignore", "-q", "--no-index",
-                       ".devlyn/loop/evidence", ok=(0, 1)).returncode == 0
-
-
 def allocate(v, row, opts):
     """Allocate the task's owned worktree, or return why it waits: origin names no GitHub repository, its base is not the
     default, or its refreshed remote base holds another version of the loop's package or lacks the checkout's instructions
@@ -1055,10 +1044,6 @@ def allocate(v, row, opts):
         require_merged(v, row, start)
         if drift := package_drift(v, loop, start, f"origin/{manifest['base_ref']}"):
             return drift
-    require(evidence_ignored(anchor, common, start),
-            f"{identity}: .devlyn/ is not ignored in its start commit {start}, so loop evidence would dirty task source; commit a "
-            f"`.devlyn/` entry to .gitignore in the base the task starts from (push it for remote delivery), or add `.devlyn/` to "
-            f"{common / 'info' / 'exclude'}; then drain again")
     if values["start"] and (drift := instruction_drift(anchor, start)):
         return (f"the installed instructions ({drift}) in this checkout differ from those in its start commit {start}, so it would run "
                 f"without them; commit them and push them to origin/{manifest['base_ref']}")

package/package.json

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