devlyn-cli 4.3.0 → 4.3.4

package/native/claude/skills/_shared/engine-doctor.sh

@@ -0,0 +1,70 @@
+#!/usr/bin/env bash
+# engine-doctor.sh — read-only detection for /devlyn-engines' no-arg output.
+#
+# WHY (iter-0050): users need to see what's actually on the machine, not
+# just what's pinned. This script never writes .devlyn/engines.json, never
+# installs anything, never changes pin validation — it only reports.
+#
+# macOS-safe bash 3.2: no associative arrays, no mapfile/readarray.
+set -uo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]:-$0}")" && pwd)"
+ADAPTERS_DIR="$SCRIPT_DIR/adapters"
+
+TARGETS=(claude codex omp pi)
+KINDS=(cli-engine cli-engine cli-engine orchestrator-only)
+BINARIES=(claude codex omp "")
+INSTALL_HINTS=(
+  "see https://docs.anthropic.com/en/docs/claude-code"
+  "npm install -g @openai/codex"
+  "brew install can1357/tap/omp"
+  ""
+)
+
+check_binary() {
+  # $1 = binary name, "" means no known binary to probe
+  [ -n "$1" ] || { printf 'unknown'; return; }
+  if command -v "$1" >/dev/null 2>&1; then printf 'yes'; else printf 'no'; fi
+}
+
+check_adapter() {
+  # $1 = target name
+  if [ -f "$ADAPTERS_DIR/$1.md" ]; then printf 'yes'; else printf 'no'; fi
+}
+
+check_executor() {
+  # $1 = adapter file path. An adapter may declare the fixed ASCII field
+  # `executor: no` under `## Role eligibility`; otherwise it can execute.
+  [ -f "$1" ] || { printf 'n/a'; return; }
+  if grep -q '^executor: no' "$1" 2>/dev/null; then printf 'no'; else printf 'yes'; fi
+}
+
+printf '%-8s %-17s %-8s %-8s %-9s %s\n' \
+  'target' 'kind' 'binary' 'adapter' 'executor' 'note'
+
+for i in "${!TARGETS[@]}"; do
+  target="${TARGETS[$i]}"
+  kind="${KINDS[$i]}"
+  binary="$(check_binary "${BINARIES[$i]}")"
+  adapter="$(check_adapter "$target")"
+  executor="$(check_executor "$ADAPTERS_DIR/$target.md")"
+
+  note='-'
+  case "$kind" in
+    cli-engine)
+      if [ "$binary" = 'no' ]; then
+        note="not installed; ${INSTALL_HINTS[$i]}"
+      elif [ "$adapter" = 'no' ]; then
+        note="binary present, no adapter — reinstall devlyn-cli, whose releases ship the adapters"
+      elif [ "$executor" = 'no' ]; then
+        note='adapter declares executor: no'
+      fi
+      ;;
+    orchestrator-only)
+      note='informational only; not a routable engine — no verified CLI binary or adapter'
+      ;;
+  esac
+
+  printf '%-8s %-17s %-8s %-8s %-9s %s\n' \
+    "$target" "$kind" "$binary" "$adapter" "$executor" "$note"
+done

package/native/claude/skills/_shared/engine-preflight.md

@@ -0,0 +1,29 @@
+# Shared — Executor Pre-flight
+
+Used by `/devlyn-ideate` and `/devlyn-engines`: one rule for which engine executes implementation work and what happens when it is missing.
+
+## Selection
+
+The executor is the `executor` pin in `.devlyn/engines.json` at the checkout root (set with `/devlyn-engines executor <name>`), else the CLI the user opened. A linked worktree or subdirectory has no pin unless one is set there. Pi and Grok have no executor adapter, so a drain from them needs a claude, codex or omp pin. Keys earlier releases wrote for retired pipeline roles (`pair_judge_priority`, `roles`) stay as written and select nothing: a worker profile never becomes the executor.
+
+Before dispatching to the executor, run:
+
+```sh
+python3 "$DEVLYN_SHARED_DIR/role-config.py" --workdir <project> --default-engine <this CLI> --select
+```
+
+A pin is a promise. When the pinned engine's CLI is unavailable, the command exits 1 with `BLOCKED:<engine>-unavailable`: stop, preserve the evidence, and show the setup guidance — install and authenticate that CLI, verify `<engine> --version`, rerun. Never substitute another engine. A malformed file, or a name without an executor-eligible adapter, is `BLOCKED:invalid-engine-config`. CLI presence is not authentication, and status never launches a model.
+
+## Engines
+
+An engine is pinnable when `_shared/adapters/<name>.md` exists and does not declare `executor: no` under `## Role eligibility`. Adapters ship with devlyn-cli releases, and a reinstall replaces `_shared`. An adapter's `## Invocation` says how to start it. On native Windows, use native Node/npm and Python (`python3` on PATH), with Git for Windows Bash for the shipped shell wrapper.
+
+## Reporting a blocked engine
+
+The final report names the selected engine, the verdict and the setup steps; it never reports a downgraded success:
+
+```
+Engine: codex (pinned executor)
+Verdict: BLOCKED:codex-unavailable
+Setup: install/configure Codex CLI; run the current Codex auth/login flow; verify `codex --version`; rerun.
+```

package/native/claude/skills/_shared/expected-contract.py

@@ -0,0 +1,242 @@
+#!/usr/bin/env python3
+"""Strict JSON and `spec.expected.json` contract validation for the ideate loop's package check and acceptance runner."""
+from __future__ import annotations
+
+import json
+import sys
+import unittest
+
+
+def reject_json_constant(token: str) -> None:
+    raise ValueError(f"invalid JSON numeric constant: {token}")
+
+
+def reject_duplicate_keys(pairs: list[tuple[str, object]]) -> dict:
+    result = {}
+    for key, value in pairs:
+        if key in result:
+            raise ValueError(f"duplicate JSON key: {key}")
+        result[key] = value
+    return result
+
+
+def loads_strict_json(text: str):
+    return json.loads(
+        text,
+        parse_constant=reject_json_constant,
+        object_pairs_hook=reject_duplicate_keys,
+    )
+
+
+EXPECTED_TOP_LEVEL_KEYS = {
+    "verification_commands",
+    "forbidden_patterns",
+    "required_files",
+    "forbidden_files",
+    "max_deps_added",
+    "pure_design",
+}
+EXPECTED_VERIFICATION_COMMAND_KEYS = {
+    "cmd",
+    "argv",
+    "exit_code",
+    "timeout_sec",
+    "stdout_contains",
+    "stdout_not_contains",
+    "contract_refs",
+}
+DEFAULT_TIMEOUT_SEC = 60
+
+
+def verification_timeout_sec(command: dict) -> int:
+    return command.get("timeout_sec", DEFAULT_TIMEOUT_SEC)
+
+
+def validate_command(command: object, label: str) -> str | None:
+    """Validate one command; `argv` and `cmd` are mutually exclusive."""
+    if not isinstance(command, dict):
+        return f"{label} must be an object"
+    if "argv" in command:
+        if "cmd" in command:
+            return f"{label} requires exactly one of cmd or argv"
+        value = command["argv"]
+        if not isinstance(value, list) or not value or not all(isinstance(item, str) for item in value) or not value[0]:
+            return f"{label}.argv must be a string array with non-empty argv[0]"
+    else:
+        cmd = command.get("cmd")
+        if not isinstance(cmd, str) or not cmd.strip():
+            return f"{label}.cmd must be a non-empty string"
+    ec = command.get("exit_code", 0)
+    if isinstance(ec, bool) or not isinstance(ec, int):
+        return f"{label}.exit_code must be int (not bool)"
+    timeout_sec = command.get("timeout_sec", DEFAULT_TIMEOUT_SEC)
+    if isinstance(timeout_sec, bool) or not isinstance(timeout_sec, int) or not 1 <= timeout_sec <= 600:
+        return f"{label}.timeout_sec must be int from 1 to 600 (not bool)"
+    for k in ("stdout_contains", "stdout_not_contains"):
+        v = command.get(k, [])
+        if not isinstance(v, list) or not all(isinstance(s, str) and s for s in v):
+            return f"{label}.{k} must be a list of non-empty strings"
+    return None
+
+
+def validate_shape(data) -> str | None:
+    """Return None if `data` has a non-empty, well-formed `verification_commands`
+    list; else a human-readable error string.
+
+    Each object requires exactly one of a non-empty string `cmd` or a
+    string-array `argv`; `exit_code` defaults to 0 and must be a
+    non-bool int; `timeout_sec` defaults to DEFAULT_TIMEOUT_SEC and must be a
+    non-bool int from 1 through 600; `stdout_contains` and `stdout_not_contains`
+    default to empty lists of non-empty strings. Bool is rejected explicitly
+    because Python's `bool` subclasses `int`.
+    """
+    if not isinstance(data, dict):
+        return "top-level must be a JSON object"
+    cmds = data.get("verification_commands")
+    if not isinstance(cmds, list):
+        return "verification_commands must be a list"
+    if not cmds:
+        return "verification_commands must contain at least one entry"
+    for i, c in enumerate(cmds):
+        err = validate_command(c, f"verification_commands[{i}]")
+        if err:
+            return err
+    return None
+
+
+def validate_string_list(data: object, key: str) -> str | None:
+    value = data.get(key, []) if isinstance(data, dict) else None
+    if not isinstance(value, list) or not all(isinstance(item, str) and item for item in value):
+        return f"{key} must be a list of non-empty strings"
+    return None
+
+
+def validate_expected_shape(data) -> str | None:
+    """Return None if shape matches the sibling spec.expected.json schema.
+
+    Keep this dependency-free: it mirrors `_shared/expected.schema.json` enough
+    to catch malformed contracts before a consumer executes them.
+    """
+    if not isinstance(data, dict):
+        return "top-level must be a JSON object"
+    unknown = sorted(set(data) - EXPECTED_TOP_LEVEL_KEYS)
+    if unknown:
+        return f"unknown top-level key(s): {', '.join(unknown)}"
+    if "verification_commands" in data:
+        commands = data["verification_commands"]
+        if not isinstance(commands, list):
+            return "verification_commands must be a list"
+        if commands:
+            err = validate_shape({"verification_commands": commands})
+            if err:
+                return err
+        for i, command in enumerate(commands):
+            unknown_command_keys = sorted(set(command) - EXPECTED_VERIFICATION_COMMAND_KEYS)
+            if unknown_command_keys:
+                return (
+                    f"verification_commands[{i}] unknown key(s): "
+                    f"{', '.join(unknown_command_keys)}"
+                )
+            contract_refs = command.get("contract_refs", [])
+            if not isinstance(contract_refs, list) or not all(
+                isinstance(item, str) and item for item in contract_refs
+            ):
+                return f"verification_commands[{i}].contract_refs must be a list of non-empty strings"
+    for key in ("required_files", "forbidden_files"):
+        err = validate_string_list(data, key)
+        if err:
+            return err
+    max_deps = data.get("max_deps_added", 0)
+    if isinstance(max_deps, bool) or not isinstance(max_deps, int) or max_deps < 0:
+        return "max_deps_added must be a non-negative integer"
+    if "pure_design" in data and not isinstance(data["pure_design"], bool):
+        return "pure_design must be a boolean"
+    patterns = data.get("forbidden_patterns", [])
+    if not isinstance(patterns, list):
+        return "forbidden_patterns must be a list"
+    for i, pattern in enumerate(patterns):
+        if not isinstance(pattern, dict):
+            return f"forbidden_patterns[{i}] must be an object"
+        unknown_pattern_keys = sorted(set(pattern) - {"pattern", "description", "files", "severity"})
+        if unknown_pattern_keys:
+            return (
+                f"forbidden_patterns[{i}] unknown key(s): "
+                f"{', '.join(unknown_pattern_keys)}"
+            )
+        for key in ("pattern", "description", "severity"):
+            value = pattern.get(key)
+            if not isinstance(value, str) or not value:
+                return f"forbidden_patterns[{i}].{key} must be a non-empty string"
+        if pattern["severity"] not in {"disqualifier", "warning"}:
+            return f"forbidden_patterns[{i}].severity must be disqualifier or warning"
+        files = pattern.get("files", [])
+        if not isinstance(files, list) or not all(isinstance(item, str) and item for item in files):
+            return f"forbidden_patterns[{i}].files must be a list of non-empty strings"
+    return None
+
+
+def slice_diff_to_files(diff_text: str, files: list[str]) -> str:
+    if not files:
+        return diff_text
+    out: list[str] = []
+    keep = False
+    for line in diff_text.splitlines(keepends=True):
+        if line.startswith("diff --git "):
+            keep = any(path in line for path in files)
+        if keep:
+            out.append(line)
+    return "".join(out)
+
+
+class ContractTests(unittest.TestCase):
+    def test_strict_json(self):
+        for text, message in (('{"a":1,"a":2}', "duplicate JSON key"), ('{"a":NaN}', "invalid JSON numeric constant")):
+            with self.assertRaisesRegex(ValueError, message):
+                loads_strict_json(text)
+
+    def test_cmd_and_argv_are_mutually_exclusive(self):
+        ok = {"verification_commands": [{"argv": ["python3", "-c", "pass"], "contract_refs": ["R1"]}, {"cmd": "true"}]}
+        self.assertIsNone(validate_expected_shape(ok))
+        for command, message in (
+            ({"cmd": "true", "argv": ["true"]}, "exactly one of cmd or argv"),
+            ({"argv": []}, "argv must be a string array"),
+            ({"argv": ["", "x"]}, "argv must be a string array"),
+            ({"argv": ["x", 1]}, "argv must be a string array"),
+            ({}, "cmd must be a non-empty string"),
+        ):
+            self.assertIn(message, validate_expected_shape({"verification_commands": [command]}))
+
+    def test_command_fields(self):
+        for command, message in (
+            ({"cmd": "x", "exit_code": True}, "exit_code must be int"),
+            ({"cmd": "x", "timeout_sec": 601}, "timeout_sec must be int from 1 to 600"),
+            ({"cmd": "x", "stdout_contains": "x"}, "stdout_contains must be a list of non-empty strings"),
+            ({"cmd": "x", "stdout_contains": [""]}, "stdout_contains must be a list of non-empty strings"),
+            ({"cmd": "x", "stdout_not_contains": [""]}, "stdout_not_contains must be a list of non-empty strings"),
+            ({"cmd": "x", "contract_refs": [""]}, "contract_refs must be a list of non-empty strings"),
+            ({"cmd": "x", "extra": 1}, "unknown key(s): extra"),
+        ):
+            self.assertIn(message, validate_expected_shape({"verification_commands": [command]}))
+        self.assertEqual(validate_expected_shape([]), "top-level must be a JSON object")
+        self.assertIn("unknown top-level key(s): process_evidence", validate_expected_shape({"process_evidence": []}))
+
+    def test_diff_helpers(self):
+        diff = ('diff --git a/package.json b/package.json\n--- a/package.json\n+++ b/package.json\n@@ -1,3 +1,5 @@\n'
+                ' {\n   "dependencies": {\n+    "left-pad": "1.0.0",\n+    "is-odd": "3.0.0"\n   }\n }\n'
+                'diff --git a/other b/other\n+x\n')
+        self.assertNotIn("other", slice_diff_to_files(diff, ["package.json"]))
+        self.assertEqual(slice_diff_to_files(diff, []), diff)
+
+
+def main() -> int:
+    if sys.argv[1:] != ["--self-test"]:
+        print("usage: expected-contract.py --self-test", file=sys.stderr)
+        return 2
+    result = unittest.TextTestRunner(verbosity=1).run(unittest.defaultTestLoader.loadTestsFromTestCase(ContractTests))
+    if result.wasSuccessful():
+        print(f"expected-contract self-test: PASS ({result.testsRun} tests)")
+    return 0 if result.wasSuccessful() else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/native/claude/skills/_shared/expected.schema.json

@@ -0,0 +1,120 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://github.com/fysoul17/devlyn-cli/config/skills/_shared/expected.schema.json",
+  "title": "spec.expected.json — mechanical acceptance contract",
+  "description": "Load-bearing LLM-agnostic decoupler for the devlyn-cli harness. Defines the machine-readable acceptance criteria a spec ships alongside spec.md. Stable across model upgrades — when Opus 5 / GPT-6 / Qwen / Gemini land, this schema does not move; only the per-model adapter files in _shared/adapters/ do.",
+  "type": "object",
+  "additionalProperties": false,
+  "properties": {
+    "verification_commands": {
+      "type": "array",
+      "description": "Each command must pass on the task's committed source. At least one entry is required when the spec has any observable runtime check (CLI, test command, HTTP request).",
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "oneOf": [
+          { "required": ["cmd"], "not": { "required": ["argv"] } },
+          { "required": ["argv"], "not": { "required": ["cmd"] } }
+        ],
+        "properties": {
+          "cmd": {
+            "type": "string",
+            "description": "Shell command, executed via `subprocess.run(..., shell=True)` from the build's working directory.",
+            "minLength": 1
+          },
+          "argv": {
+            "type": "array",
+            "minItems": 1,
+            "items": { "type": "string" },
+            "description": "Exact argv executed without a shell; argv[0] must be non-empty. Preferred for generated and Windows contracts."
+          },
+          "exit_code": {
+            "type": "integer",
+            "description": "Required exit code. Default 0 if omitted.",
+            "default": 0
+          },
+          "timeout_sec": {
+            "type": "integer",
+            "minimum": 1,
+            "maximum": 600,
+            "description": "Per-command timeout in seconds. Default 60 if omitted; maximum 600.",
+            "default": 60
+          },
+          "stdout_contains": {
+            "type": "array",
+            "description": "Each substring must appear verbatim in (stdout + stderr) for pass.",
+            "items": { "type": "string", "minLength": 1 },
+            "default": []
+          },
+          "stdout_not_contains": {
+            "type": "array",
+            "description": "None of these substrings may appear in (stdout + stderr) for pass.",
+            "items": { "type": "string", "minLength": 1 },
+            "default": []
+          },
+          "contract_refs": {
+            "type": "array",
+            "description": "Requirements this command verifies. Ideate loop tasks name requirement IDs (R1, R2, ...) from the task Requirements and require at least one.",
+            "items": { "type": "string", "minLength": 1 },
+            "default": []
+          }
+        }
+      }
+    },
+    "forbidden_patterns": {
+      "type": "array",
+      "description": "Regex patterns scanned across the task's diff.",
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": ["pattern", "description", "severity"],
+        "properties": {
+          "pattern": {
+            "type": "string",
+            "description": "Python re.search-compatible regex. Anchored implicitly by the surrounding regex, NOT by ^ / $ unless intended.",
+            "minLength": 1
+          },
+          "description": {
+            "type": "string",
+            "description": "Human-readable explanation of what the pattern catches and why it's forbidden.",
+            "minLength": 1
+          },
+          "files": {
+            "type": "array",
+            "description": "Optional allow-list of files (substrings of diff --git lines). When present, scan is sliced to hunks touching only these files.",
+            "items": { "type": "string", "minLength": 1 },
+            "default": []
+          },
+          "severity": {
+            "type": "string",
+            "enum": ["disqualifier", "warning"],
+            "description": "disqualifier blocks acceptance; warning is recorded."
+          }
+        }
+      }
+    },
+    "required_files": {
+      "type": "array",
+      "description": "Files specified by literal paths that must exist in the committed source; globs are not expanded.",
+      "items": { "type": "string", "minLength": 1 },
+      "default": []
+    },
+    "forbidden_files": {
+      "type": "array",
+      "description": "Exact Git-relative paths (forward slashes, no leading ./) that must NOT appear in the diff, including both rename names; globs and directory prefixes are not expanded.",
+      "items": { "type": "string", "minLength": 1 },
+      "default": []
+    },
+    "max_deps_added": {
+      "type": "integer",
+      "description": "Hard cap on package names the root package.json's dependencies and devDependencies gain over the task inputs; a move between them adds none.",
+      "minimum": 0,
+      "default": 0
+    },
+    "pure_design": {
+      "type": "boolean",
+      "description": "Declares that every Requirement is pure-design (no observable runtime check). Lets verification_commands stay empty without failing shape validation. Contradictory (and rejected) when true alongside a non-empty verification_commands.",
+      "default": false
+    }
+  }
+}

package/native/claude/skills/_shared/harness-store.py

@@ -0,0 +1,207 @@
+"""Release identity and queue resource checks. Readers never write or create locks.
+
+The release verifier is CLI-1's bin/release.js, not a second manifest verifier.
+A Codex projection has .devlyn-harness-projection.json at its plugin root:
+{schemaVersion: 1, release: ReleaseRef, source: "native/codex/plugins/devlyn"}.
+Its complete regular-file tree (except that marker) must match that release subtree.
+"""
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+from pathlib import Path
+import re
+import runpy
+import subprocess
+import sys
+
+PROJECTION = ".devlyn-harness-projection.json"
+CODEX_SOURCE = "native/codex/plugins/devlyn"
+
+
+class HarnessError(Exception):
+    pass
+
+
+def require(condition, message):
+    if not condition:
+        raise HarnessError(message)
+
+
+def read_json(path):
+    try:
+        return json.loads(Path(path).read_bytes())
+    except (OSError, ValueError) as exc:
+        raise HarnessError(f"{path}: {exc}") from exc
+
+
+def file_identity(path):
+    path = Path(path)
+    info = path.lstat()
+    require(path.is_file() and not path.is_symlink() and info.st_nlink == 1, f"not a regular resource: {path}")
+    return {"path": str(path), "sha256": hashlib.sha256(path.read_bytes()).hexdigest()}
+
+
+def release_ref(value):
+    require(isinstance(value, dict) and set(value) == {"package", "version", "digest", "root"}
+            and value["package"] == "devlyn-cli"
+            and all(isinstance(value[k], str) and value[k] and "\0" not in value[k] for k in ("version", "digest", "root"))
+            and re.fullmatch(r"[a-f0-9]{64}", value["digest"]) and Path(value["root"]).is_absolute(), "malformed release reference")
+    return value
+
+
+def verify_release(root):
+    root = Path(root)
+    # As harness-status verifies it: an npm-installed package keeps npm's own .bin shims, which are checked.
+    script = "const r=require(process.argv[1]);r.runJson(()=>r.verifyRelease(process.argv[2],{npmInstall:true}));"
+    try:
+        node = runpy.run_path(str(Path(__file__).with_name("platform-support.py")))["managed_node"]() or "node"
+        result = subprocess.run([node, "-e", script, str(root / "bin/release.js"), str(root)], capture_output=True, text=True, encoding="utf-8")
+    except (OSError, ValueError) as exc:
+        raise HarnessError(f"release verifier could not start: {exc}") from exc
+    require(result.returncode == 0, f"release verification failed: {root}: {result.stderr.strip()}")
+    try:
+        release = release_ref(json.loads(result.stdout)["data"]["release"])
+    except (KeyError, ValueError, TypeError) as exc:
+        raise HarnessError(f"invalid release verifier result: {root}: {exc}") from exc
+    manifest = read_json(root / "release.json")
+    defaults = file_identity(root / manifest["principles"]["defaults"])
+    return {"schemaVersion": 1, "release": release, "defaults": defaults}
+
+
+def walk_error(error):
+    raise error  # os.walk otherwise silently skips unreadable projection directories.
+
+
+def resolve(skills):
+    """Resolve only this invoking skill's real ancestry; never search another install."""
+    skill = (Path(skills) / "devlyn-ideate").resolve()
+    for parent in (skill, *skill.parents):
+        marker = parent / PROJECTION
+        if marker.exists() or marker.is_symlink():
+            file_identity(marker)
+            projection = read_json(marker)
+            require(isinstance(projection, dict) and set(projection) == {"schemaVersion", "release", "source"}
+                    and type(projection["schemaVersion"]) is int and projection["schemaVersion"] == 1
+                    and projection["source"] == CODEX_SOURCE, f"malformed projection: {marker}")
+            ref = release_ref(projection["release"])
+            binding = verify_release(ref["root"])
+            require(binding["release"] == ref, f"projection release changed: {marker}")
+            source = Path(ref["root"]) / CODEX_SOURCE
+            require(skill == parent / "skills/devlyn-ideate", f"unexpected projection skill: {skill}")
+            expected = {p.relative_to(source) for p in source.rglob("*") if p.is_file()}
+            actual = set()
+            for directory, dirs, files in os.walk(parent, onerror=walk_error):
+                for name in dirs:
+                    require(not (Path(directory) / name).is_symlink(), f"projection directory link: {directory}/{name}")
+                for name in files:
+                    file = Path(directory) / name
+                    if file == marker:
+                        continue
+                    rel = file.relative_to(parent)
+                    actual.add(rel)
+                    require(rel in expected and file_identity(file)["sha256"] == file_identity(source / rel)["sha256"]
+                            and (os.name == "nt" or bool(file.stat().st_mode & 0o111) == bool((source / rel).stat().st_mode & 0o111)),
+                            f"projection resource changed: {file}")
+            require(actual == expected, f"projection file list changed: {parent}")
+            return binding
+        manifest = parent / "release.json"
+        if (manifest.exists() or manifest.is_symlink()) and skill in [parent / p / "devlyn-ideate" for p in
+                ("config/skills", "native/claude/skills", CODEX_SOURCE + "/skills")]:
+            return verify_release(parent)
+    return None
+
+
+def read_binding(common):
+    path = Path(common) / "devlyn-loops/harness.json"
+    if not path.exists() and not path.is_symlink():
+        return None
+    file_identity(path)
+    binding = read_json(path)
+    require(isinstance(binding, dict) and set(binding) == {"schemaVersion", "release", "defaults"}
+            and type(binding["schemaVersion"]) is int and binding["schemaVersion"] == 1, f"incompatible queue binding: {path}")
+    release_ref(binding["release"])
+    resource(binding["defaults"])
+    return binding
+
+
+def resource(value):
+    require(isinstance(value, dict) and set(value) == {"path", "sha256"}
+            and isinstance(value["path"], str) and "\0" not in value["path"] and Path(value["path"]).is_absolute()
+            and isinstance(value["sha256"], str) and re.fullmatch(r"[a-f0-9]{64}", value["sha256"]), "malformed resource binding")
+
+
+def recovery_argv(binding, argv):
+    return [sys.executable, str(Path(binding["release"]["root"]) / "config/skills/devlyn-ideate/scripts/queue.py"), *argv]
+
+
+def check_binding(binding, invoking):
+    if binding is None:
+        return
+    require(invoking is not None and binding["release"] == invoking["release"], "queue-release-mismatch")
+    require(binding == invoking, "queue defaults changed; restore the bound release")
+
+
+def packet_schema(packet):
+    require(isinstance(packet, dict), "task packet must be an object")
+    version = packet.get("schema_version", 1)
+    require(type(version) is int and version in (1, 2), f"incompatible task packet version: {version!r}")
+    if version == 1:
+        return
+    require("harness" in packet and isinstance(packet.get("methodology"), dict), "malformed packet v2 harness/methodology")
+    methodology = packet["methodology"]
+    require(set(methodology) == {"defaults", "projectInstructions"} and isinstance(methodology["projectInstructions"], list),
+            "malformed packet v2 methodology")
+    for entry in methodology["projectInstructions"]:
+        resource(entry)
+    if packet["harness"] is None:
+        defaults = methodology["defaults"]
+        require(packet.get("workerPrompt") is None and (defaults is None or (isinstance(defaults, dict) and defaults.get("source") == "skill")),
+                "legacy packet has release resources")
+        if defaults is not None:
+            resource({k: v for k, v in defaults.items() if k != "source"})
+        return
+    release_ref(packet["harness"])
+    defaults = methodology["defaults"]
+    require(isinstance(defaults, dict) and defaults.get("source") == "release", "packet has no verified release defaults source")
+    resource({k: v for k, v in defaults.items() if k != "source"})
+    resource(packet.get("workerPrompt"))
+
+
+def verify_packet(packet, path, skills):
+    packet_schema(packet)
+    if packet.get("schema_version", 1) == 1:
+        return  # Preserve v1 execution without upgrading its resources.
+    receipt = packet.get("receipt")
+    require(isinstance(receipt, str) and "\0" not in receipt and Path(receipt).is_absolute()
+            and Path(receipt).name == "receipt.json" and Path(receipt).parent.parent.name == "devlyn-completion"
+            and Path(receipt) == Path(path).with_name("receipt.json"),
+            "malformed packet receipt path")
+    binding = read_binding(Path(receipt).parent.parent.parent)
+    if packet["harness"] is None:
+        require(binding is None, "bound task packet has no harness/defaults source")
+        # An unbound installation's own defaults change with its normal updates: never gate acceptance or delivery on
+        # their bytes (queue.py checks only their presence, before a spawn).
+        return
+    require(binding is not None, "packet queue binding is missing; restore harness.json")
+    invoking = resolve(skills)
+    ref = packet["harness"]
+    require(invoking is not None and invoking["release"] == ref,
+            f"packet-release-mismatch; use {Path(ref['root']) / 'config/skills/devlyn-ideate/scripts/queue.py'}")
+    check_binding(binding, invoking)
+    defaults = {"source": "release", **binding["defaults"]}
+    require(packet["methodology"]["defaults"] == defaults, "packet defaults differ from queue binding")
+    expected_runner = [str(Path(ref["root"]) / "config/skills/devlyn-ideate/scripts/acceptance.py"),
+                       "run", "--packet", str(path)]
+    require(isinstance(packet.get("runner"), list) and packet["runner"][1:] == expected_runner, "packet runner differs from bound release")
+    prompt = packet["workerPrompt"]
+    require(prompt["path"] == str(Path(path).parent / "worker-prompt.md") and file_identity(prompt["path"]) == prompt,
+            "worker prompt changed or missing; restore the bound resource")
+    for entry in packet["methodology"]["projectInstructions"]:
+        name = Path(entry["path"]).name
+        require(name in ("CLAUDE.md", "AGENTS.md") and entry["path"] == str(Path(packet["worktree"]) / name),
+                "project instruction path escapes packet worktree")
+        committed = subprocess.run(["git", "-C", packet["worktree"], "cat-file", "blob", f"{packet['inputs_sha']}:{name}"], capture_output=True)
+        require(committed.returncode == 0 and hashlib.sha256(committed.stdout).hexdigest() == entry["sha256"],
+                f"project instruction differs from inputs commit: {name}")