devlyn-cli 4.3.30 → 4.3.32

package/native/claude/skills/_shared/task-completion.md

@@ -201,14 +201,14 @@ publication mode pushes no task commit and opens no PR. Delivery is `COMPLETE` w
 `pr` pushes the exact accepted task ref and creates/reuses its exact repository,
 head and base PR. While OPEN, it cancels owned auto-merge, reports `PR` with its URL
 and retains the checkout. Once MERGED by any method, either mode cleans released
-resources in that call, on resume or at the next allocation. Default `auto` also requests
-a `--merge --match-head-commit <accepted SHA>` merge. Repository
-checks/reviews and merge policy remain authoritative: no admin bypass, strategy
+resources in that call, on resume or at the next allocation. Default `auto` also
+merges the accepted commit. Merge policy remains authoritative: no admin bypass, strategy
 fallback or repository setting changes. When the repository disallows merge
-commits or refuses the request, delivery reports `PR` with `merge_refused` and
+commits or refuses the merge, delivery reports `PR` with `merge_refused` and
 the PR waits for a person. Command success alone never proves merge.
 
-`PENDING` retains the workspace and reports a receipt-based resume command.
+`PENDING` retains the workspace; its receipt-based resume command merges once
+required checks or reviews pass, or a person merges it.
 `BLOCKED` names the cause and retry action; repair that condition before retrying.
 Resume reobserves Git/PR state under a per-receipt lock, reuses the original
 acceptance and performs only missing eligible effects.

package/native/claude/skills/_shared/warm-build-dirs.py

@@ -706,9 +706,14 @@ class WarmTests(unittest.TestCase):
         (bin_dir / "cargo").write_text(FAKE_CARGO)
         (bin_dir / "cargo").chmod(0o755)
         self.fixture, self.log = self.root / "fixture.json", self.root / "cargo.log"
+        # A commit's detached automatic maintenance would still write into .git while a test reads the tree. Appended to
+        # the inherited GIT_CONFIG_COUNT entries, which this environment keeps.
+        count = int(os.environ.get("GIT_CONFIG_COUNT") or 0)
         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",
+            "GIT_CONFIG_COUNT": str(count + 1), f"GIT_CONFIG_KEY_{count}": "maintenance.auto",
+            f"GIT_CONFIG_VALUE_{count}": "false",
             "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"})
@@ -749,6 +754,14 @@ class WarmTests(unittest.TestCase):
     def git(self, work, *args):
         return subprocess.run(["git", "-C", str(work), *args], check=True, capture_output=True, text=True).stdout
 
+    def test_fixture_commit_starts_no_automatic_maintenance(self):
+        # Its detached child would still write into .git while a test reads the tree or cleanup removes it.
+        trace = self.root / "trace.json"
+        os.environ["GIT_TRACE2_EVENT"] = str(trace)  # setUp's patch restores the environment
+        self.git(self.anchor, "commit", "-q", "--allow-empty", "-m", "traced")
+        children = [line for line in trace.read_text(encoding="utf-8").splitlines() if '"event":"child_start"' in line]
+        self.assertEqual(children, [])
+
     def write_fixture(self, **extra):
         packages = [
             {"name": "app", "source": None, "manifest_path": str(self.work / "Cargo.toml"), "targets": [{"kind": ["lib"], "name": "LIB"}]},

package/native/claude/skills/devlyn-ideate/references/executor.md

@@ -59,4 +59,4 @@ Each `review_requirements` ID needs review evidence: a JSON record under `<workt
 }
 ```
 
-A record counts only when it binds this task, the candidate source and both contract digests; any other well-formed record is reported under `ignored_reviews` (a source change invalidates earlier reviews). A listed review or runner record that is unreadable or not this shape fails acceptance with its path named; keys a review record or finding adds beyond this shape are ignored. The counted records' `requirements` must cover `review_requirements`. Each finding's `disposition` is `open`, `resolved` or `rejected` (`rejected` needs a `reason`); an open binding finding blocks acceptance. The loop requires no particular engine or number of reviewers.
+A record counts only when it binds this task, the candidate source and both contract digests; any other well-formed record is reported under `ignored_reviews` (a source change invalidates earlier reviews; the record for the changed source may come from a pass that reads only the change and the invariants it touches). A listed review or runner record that is unreadable or not this shape fails acceptance with its path named; keys a review record or finding adds beyond this shape are ignored. The counted records' `requirements` must cover `review_requirements`. Each finding's `disposition` is `open`, `resolved` or `rejected` (`rejected` needs a `reason`); an open binding finding blocks acceptance. The loop requires no particular engine or number of reviewers.

package/native/claude/skills/devlyn-ideate/references/loop.md

@@ -32,7 +32,7 @@ The host supplies the executor and maps its configured engine to the argv; the l
 6. **Derive acceptance** with `acceptance.py accept`. It binds the committed contract to the packet digests; requires the candidate to be the owned branch head with HEAD checked out on that branch, to descend from the inputs, to leave the package (its queue file included) and `docs/specs/queue.md` untouched and to have a clean worktree; executes each declared command on that source, recording raw stdout/stderr and exit, timeout or spawn outcomes (a runner result is reused only when it is wholly clean — no reasons, so no failed check and no source change during its checks — for the same source and contract digests, with unchanged streams); evaluates the file and diff guards against the inputs; confirms the source is unchanged; checks review records; and writes `.devlyn/loop/acceptance.json`. Missing checks, missing review coverage and open binding findings cannot produce `[x]`, and acceptance weakening is not repair. This establishes command outcomes and evidence completeness, not a reviewer's semantic judgment; deliberate evidence forgery is outside the trust model.
 7. **Bind before terminal metadata.** `task-complete.py accept --receipt <receipt> --acceptance <worktree>/.devlyn/loop/acceptance.json` takes evidence custody and points the recovery ref at the source. Failed results are bound the same way; they never become a frontier or a publishable product.
 8. **Commit the terminal transition** under the queue lock: one commit whose sole parent is the bound source and whose only change is this task's row in `docs/specs/<loop-id>/queue.md` (`[x]`, or `[F] — <first reason> (receipt <id>)`), validated as the only legal transition. Then `task-complete.py attach --receipt <receipt> --commit <terminal> --file docs/specs/<loop-id>/queue.md` records it separately from the source and moves the recovery ref to it.
-9. **Deliver** after waiting for the executor, with `task-complete.py complete --receipt <receipt> --writers-stopped`, plus `--local-only` or, until the receipt records a mode, the packet's `--mode auto|pr`, so a per-task `--mode` persists. Local-only keeps source, custody and the recovery ref with no remote effect. `auto`/`pr` publish the terminal commit under the completion contract; a pending or refused delivery keeps product acceptance, resources and a resume command. Where writer cessation cannot be observed, or a process still uses the tree, a merged delivery settles (`COMPLETE`) with its workspace, task ref and custody retained and reported under workspace cleanup; retained cleanup never blocks the queue. Failed products are never published. The receipt's `delivery` field checkpoints the latest outcome. A local chain is never turned into stacked PRs; publishing it requires integrated acceptance of the actual publication candidate.
+9. **Deliver** after waiting for the executor, with `task-complete.py complete --receipt <receipt> --writers-stopped`, plus `--local-only` or, until the receipt records a mode, the packet's `--mode auto|pr`, so a per-task `--mode` persists. Local-only keeps source, custody and the recovery ref with no remote effect. `auto`/`pr` publish the terminal commit under the completion contract; a pending or refused delivery keeps product acceptance, resources and a resume command. A merged delivery whose cleanup is refused settles (`COMPLETE`) with what the refusal guards retained and reported under workspace cleanup; retained cleanup never blocks the queue. Failed products are never published. The receipt's `delivery` field checkpoints the latest outcome. A local chain is never turned into stacked PRs; publishing it requires integrated acceptance of the actual publication candidate.
 10. **Recover** from durable state only:
 
     | Interrupted | Resume |

package/native/claude/skills/devlyn-ideate/scripts/acceptance.py

@@ -515,6 +515,8 @@ class AcceptanceTests(unittest.TestCase):
         self.addCleanup(self.temp.cleanup)
         self.root = Path(self.temp.name).resolve()
         self.work = self.root / "work tree"
+        # A commit's detached automatic maintenance would still write into .git while a test reads the tree.
+        (self.root / "gitconfig").write_text("[maintenance]\n\tauto = false\n", encoding="utf-8")
         env = {"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.saved = {key: os.environ.get(key) for key in env}
@@ -543,6 +545,15 @@ class AcceptanceTests(unittest.TestCase):
         self.g("commit", "-q", "-m", message)
         return self.g("rev-parse", "HEAD")
 
+    def test_fixture_commit_starts_no_automatic_maintenance(self):
+        # Its detached child would still write into .git while a test reads the tree or cleanup removes it.
+        from unittest import mock
+        trace = self.root / "trace.json"
+        with mock.patch.dict(os.environ, GIT_TRACE2_EVENT=str(trace)):
+            self.g("commit", "-q", "--allow-empty", "-m", "traced")
+        children = [line for line in trace.read_text(encoding="utf-8").splitlines() if '"event":"child_start"' in line]
+        self.assertEqual(children, [])
+
     def inputs(self, expected=None, review=()):
         base = self.g("rev-parse", "HEAD")
         files = {"docs/specs/l/meta.md": "# meta\n", "docs/specs/l/t/spec.md": "# task R1 R2\n",

package/native/claude/skills/devlyn-ideate/scripts/queue.py

@@ -1429,6 +1429,8 @@ def advance(v, row, opts):
         progress(identity, f"delivery {result['status']}")
         if result.get("merge_refused"):
             return f"merge refused: {result['merge_refused']}; a person merges the PR"
+        if waits := result.get("merge_waits"):
+            return f"merge waits: PR is {waits} ({'GitHub has not computed its mergeability yet' if waits == 'UNKNOWN' else 'required checks or reviews not passing yet'}); drain again later, or merge it"
     return None
 
 
@@ -1657,11 +1659,15 @@ def status_summary(v):
     row = next_task(v, set())
     annotate(v, {})
     tasks = [summary(v, r) for r in v["rows"] if r["identity"]]
+    # A task without a resume is no pending delivery, so a cleanup it retained is named here with its own resume.
+    retained = [f"{t['identity']}: {label} {t[key]}" for t in tasks if not t.get("resume")
+                for key, field, label in (("cleanup", "workspace_cleanup", "workspace cleanup"), ("scratch", "scratch_cleanup", "scratch cleanup"))
+                if ((v["states"][t["identity"]]["receipt"] or {}).get(field) or {}).get("reason")]
     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"]],
-            "delivery": [t for t in tasks if t.get("resume")], "cleanup": v["cleanup"]}
+            "delivery": [t for t in tasks if t.get("resume")], "cleanup": v["cleanup"] + retained}
 
 
 def status(args):
@@ -1897,6 +1903,8 @@ class QueueTests(unittest.TestCase):
             "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")
+        # A commit's detached automatic maintenance would still write into .git while a test reads the tree.
+        (self.root / "gitconfig").write_text("[maintenance]\n\tauto = false\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"}
@@ -1940,6 +1948,14 @@ class QueueTests(unittest.TestCase):
             path.write_text(text.replace(old, new, 1), encoding="utf-8")
         return mutate
 
+    def test_fixture_commit_starts_no_automatic_maintenance(self):
+        # Its detached child would still write into .git while a test reads the tree or cleanup removes it.
+        trace = self.root / "trace.json"
+        subprocess.run(["git", "-C", str(self.anchor), "commit", "-q", "--allow-empty", "-m", "traced"], check=True,
+                       env={**self.env, "GIT_TRACE2_EVENT": str(trace)})
+        children = [line for line in trace.read_text(encoding="utf-8").splitlines() if '"event":"child_start"' in line]
+        self.assertEqual(children, [])
+
     def test_package_validation(self):
         self.assertEqual(self.cli("check", self.meta)["tasks"], ["inv.t1", "inv.t2"])
         manifest = json.loads(JSON_FENCE_RE.search((self.anchor / "docs/specs/inv/meta.md").read_text(encoding="utf-8")).group(1))

package/native/codex/.agents/plugins/marketplace.json

@@ -1,5 +1,5 @@
 {
-  "name": "devlyn-harness-v4-3-30",
+  "name": "devlyn-harness-v4-3-32",
   "plugins": [
     {
       "name": "devlyn",

package/native/codex/plugins/devlyn/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "devlyn",
-  "version": "4.3.30",
+  "version": "4.3.32",
   "description": "Devlyn harness skills",
   "skills": "./skills/"
 }

package/native/codex/plugins/devlyn/skills/_shared/bring-in.py

@@ -363,6 +363,8 @@ class BringInTests(unittest.TestCase):
         self.env = {key: value for key, value in os.environ.items()
                     if not key.startswith("GIT_")}
         self.env.update(GIT_CONFIG_NOSYSTEM="1", GIT_CONFIG_GLOBAL=str(self.root / "no-global"),
+                        # A commit's detached automatic maintenance would still write into .git while a test copies it.
+                        GIT_CONFIG_COUNT="1", GIT_CONFIG_KEY_0="maintenance.auto", GIT_CONFIG_VALUE_0="false",
                         GIT_AUTHOR_NAME="Fixture", GIT_AUTHOR_EMAIL="fixture@example.invalid",
                         GIT_COMMITTER_NAME="Fixture", GIT_COMMITTER_EMAIL="fixture@example.invalid",
                         LC_ALL="C", GIT_EDITOR=":", GIT_MERGE_AUTOEDIT="no")
@@ -415,6 +417,14 @@ class BringInTests(unittest.TestCase):
         path.write_bytes(("#!/bin/sh\n" + body).encode("utf-8"))
         path.chmod(0o755)
 
+    def test_fixture_commit_starts_no_automatic_maintenance(self):
+        # Its detached child would still write .git/objects/maintenance.lock while copytree or cleanup reads the tree.
+        trace = self.root / "trace.json"
+        self.env["GIT_TRACE2_EVENT"] = str(trace)
+        self.commit("traced", "traced\n")
+        children = [line for line in trace.read_text(encoding="utf-8").splitlines() if '"event":"child_start"' in line]
+        self.assertEqual(children, [])
+
     def test_fast_forward_and_paths_with_spaces(self):
         self.cli()
         self.assertEqual(self.g("rev-parse", "HEAD").strip(), self.target)

package/native/codex/plugins/devlyn/skills/_shared/runtime-principles.md

@@ -15,7 +15,7 @@ Seven rules govern every change. Cite them by name when a decision touches one.
 1. **No workaround** — fix the root cause, never the symptom. No `any`, no `@ts-ignore`, no silent `catch`, no hardcoded fallback that hides a broken contract. No config bypasses.
 2. **No overengineering** — smallest sufficient change, one responsibility per module. New abstractions need an observed failure. Subtractive-first: ask "what can I delete instead?" before writing anything new. Remove code your change makes unused; only report unrelated pre-existing dead code.
 3. **No guesswork** — verify with the actual files, logs, diffs, and run output before forming conclusions. State the falsifiable prediction BEFORE the experiment; record raw results AFTER. Retroactive prediction edits are dishonest.
-4. **Worldclass** — zero CRITICAL, zero HIGH security/design findings on the shippable path. Any review is one pass in which every reviewer, including each one the user requires, reads the source the checks ran on; fix each finding or reject it with a reason, re-check the fixes and the invariants they touch, and repeat the full review only while a CRITICAL or HIGH finding remains.
+4. **Worldclass** — zero CRITICAL, zero HIGH findings on the shippable path; each must name a concrete case of wrong behavior or results, a security hole, or lost or corrupted data. A review is one pass on the source the checks ran on, by the reviewers the user requires, else by one reviewer who has not seen the author's reasoning. Fix each finding or reject it with a reason, and verify every edit and the invariants it touches. Only a CRITICAL or HIGH calls for another reviewer pass, which reads the fixes, the rejections and the invariants they touch. If one survives that pass, or its fix caused a new one, repair once more; if the next pass finds either again, stop: the work does not ship and is reported blocked.
 5. **Best practice** — idiomatic for the language and framework. Use standard primitives; do not hand-roll what the library already provides.
 6. **Optimized** — efficient on the resource that matters (the user's time, tokens, attention, runtime) without weakening correctness or requirements. An extra check or process step must beat the simpler path.
 7. **Production ready** — error states are explicit and visible; behavior under failure is what the user expects, not silent corruption.