engineering-process 2.1.0__tar.gz → 2.2.0__tar.gz

{engineering_process-2.1.0 → engineering_process-2.2.0}/MANIFEST.in

@@ -1,5 +1,6 @@
 include process-graph.json
 include RELEASE_NOTES.md
 recursive-include process_assets/skills SKILL.md *.json
+recursive-include process_assets/standards *.json
 recursive-include schemas *.json
 recursive-include templates *.md *.py *.json

{engineering_process-2.1.0/engineering_process.egg-info → engineering_process-2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: engineering-process
-Version: 2.1.0
+Version: 2.2.0
 Summary: A small agent-neutral engineering lifecycle with managed adoption
 License-Expression: MIT
 Project-URL: Homepage, https://github.com/phuongnse/engineering-process
@@ -270,6 +270,11 @@ The transaction writes only managed surfaces:
 
 It removes obsolete skills named by the previous process lock and preserves
 consumer-owned skills and instructions. Applying the same version twice is a no-op.
+Consumer-owned `.process/standards.json` selections and override definitions are also
+preserved; the managed PR template follows the effective supported standard. See
+[consumer document standards](ARTIFACT_STANDARDS.md).
+[Automation naming](ARTIFACT_STANDARDS.md#automation-names) uses the same versioned
+selection and override mechanism; consumers apply it in their bootstrap and provider checks.
 The legacy managed runner can enter 1.0 directly, so consumers do not need a chain of
 per-version migration documents. The same transaction deletes the retired migration
 directory and standing automation policy; the Windows Job Object helper remains a
@@ -482,7 +487,7 @@ supported review schemas; ordinary legacy non-blocking observations remain reada
 
 ### Public pull-request evidence
 
-The managed pull-request template keeps public assurance separate from local
+The default pull-request standard keeps public assurance separate from local
 lifecycle identity. Its five sections and labeled fields are ordered and stable:
 outcome and scope; source, risk, compatibility, and stack; profiles, snapshot, and
 completion receipt; verdict, cycles, blocking status, and non-blocking dispositions;
@@ -492,10 +497,15 @@ handle, or local `.process/runs` path. Those values remain in lifecycle state, w
 they enforce self-review rejection but do not pretend to be provider-authenticated
 review identities.
 
-`processctl publication validate-pr` checks that public contract deterministically.
+The template and validator derive this contract from the same versioned definition.
+Consumers can select a supported override through `.process/standards.json`; see
+[generation, verification and custom-format boundaries](ARTIFACT_STANDARDS.md).
+`processctl publication validate-pr` checks that selected contract deterministically.
 It rejects missing, repeated, misplaced, hidden, unordered, or unsupported visible
 structure. Completion checkboxes belong only to the Completion gate section. Ready
-pull requests must have every checkbox checked; drafts may retain unchecked work.
+pull requests must have every checkbox checked and no unresolved default placeholder
+values; drafts may retain pending fields and unchecked work. The author/coordinator
+replaces them with actual evidence before ready/merge; the reviewer supplies the verdict.
 One trailing `Refs ISSUE.` line remains optional. A ready, contract-identified final
 consumer adoption may instead use `Closes ISSUE, closes OWNER/REPOSITORY#NUMBER.` with
 the complete keyword/reference syntax repeated for every issue; drafts cannot close
@@ -555,17 +565,19 @@ authorizes that merge.
 This repository opts in through .github/renovate.json, so it receives the same
 adoption PR as every other consumer. See SELF_HOSTING.md and RELEASING.md.
 
-The optional [Renovate preset](templates/renovate.json) is generated from the
-canonical public template. It supplies only `prHeader` and `prBodyTemplate`;
+The optional [Renovate preset](templates/renovate.json) and public template are generated
+from the packaged PR standard. It supplies only `prHeader` and `prBodyTemplate`;
 dependency selection, supported platforms, schedules, major-update approval,
 commands, draft policy, and merge authority remain consumer-owned. Regenerate it
 with `python verification/generate_renovate_preset.py`; `--check` rejects drift.
+Consumers overriding that standard can generate a matching preset with
+`processctl artifact renovate-preset`; wire it through their own Renovate configuration.
 
 Consumers add `github>phuongnse/engineering-process//templates/renovate#COMMIT_SHA`
 to their existing `extends` array, replacing `COMMIT_SHA` with the full source
 commit of a verified release that contains the preset. Remove obsolete inline
 `prHeader` and `prBodyTemplate` overrides, including matching package-rule overrides.
-The preset targets the canonical draft grammar used by 1.2.4 and this distribution;
+The default preset targets the draft grammar used by 1.2.4 and this distribution;
 it does not claim compatibility with earlier publication contracts. A future
 grammar change must preserve this adapter or ship an explicit consumer migration.
 

{engineering_process-2.1.0 → engineering_process-2.2.0}/README.md

@@ -246,6 +246,11 @@ The transaction writes only managed surfaces:
 
 It removes obsolete skills named by the previous process lock and preserves
 consumer-owned skills and instructions. Applying the same version twice is a no-op.
+Consumer-owned `.process/standards.json` selections and override definitions are also
+preserved; the managed PR template follows the effective supported standard. See
+[consumer document standards](ARTIFACT_STANDARDS.md).
+[Automation naming](ARTIFACT_STANDARDS.md#automation-names) uses the same versioned
+selection and override mechanism; consumers apply it in their bootstrap and provider checks.
 The legacy managed runner can enter 1.0 directly, so consumers do not need a chain of
 per-version migration documents. The same transaction deletes the retired migration
 directory and standing automation policy; the Windows Job Object helper remains a
@@ -458,7 +463,7 @@ supported review schemas; ordinary legacy non-blocking observations remain reada
 
 ### Public pull-request evidence
 
-The managed pull-request template keeps public assurance separate from local
+The default pull-request standard keeps public assurance separate from local
 lifecycle identity. Its five sections and labeled fields are ordered and stable:
 outcome and scope; source, risk, compatibility, and stack; profiles, snapshot, and
 completion receipt; verdict, cycles, blocking status, and non-blocking dispositions;
@@ -468,10 +473,15 @@ handle, or local `.process/runs` path. Those values remain in lifecycle state, w
 they enforce self-review rejection but do not pretend to be provider-authenticated
 review identities.
 
-`processctl publication validate-pr` checks that public contract deterministically.
+The template and validator derive this contract from the same versioned definition.
+Consumers can select a supported override through `.process/standards.json`; see
+[generation, verification and custom-format boundaries](ARTIFACT_STANDARDS.md).
+`processctl publication validate-pr` checks that selected contract deterministically.
 It rejects missing, repeated, misplaced, hidden, unordered, or unsupported visible
 structure. Completion checkboxes belong only to the Completion gate section. Ready
-pull requests must have every checkbox checked; drafts may retain unchecked work.
+pull requests must have every checkbox checked and no unresolved default placeholder
+values; drafts may retain pending fields and unchecked work. The author/coordinator
+replaces them with actual evidence before ready/merge; the reviewer supplies the verdict.
 One trailing `Refs ISSUE.` line remains optional. A ready, contract-identified final
 consumer adoption may instead use `Closes ISSUE, closes OWNER/REPOSITORY#NUMBER.` with
 the complete keyword/reference syntax repeated for every issue; drafts cannot close
@@ -531,17 +541,19 @@ authorizes that merge.
 This repository opts in through .github/renovate.json, so it receives the same
 adoption PR as every other consumer. See SELF_HOSTING.md and RELEASING.md.
 
-The optional [Renovate preset](templates/renovate.json) is generated from the
-canonical public template. It supplies only `prHeader` and `prBodyTemplate`;
+The optional [Renovate preset](templates/renovate.json) and public template are generated
+from the packaged PR standard. It supplies only `prHeader` and `prBodyTemplate`;
 dependency selection, supported platforms, schedules, major-update approval,
 commands, draft policy, and merge authority remain consumer-owned. Regenerate it
 with `python verification/generate_renovate_preset.py`; `--check` rejects drift.
+Consumers overriding that standard can generate a matching preset with
+`processctl artifact renovate-preset`; wire it through their own Renovate configuration.
 
 Consumers add `github>phuongnse/engineering-process//templates/renovate#COMMIT_SHA`
 to their existing `extends` array, replacing `COMMIT_SHA` with the full source
 commit of a verified release that contains the preset. Remove obsolete inline
 `prHeader` and `prBodyTemplate` overrides, including matching package-rule overrides.
-The preset targets the canonical draft grammar used by 1.2.4 and this distribution;
+The default preset targets the draft grammar used by 1.2.4 and this distribution;
 it does not claim compatibility with earlier publication contracts. A future
 grammar change must preserve this adapter or ship an explicit consumer migration.
 

engineering_process-2.2.0/RELEASE_NOTES.md

@@ -0,0 +1,18 @@
+# Engineering Process v2.2.0
+
+Changes since v2.1.0.
+
+## Features
+
+- Generate and verify PR descriptions and release notes from versioned standards with consumer\-owned overrides preserved by adoption\. Matching template and validator definitions reject unresolved default PR placeholders in ready state\; custom formats retain consumer\-owned validation profiles\. ([#174](https://github.com/phuongnse/engineering-process/issues/174))
+- Generate and verify automation names from a default owner\-role convention or a consumer\-owned override\. Bootstrap integrations can consume structured CLI output and check actual provider names before side effects\; provider limits and authenticated identity remain consumer\-owned\. ([#176](https://github.com/phuongnse/engineering-process/issues/176))
+
+## Upgrade and compatibility
+
+Merge the complete hash-locked package/adoption PR, update the local and CI environments to the selected version, and start a fresh agent session.
+
+Consumer CI, naming conventions and branch-protection settings remain consumer-owned; adoption does not configure them automatically.
+
+See [versioning and compatibility](https://github.com/phuongnse/engineering-process/blob/v2.2.0/VERSIONING.md) and [adoption guidance](https://github.com/phuongnse/engineering-process/blob/v2.2.0/SELF_HOSTING.md).
+
+[Full change comparison](https://github.com/phuongnse/engineering-process/compare/v2.1.0...v2.2.0)

{engineering_process-2.1.0 → engineering_process-2.2.0}/engineering_process/__init__.py

@@ -1,3 +1,3 @@
 """Agent-neutral engineering process."""
 
-VERSION = "2.1.0"
+VERSION = "2.2.0"

{engineering_process-2.1.0 → engineering_process-2.2.0}/engineering_process/adoption.py

@@ -12,6 +12,7 @@ import tempfile
 from typing import Any, Callable
 
 from . import VERSION
+from .artifact_standards import load_standard_catalog
 from .contracts import ProcessError, read_json, validate_document
 from .distribution import (
     distribution_digest,
@@ -21,6 +22,7 @@ from .distribution import (
     skills_root,
 )
 from .project import normalize_project, project_path
+from .pr_description import render_template
 
 
 MAX_REQUIREMENTS_BYTES = 2_000_000
@@ -253,9 +255,8 @@ def _expected_files(
         "utf-8"
     )
 
-    pull_request_template = (
-        process_root / "templates" / "PULL_REQUEST_TEMPLATE.md"
-    ).read_text(encoding="utf-8")
+    standards = load_standard_catalog(project_root, process_root)
+    pull_request_template = render_template(standards.resolve("pull-request"), process_root=process_root)
     pull_request_path = project_root / ".github" / "PULL_REQUEST_TEMPLATE.md"
     existing_pull_request = (
         pull_request_path.read_text(encoding="utf-8")
@@ -301,6 +302,12 @@ def _expected_files(
     writes[Path(".process/process.lock")] = (
         json.dumps(lock, indent=2, sort_keys=True) + "\n"
     ).encode("utf-8")
+    collisions = standards.consumer_files.intersection(writes.keys() | deletions)
+    if collisions:
+        raise ProcessError(
+            "consumer standard files conflict with managed adoption paths; move the definitions and update the selection: "
+            + ", ".join(sorted(path.as_posix() for path in collisions))
+        )
     total = sum(len(value) for value in writes.values())
     if total > MAX_MANAGED_BYTES:
         raise ProcessError("managed adoption output exceeds its aggregate limit")

engineering_process-2.2.0/engineering_process/artifact_standards.py

@@ -0,0 +1,147 @@
+"""Resolve one versioned artifact contract for both generation and verification."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+import os
+from pathlib import Path
+import re
+from typing import Any
+
+from .contracts import ProcessError, digest_json, load_and_validate
+from .distribution import schemas_root
+from .repository import STATE_PREFIXES, _git
+
+
+IDENTIFIER = re.compile(r"[a-z0-9](?:[a-z0-9.-]*[a-z0-9])?")
+MAX_DOCUMENT_BYTES = 1_000_000
+
+
+@dataclass(frozen=True)
+class ArtifactStandard:
+    document: dict[str, Any]
+    source: str
+
+    @property
+    def rules(self) -> dict[str, Any]:
+        return self.document["rules"]
+
+    @property
+    def metadata(self) -> dict[str, Any]:
+        return {
+            **{key: self.document[key] for key in ("id", "version", "artifact", "adapter")},
+            "digest": digest_json(self.document),
+            "source": self.source,
+        }
+
+    def unresolved(self, value: str) -> bool:
+        # These are reserved values in an owned protocol, not prose classification.
+        return value.strip().casefold() in {
+            item.strip().casefold() for item in self.document.get("pendingValues", [])
+        }
+
+
+def _consumer_file(root: Path, relative: str) -> Path:
+    path = root / relative
+    if not path.resolve().is_relative_to(root):
+        raise ProcessError(f"standard path escapes the consumer repository: {relative}")
+    if path.resolve() != path or Path(relative).as_posix() != relative:
+        raise ProcessError(f"standard path must be canonical without links: {relative}")
+    if any(part in {"..", ".git"} for part in Path(relative).parts):
+        raise ProcessError(f"standard path is not an owned repository file: {relative}")
+    current = root
+    for part in Path(relative).parts:
+        current /= part
+        if current.is_symlink():
+            raise ProcessError(f"standard paths cannot traverse symlinks: {relative}")
+    if not path.is_file():
+        raise ProcessError(f"consumer standard file is missing: {relative}")
+    encoded = os.fsencode(Path(relative).as_posix())
+    if any(encoded.startswith(prefix) for prefix in STATE_PREFIXES):
+        raise ProcessError(f"standard file is excluded from lifecycle snapshots: {relative}")
+    inventory = _git(root, ["ls-files", "-z", "--cached", "--others", "--exclude-standard", "--", relative])
+    if encoded not in inventory.split(b"\0"):
+        raise ProcessError(f"standard file must be included in the consumer Git snapshot: {relative}")
+    return path
+
+
+def _unique(values: list[str], description: str) -> None:
+    if len(values) != len(set(values)):
+        raise ProcessError(f"artifact standard requires unique {description}")
+
+
+def _validate_relations(document: dict[str, Any]) -> None:
+    _unique([value.strip().casefold() for value in document.get("pendingValues", [])], "pending values")
+    rules = document["rules"]
+    if document["adapter"] == "pr-description":
+        sections = rules["sections"]
+        _unique([section["heading"] for section in sections], "section headings")
+        for kind in ("fields", "checks"):
+            entries = [entry for section in sections for entry in section[kind]]
+            _unique([entry["id"] for entry in entries], f"{kind} ids")
+            _unique([entry["label"] for entry in entries], f"{kind} labels")
+    elif document["adapter"] == "release-notes":
+        _unique([group["type"] for group in rules["groups"]], "change types")
+        _unique([section["id"] for section in rules["sections"]], "release section ids")
+        _unique([item["heading"] for item in rules["groups"] + rules["sections"]], "release headings")
+
+
+def read_document(path: Path) -> bytes:
+    with path.open("rb") as stream:
+        data = stream.read(MAX_DOCUMENT_BYTES + 1)
+    if len(data) > MAX_DOCUMENT_BYTES:
+        raise ProcessError("artifact body exceeds its size limit")
+    data.decode("utf-8")
+    return data
+
+
+@dataclass(frozen=True)
+class StandardCatalog:
+    """One selection snapshot for adapter resolution and adoption ownership checks."""
+
+    project_root: Path | None
+    process_root: Path
+    selections: dict[str, Any]
+    consumer_files: frozenset[Path]
+
+    def resolve(self, artifact: str) -> ArtifactStandard:
+        if len(artifact) > 128 or not IDENTIFIER.fullmatch(artifact):
+            raise ProcessError("artifact must be a canonical identifier")
+        selection = self.selections.get(artifact, {"builtin": f"{artifact}@1"})
+        if "path" in selection:
+            path = _consumer_file(self.project_root, selection["path"])
+            source = selection["path"]
+        else:
+            name, version = selection["builtin"].rsplit("@", 1)
+            path = self.process_root / "process_assets" / "standards" / f"{name}.v{version}.json"
+            source = selection["builtin"]
+            if path.is_symlink() or not path.is_file():
+                raise ProcessError(f"unsupported packaged artifact standard: {source}")
+        document = load_and_validate(path, "artifact-standard", schema_root=schemas_root(self.process_root))
+        if document["artifact"] != artifact:
+            raise ProcessError(f"selected standard is for {document['artifact']}, not {artifact}")
+        if "builtin" in selection and (name != artifact or document["version"] != int(version)):
+            raise ProcessError("packaged standard identity does not match its selection")
+        _validate_relations(document)
+        return ArtifactStandard(document, source)
+
+
+def load_standard_catalog(project_root: Path | None, process_root: Path) -> StandardCatalog:
+    selections: dict[str, Any] = {}
+    consumer_files: set[Path] = set()
+    if project_root is not None:
+        project_root = project_root.resolve()
+        selector = project_root / ".process" / "standards.json"
+        if selector.exists() or selector.is_symlink():
+            document = load_and_validate(
+                _consumer_file(project_root, ".process/standards.json"),
+                "artifact-selection", schema_root=schemas_root(process_root),
+            )
+            selections = document["artifacts"]
+            consumer_files = {Path(".process/standards.json")}
+            consumer_files.update(Path(value["path"]) for value in selections.values() if "path" in value)
+    return StandardCatalog(project_root, process_root, selections, frozenset(consumer_files))
+
+
+def resolve_standard(project_root: Path | None, process_root: Path, artifact: str) -> ArtifactStandard:
+    return load_standard_catalog(project_root, process_root).resolve(artifact)

engineering_process-2.2.0/engineering_process/automation_name.py

@@ -0,0 +1,31 @@
+"""Compose automation names from a selected convention and consumer-owned components."""
+
+from pathlib import Path
+from typing import Any
+
+from .artifact_standards import ArtifactStandard
+from .contracts import ProcessError, validate_document
+from .distribution import distribution_root, schemas_root
+
+
+def render_name(
+    standard: ArtifactStandard,
+    data: dict[str, Any],
+    *,
+    state: str = "ready",
+    process_root: Path | None = None,
+) -> str:
+    if standard.document["adapter"] != "automation-name":
+        raise ProcessError("selected standard requires a different name adapter")
+    validate_document(data, "automation-name-data", schema_root=schemas_root(distribution_root(process_root)))
+    if state not in {"draft", "ready"}:
+        raise ProcessError("artifact state must be draft or ready")
+    rules = standard.rules
+    if set(data["components"]) != set(rules["components"]):
+        raise ProcessError("name components must exactly match the selected standard")
+    name = rules["separator"].join(data["components"][key] for key in rules["components"])
+    if rules["case"] == "lower":
+        name = name.lower()
+    if len(name) > rules["maxLength"]:
+        raise ProcessError("automation name exceeds the selected length limit")
+    return name + "\n"

{engineering_process-2.1.0 → engineering_process-2.2.0}/engineering_process/cli.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import argparse
+import hashlib
 import json
 from pathlib import Path
 import sys
@@ -10,10 +11,14 @@ from typing import Any, Callable
 
 from . import VERSION
 from .adoption import apply_adoption, check_adoption
+from .automation_name import render_name
+from .artifact_standards import MAX_DOCUMENT_BYTES, read_document, resolve_standard
 from .commands import run_check, run_profile
 from .contracts import (
     CONTRACT_KINDS,
     ProcessError,
+    digest_json,
+    formatted_json_bytes,
     load_and_validate,
     read_json,
     validate_document,
@@ -47,6 +52,8 @@ from .publication_compat import (
     validate_range,
 )
 from .release import validate_release
+from .pr_description import body_issues, render_description, render_renovate_preset, render_template
+from .release_notes import render_notes
 from .repository import repository_snapshot, same_checkpoint
 from .skills import validate_skills
 
@@ -391,11 +398,54 @@ def command_publication(args: argparse.Namespace) -> Result:
             branch=args.branch,
             state=args.state,
             body_path=args.body_file,
+            project_root=args.project_root,
+            process_root=_process_root(args),
         )
     status = "passed" if not details["issues"] else "failed"
     return _result(f"publication {name}", status=status, **details), (0 if status == "passed" else 1)
 
 
+def command_artifact(args: argparse.Namespace) -> Result:
+    process_root = _process_root(args)
+    standard = resolve_standard(args.project_root, process_root, args.artifact)
+    details: dict[str, Any] = {"standard": standard.metadata}
+    operation = args.artifact_command
+    issues: list[str] = []
+    if operation == "show":
+        payload = formatted_json_bytes(standard.document)
+        if args.output is None:
+            details["definition"] = standard.document
+    elif operation == "template":
+        payload = render_template(standard, process_root=process_root).encode("utf-8")
+    elif operation == "renovate-preset":
+        payload = formatted_json_bytes(render_renovate_preset(standard, process_root=process_root))
+    else:
+        data = load_and_validate(args.data_file, standard.document["adapter"] + "-data", schema_root=schemas_root(process_root)) if args.data_file is not None else None
+        if data is not None:
+            renderer = {"pr-description": render_description, "release-notes": render_notes, "automation-name": render_name}[standard.document["adapter"]]
+            payload = renderer(standard, data, state=args.state, process_root=process_root).encode("utf-8")
+            details["dataDigest"] = digest_json(data)
+        elif operation == "render" or standard.document["adapter"] != "pr-description":
+            raise ProcessError("this artifact operation requires --data-file")
+        if operation == "validate":
+            actual = read_document(args.body_file)
+            if data is None:
+                issues = body_issues(actual.decode("utf-8"), args.state, standard)
+            elif actual != payload:
+                issues.append("artifact bytes differ from the selected standard and input data")
+            payload = actual
+    if len(payload) > MAX_DOCUMENT_BYTES:
+        raise ProcessError("artifact output exceeds its size limit")
+    details["artifactDigest"] = "sha256:" + hashlib.sha256(payload).hexdigest()
+    if operation != "validate" and args.output is not None:
+        args.output.write_bytes(payload)
+        details["output"] = str(args.output)
+    elif operation == "render":
+        details["content"] = payload.decode("utf-8")
+    status = "failed" if issues else "passed"
+    return _result(f"artifact {operation}", status, **details, issues=issues), (1 if issues else 0)
+
+
 def _add_common(parser: argparse.ArgumentParser, *, project: bool = True) -> None:
     if project:
         parser.add_argument("--project-root", type=_root, default=Path.cwd())
@@ -495,6 +545,19 @@ def build_parser() -> argparse.ArgumentParser:
     release_validate = _leaf(release_commands, "validate", command_release_validate)
     release_validate.add_argument("--tag")
 
+    artifact = commands.add_parser("artifact", help="Generate and verify consumer-selected artifact standards")
+    artifact_commands = artifact.add_subparsers(dest="artifact_command", required=True)
+    for name in ("show", "template", "renovate-preset", "render", "validate"):
+        leaf = _leaf(artifact_commands, name, command_artifact)
+        leaf.add_argument("--artifact", required=True)
+        if name in {"render", "validate"}:
+            leaf.add_argument("--state", choices=("draft", "ready"), default="ready")
+            leaf.add_argument("--data-file", type=Path, required=name == "render")
+        if name == "validate":
+            leaf.add_argument("--body-file", type=Path, required=True)
+        else:
+            leaf.add_argument("--output", type=Path, required=name not in {"show", "render"})
+
     publication = commands.add_parser("publication", help=argparse.SUPPRESS)
     publication_commands = publication.add_subparsers(
         dest="publication_command", required=True
@@ -511,7 +574,7 @@ def build_parser() -> argparse.ArgumentParser:
     publication_range.add_argument("--branch", required=True)
     publication_range.add_argument("--range", dest="range_spec", required=True)
     publication_pr = _leaf(
-        publication_commands, "validate-pr", command_publication, project=False
+        publication_commands, "validate-pr", command_publication
     )
     publication_pr.add_argument("--title", required=True)
     publication_pr.add_argument("--branch", required=True)

{engineering_process-2.1.0 → engineering_process-2.2.0}/engineering_process/contracts.py

@@ -17,16 +17,22 @@ from jsonschema import Draft202012Validator
 
 MAX_JSON_BYTES = 2_000_000
 CONTRACT_KINDS = (
+    "artifact-selection",
+    "artifact-standard",
+    "automation-name-data",
     "change",
     "plan",
     "process-graph",
     "process-lock",
     "production-engineering",
+    "pr-description-data",
     "project",
     "project-legacy",
     "receipt",
     "release-change",
     "release",
+    "release-notes-data",
+    "renovate-preset",
     "review",
     "run",
 )

{engineering_process-2.1.0 → engineering_process-2.2.0}/engineering_process/distribution.py

@@ -18,8 +18,8 @@ MAX_DISTRIBUTION_BYTES = 10_000_000
 def distribution_root(explicit: Path | None = None) -> Path:
     if explicit is not None:
         root = explicit.resolve()
-        if not (root / "process_assets" / "skills").is_dir():
-            raise ProcessError(f"{root}: process_assets/skills is missing")
+        if not skills_root(root).is_dir():
+            raise ProcessError(f"{root}: process_assets/skills or skills is missing")
         return root
 
     source = Path(__file__).resolve().parent.parent
@@ -77,6 +77,9 @@ def _asset_paths(root: Path) -> Iterable[tuple[str, Path]]:
     schema_directory = schemas_root(root)
     for path in _ordered_paths(schema_directory, schema_directory.glob("*.json")):
         yield f"schemas/{path.name}", path
+    standard_directory = root / "process_assets" / "standards"
+    for path in _ordered_paths(standard_directory, standard_directory.glob("*.json")):
+        yield f"standards/{path.name}", path
     for name in (
         "AGENTS.process.md",
         "PULL_REQUEST_TEMPLATE.md",