engineering-process 1.0.0__tar.gz → 1.1.0__tar.gz

{engineering_process-1.0.0/engineering_process.egg-info → engineering_process-1.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: engineering-process
-Version: 1.0.0
+Version: 1.1.0
 Summary: A small agent-neutral engineering lifecycle with managed adoption
 License-Expression: MIT
 Project-URL: Homepage, https://github.com/phuongnse/engineering-process
@@ -92,10 +92,72 @@ Commands are argument arrays, never shell strings. Each command has a finite tim
 Output has a hard aggregate budget; evidence stores byte counts and hashes, never raw
 stdout or stderr that could contain secrets.
 
+### Production readiness
+
+A consumer declares `.process/readiness.json` with production as its direction, its
+current stage, immutable pack versions, and the state of every required capability.
+An enforced capability maps to project-required profiles; a planned capability names
+the concrete gap without pretending to have evidence:
+
+    {
+      "target": "production",
+      "stage": "production",
+      "packs": [{"id": "library-cli", "version": 1}],
+      "capabilities": [
+        {"id": "correctness", "state": "enforced", "evidenceProfiles": ["development"]},
+        {"id": "runtime-safety", "state": "enforced", "evidenceProfiles": ["development"]},
+        {"id": "compatibility", "state": "enforced", "evidenceProfiles": ["development"]},
+        {"id": "portability", "state": "enforced", "evidenceProfiles": ["development", "review"]},
+        {"id": "installability", "state": "enforced", "evidenceProfiles": ["review"]},
+        {"id": "distribution-integrity", "state": "enforced", "evidenceProfiles": ["review"]},
+        {"id": "adoption-integrity", "state": "enforced", "evidenceProfiles": ["development", "review"]}
+      ]
+    }
+
+`project validate` and `doctor` resolve that declaration to the exact checks owned by
+the consumer. The declaration does not make a weak command sufficient: normal CI and
+independent review still judge whether those commands prove the named capability. A
+building consumer may keep planned gaps while ordinary development continues. A
+production-stage declaration fails closed if any capability remains planned.
+
+The sidecar is a deliberate self-hosting boundary. Public authority N continues to
+validate the unchanged strict `.process/project.json` while source N+1 validates and
+self-applies the new readiness contract. Adoption leaves the consumer-owned sidecar
+in place, so every later authority can repeat the same forward-compatible sequence.
+Pack versions are also immutable: a process update must keep `operations@1` working
+even after `operations@2` exists. Process adoption and pack upgrades are separate
+consumer-owned changes, preventing a new standard from deadlocking authority adoption.
+
+`library-cli@1` was derived from this repository as a real producer and self-consumer.
+`operations@1` was then derived from renovate-ops and requires auditability, automation
+correctness, bounded execution, least privilege, policy integrity, recovery, and
+target-selection integrity. `desktop-media@1` is derived from LyricRail and keeps its
+existing correctness, input, source-portability, audit, media, package, and recovery-
+mechanism evidence enforced. Stable dependency/recovery claims, signing, key custody,
+runtime/license delivery, Linux advisory resolution, real-host workspace security,
+updater, incident recovery, and independent security review remain planned.
+Consumers without readiness remain compatible during that evidence-backed rollout.
+
+For each ordinary change, `run-change` first surfaces this readiness view. The accepted
+request and consumer rules determine which capabilities are affected. Every change
+retains the project's baseline `requiredProfiles`; start and plan add any conditional
+evidence profiles needed by affected capabilities and include a planned gap only when
+the accepted request explicitly selects it. Implement and review protect the enforced
+floor. A planned-to-enforced promotion is a reviewed consumer source diff with fresh
+evidence. Unrelated planned gaps remain visible but do not block development, and no
+skill chooses product priorities or changes readiness automatically.
+
+When a consumer incident exposes a reusable process gap, `improve-process` first keeps
+the consumer safe, then prepares a sanitized GitHub issue draft from that checkout.
+It deduplicates by consumer/process-version/invariant, requires owner authorization
+before `gh issue create`, and uses an accepted issue as the later process change source
+and `consumerEvidence`. No producer clone, consumer-CI write token, automatic process
+mutation, or wait for a process release is required to continue consumer development.
+
 Pin the process in requirements/process.in:
 
     --only-binary :all:
-    engineering-process==0.9.0
+    engineering-process==1.0.1
 
 Generate requirements/process.txt with hashes, install that lock, then run:
 
@@ -232,7 +294,7 @@ At any point:
 ## Release to consumer PR
 
 Every opted-in consumer uses Renovate's pip-compile manager. Its engineering-process
-package rule is enabled, never automerges, and runs exactly:
+package rule keeps the adoption pull request in draft and runs exactly:
 
     python .process/adopt-process.py --project-root . --requirements-lock requirements/process.txt
 
@@ -247,7 +309,8 @@ The release workflow publishes exact wheel and sdist bytes to PyPI, verifies the
 registry hashes, creates the immutable GitHub release, and sends one authenticated
 engineering-process-published event to renovate-ops. That control plane runs Renovate
 for each repository whose protected config explicitly opts in. Each consumer's normal
-CI and independent review decide whether its PR can merge.
+CI and independent review decide whether its draft PR can merge; the consumer owner
+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.

{engineering_process-1.0.0 → engineering_process-1.1.0}/README.md

@@ -68,10 +68,72 @@ Commands are argument arrays, never shell strings. Each command has a finite tim
 Output has a hard aggregate budget; evidence stores byte counts and hashes, never raw
 stdout or stderr that could contain secrets.
 
+### Production readiness
+
+A consumer declares `.process/readiness.json` with production as its direction, its
+current stage, immutable pack versions, and the state of every required capability.
+An enforced capability maps to project-required profiles; a planned capability names
+the concrete gap without pretending to have evidence:
+
+    {
+      "target": "production",
+      "stage": "production",
+      "packs": [{"id": "library-cli", "version": 1}],
+      "capabilities": [
+        {"id": "correctness", "state": "enforced", "evidenceProfiles": ["development"]},
+        {"id": "runtime-safety", "state": "enforced", "evidenceProfiles": ["development"]},
+        {"id": "compatibility", "state": "enforced", "evidenceProfiles": ["development"]},
+        {"id": "portability", "state": "enforced", "evidenceProfiles": ["development", "review"]},
+        {"id": "installability", "state": "enforced", "evidenceProfiles": ["review"]},
+        {"id": "distribution-integrity", "state": "enforced", "evidenceProfiles": ["review"]},
+        {"id": "adoption-integrity", "state": "enforced", "evidenceProfiles": ["development", "review"]}
+      ]
+    }
+
+`project validate` and `doctor` resolve that declaration to the exact checks owned by
+the consumer. The declaration does not make a weak command sufficient: normal CI and
+independent review still judge whether those commands prove the named capability. A
+building consumer may keep planned gaps while ordinary development continues. A
+production-stage declaration fails closed if any capability remains planned.
+
+The sidecar is a deliberate self-hosting boundary. Public authority N continues to
+validate the unchanged strict `.process/project.json` while source N+1 validates and
+self-applies the new readiness contract. Adoption leaves the consumer-owned sidecar
+in place, so every later authority can repeat the same forward-compatible sequence.
+Pack versions are also immutable: a process update must keep `operations@1` working
+even after `operations@2` exists. Process adoption and pack upgrades are separate
+consumer-owned changes, preventing a new standard from deadlocking authority adoption.
+
+`library-cli@1` was derived from this repository as a real producer and self-consumer.
+`operations@1` was then derived from renovate-ops and requires auditability, automation
+correctness, bounded execution, least privilege, policy integrity, recovery, and
+target-selection integrity. `desktop-media@1` is derived from LyricRail and keeps its
+existing correctness, input, source-portability, audit, media, package, and recovery-
+mechanism evidence enforced. Stable dependency/recovery claims, signing, key custody,
+runtime/license delivery, Linux advisory resolution, real-host workspace security,
+updater, incident recovery, and independent security review remain planned.
+Consumers without readiness remain compatible during that evidence-backed rollout.
+
+For each ordinary change, `run-change` first surfaces this readiness view. The accepted
+request and consumer rules determine which capabilities are affected. Every change
+retains the project's baseline `requiredProfiles`; start and plan add any conditional
+evidence profiles needed by affected capabilities and include a planned gap only when
+the accepted request explicitly selects it. Implement and review protect the enforced
+floor. A planned-to-enforced promotion is a reviewed consumer source diff with fresh
+evidence. Unrelated planned gaps remain visible but do not block development, and no
+skill chooses product priorities or changes readiness automatically.
+
+When a consumer incident exposes a reusable process gap, `improve-process` first keeps
+the consumer safe, then prepares a sanitized GitHub issue draft from that checkout.
+It deduplicates by consumer/process-version/invariant, requires owner authorization
+before `gh issue create`, and uses an accepted issue as the later process change source
+and `consumerEvidence`. No producer clone, consumer-CI write token, automatic process
+mutation, or wait for a process release is required to continue consumer development.
+
 Pin the process in requirements/process.in:
 
     --only-binary :all:
-    engineering-process==0.9.0
+    engineering-process==1.0.1
 
 Generate requirements/process.txt with hashes, install that lock, then run:
 
@@ -208,7 +270,7 @@ At any point:
 ## Release to consumer PR
 
 Every opted-in consumer uses Renovate's pip-compile manager. Its engineering-process
-package rule is enabled, never automerges, and runs exactly:
+package rule keeps the adoption pull request in draft and runs exactly:
 
     python .process/adopt-process.py --project-root . --requirements-lock requirements/process.txt
 
@@ -223,7 +285,8 @@ The release workflow publishes exact wheel and sdist bytes to PyPI, verifies the
 registry hashes, creates the immutable GitHub release, and sends one authenticated
 engineering-process-published event to renovate-ops. That control plane runs Renovate
 for each repository whose protected config explicitly opts in. Each consumer's normal
-CI and independent review decide whether its PR can merge.
+CI and independent review decide whether its draft PR can merge; the consumer owner
+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.

{engineering_process-1.0.0 → engineering_process-1.1.0}/engineering_process/__init__.py

@@ -1,3 +1,3 @@
 """Agent-neutral engineering process."""
 
-VERSION = "1.0.0"
+VERSION = "1.1.0"

{engineering_process-1.0.0 → engineering_process-1.1.0}/engineering_process/_supervisor_posix.py

@@ -98,13 +98,24 @@ def _pid_alive(pid: int) -> bool:
     status = Path(f"/proc/{pid}/stat")
     if status.is_file():
         try:
-            return status.read_text(encoding="utf-8").split()[2] != "Z"
+            state = status.read_text(encoding="utf-8").rsplit(")", 1)[1].split()[0]
+            if state == "Z":
+                try:
+                    os.waitpid(pid, os.WNOHANG)
+                except OSError:
+                    pass
+                return False
         except (OSError, IndexError):
             pass
     return True
 
 
 def _process_group_exists(process_group: int) -> bool:
+    try:
+        while os.waitpid(-process_group, os.WNOHANG)[0]:
+            pass
+    except OSError:
+        pass
     try:
         os.killpg(process_group, 0)
     except ProcessLookupError:
@@ -114,6 +125,14 @@ def _process_group_exists(process_group: int) -> bool:
     return True
 
 
+def _signal_processes(processes: set[int], signal_number: int) -> None:
+    for pid in processes:
+        try:
+            os.kill(pid, signal_number)
+        except OSError:
+            pass
+
+
 def _wait_for_process_group(process_group: int, timeout: float) -> bool:
     deadline = time.monotonic() + timeout
     while time.monotonic() < deadline:
@@ -144,11 +163,7 @@ def _terminate_group(process_group: int, grace_seconds: float) -> CleanupOutcome
     return CleanupOutcome(
         bounded=bounded,
         descendants_found=True,
-        error=(
-            None
-            if bounded
-            else "command process group could not be terminated within the bounded grace period"
-        ),
+        error=None if bounded else "command process group exceeded its termination grace period",
     )
 
 
@@ -250,24 +265,12 @@ class PosixProcessSupervisor:
         live = {pid for pid in candidates if _pid_alive(pid)}
         if not live:
             return CleanupOutcome(bounded=True)
-        for pid in live:
-            try:
-                os.kill(pid, signal.SIGTERM)
-            except ProcessLookupError:
-                pass
-            except OSError:
-                pass
+        _signal_processes(live, signal.SIGTERM)
         deadline = time.monotonic() + grace_seconds
         while time.monotonic() < deadline and any(_pid_alive(pid) for pid in live):
             time.sleep(0.02)
         survivors = {pid for pid in live if _pid_alive(pid)}
-        for pid in survivors:
-            try:
-                os.kill(pid, signal.SIGKILL)
-            except ProcessLookupError:
-                pass
-            except OSError:
-                pass
+        _signal_processes(survivors, signal.SIGKILL)
         deadline = time.monotonic() + grace_seconds
         while time.monotonic() < deadline and any(
             _pid_alive(pid) for pid in survivors
@@ -282,11 +285,7 @@ class PosixProcessSupervisor:
         return CleanupOutcome(
             bounded=bounded,
             descendants_found=True,
-            error=(
-                None
-                if bounded
-                else "detached descendants survived bounded termination"
-            ),
+            error=None if bounded else "detached descendants survived bounded termination",
         )
 
     def terminate(

{engineering_process-1.0.0 → engineering_process-1.1.0}/engineering_process/cli.py

@@ -34,7 +34,7 @@ from .lifecycle import (
     submit_review,
     verify_change,
 )
-from .project import load_project
+from .project import load_project, readiness_summary
 from .publication_compat import (
     branch_issues,
     commit_issues,
@@ -97,6 +97,7 @@ def command_project_validate(args: argparse.Namespace) -> Result:
         project=project["project"],
         profiles=sorted(project["profiles"]),
         requiredProfiles=project["lifecycle"]["requiredProfiles"],
+        readiness=readiness_summary(project),
     ), 0
 
 
@@ -155,6 +156,7 @@ def command_doctor(args: argparse.Namespace) -> Result:
         project=project["project"],
         processVersion=VERSION,
         profiles=sorted(project["profiles"]),
+        readiness=readiness_summary(project),
         issues=issues,
     ), (0 if not issues else 1)
 
@@ -341,47 +343,27 @@ def command_change_status(args: argparse.Namespace) -> Result:
 
 
 def command_release_validate(args: argparse.Namespace) -> Result:
-    details = validate_release(
-        args.project_root, _process_root(args), tag=args.tag
-    )
+    details = validate_release(args.project_root, _process_root(args), tag=args.tag)
     return _result("release validate", **details), 0
 
 
-def _publication_result(command: str, details: dict[str, Any]) -> Result:
-    issues = details["issues"]
-    status = "passed" if not issues else "failed"
-    return _result(command, status=status, **details), (0 if not issues else 1)
-
-
-def command_publication_branch(args: argparse.Namespace) -> Result:
-    return _publication_result(
-        "publication validate-branch", {"issues": branch_issues(args.branch)}
-    )
-
-
-def command_publication_commit(args: argparse.Namespace) -> Result:
-    return _publication_result(
-        "publication validate-commit", {"issues": commit_issues(args.subject)}
-    )
-
-
-def command_publication_range(args: argparse.Namespace) -> Result:
-    return _publication_result(
-        "publication validate-range",
-        validate_range(args.project_root, args.branch, args.range_spec),
-    )
-
-
-def command_publication_pr(args: argparse.Namespace) -> Result:
-    return _publication_result(
-        "publication validate-pr",
-        validate_pull_request(
+def command_publication(args: argparse.Namespace) -> Result:
+    name = args.publication_command
+    if name == "validate-branch":
+        details = {"issues": branch_issues(args.branch)}
+    elif name == "validate-commit":
+        details = {"issues": commit_issues(args.subject)}
+    elif name == "validate-range":
+        details = validate_range(args.project_root, args.branch, args.range_spec)
+    else:
+        details = validate_pull_request(
             title=args.title,
             branch=args.branch,
             state=args.state,
             body_path=args.body_file,
-        ),
-    )
+        )
+    status = "passed" if not details["issues"] else "failed"
+    return _result(f"publication {name}", status=status, **details), (0 if status == "passed" else 1)
 
 
 def _add_common(parser: argparse.ArgumentParser, *, project: bool = True) -> None:
@@ -397,151 +379,113 @@ def _add_actor(parser: argparse.ArgumentParser) -> None:
     parser.add_argument("--actor-kind", choices=("agent", "human"), default="agent")
 
 
+def _leaf(subparsers: Any, name: str, handler: Callable[..., Result], *, project: bool = True, help: str | None = None) -> argparse.ArgumentParser:
+    parser = subparsers.add_parser(name, help=help)
+    _add_common(parser, project=project)
+    parser.set_defaults(handler=handler)
+    return parser
+
+
 def build_parser() -> argparse.ArgumentParser:
     parser = argparse.ArgumentParser(
         prog="processctl", description="Small, enforceable engineering process"
     )
     parser.add_argument("--version", action="version", version=VERSION)
     commands = parser.add_subparsers(dest="command", required=True)
-
     project = commands.add_parser("project", help="Validate consumer configuration")
     project_commands = project.add_subparsers(dest="project_command", required=True)
-    project_validate = project_commands.add_parser("validate")
-    _add_common(project_validate)
-    project_validate.set_defaults(handler=command_project_validate)
-
+    _leaf(project_commands, "validate", command_project_validate)
     lock = commands.add_parser("lock", help="Validate the adopted process lock")
     lock_commands = lock.add_subparsers(dest="lock_command", required=True)
-    lock_validate = lock_commands.add_parser("validate")
-    _add_common(lock_validate)
-    lock_validate.set_defaults(handler=command_lock_validate)
-
+    _leaf(lock_commands, "validate", command_lock_validate)
     contract = commands.add_parser("contract", help="Validate a JSON contract")
     contract_commands = contract.add_subparsers(dest="contract_command", required=True)
-    contract_validate = contract_commands.add_parser("validate")
+    contract_validate = _leaf(
+        contract_commands, "validate", command_contract_validate, project=False
+    )
     contract_validate.add_argument("--kind", choices=CONTRACT_KINDS, required=True)
     contract_validate.add_argument("path", type=Path)
-    _add_common(contract_validate, project=False)
-    contract_validate.set_defaults(handler=command_contract_validate)
-
     skills = commands.add_parser("skills", help="Validate the complete skill graph")
     skills_commands = skills.add_subparsers(dest="skills_command", required=True)
-    skills_validate = skills_commands.add_parser("validate")
+    skills_validate = _leaf(
+        skills_commands, "validate", command_skills_validate, project=False
+    )
     skills_validate.add_argument("--root", type=Path)
-    _add_common(skills_validate, project=False)
-    skills_validate.set_defaults(handler=command_skills_validate)
-
-    doctor = commands.add_parser("doctor", help="Validate one consumer integration")
-    _add_common(doctor)
+    doctor = _leaf(commands, "doctor", command_doctor, help="Validate one consumer integration")
     doctor.add_argument("--profile")
-    doctor.set_defaults(handler=command_doctor)
-
-    setup = commands.add_parser("setup", help=argparse.SUPPRESS)
-    _add_common(setup)
+    setup = _leaf(commands, "setup", command_setup, help=argparse.SUPPRESS)
     setup.add_argument("--profile", required=True)
     setup.add_argument("--apply", action="store_true")
     setup.add_argument("--allow", action="append", default=[])
-    setup.set_defaults(handler=command_setup)
-
-    verify = commands.add_parser("verify", help="Run a project verification profile")
-    _add_common(verify)
+    verify = _leaf(commands, "verify", command_verify, help="Run a project verification profile")
     verify.add_argument("--profile", required=True)
-    verify.set_defaults(handler=command_verify)
-
     adoption = commands.add_parser("adoption", help="Apply or check managed adoption")
     adoption_commands = adoption.add_subparsers(dest="adoption_command", required=True)
     for name, handler in (("apply", command_adoption_apply), ("check", command_adoption_check)):
-        adoption_command = adoption_commands.add_parser(name)
-        _add_common(adoption_command)
+        adoption_command = _leaf(adoption_commands, name, handler)
         adoption_command.add_argument("--requirements-lock", type=Path, required=True)
         if name == "apply":
             adoption_command.add_argument("--requirements-source", type=Path)
             adoption_command.add_argument("--expected-requirements-digest")
-        adoption_command.set_defaults(handler=handler)
-
     change = commands.add_parser("change", help="Run the six-phase change lifecycle")
     change_commands = change.add_subparsers(dest="change_command", required=True)
-
-    change_start = change_commands.add_parser("start")
-    _add_common(change_start)
+    change_start = _leaf(change_commands, "start", command_change_start)
     _add_actor(change_start)
     change_start.add_argument("--contract", type=Path, required=True)
-    change_start.set_defaults(handler=command_change_start)
-
-    change_plan = change_commands.add_parser("plan")
-    _add_common(change_plan)
+    change_plan = _leaf(change_commands, "plan", command_change_plan)
     _add_actor(change_plan)
     change_plan.add_argument("--change-id", required=True)
     change_plan.add_argument("--plan", type=Path, required=True)
-    change_plan.set_defaults(handler=command_change_plan)
-
-    change_implement = change_commands.add_parser("implement")
-    _add_common(change_implement)
+    change_implement = _leaf(change_commands, "implement", command_change_implement)
     _add_actor(change_implement)
     change_implement.add_argument("--change-id", required=True)
-    change_implement.set_defaults(handler=command_change_implement)
-
-    change_verify = change_commands.add_parser("verify")
-    _add_common(change_verify)
+    change_verify = _leaf(change_commands, "verify", command_change_verify)
     change_verify.add_argument("--change-id", required=True)
     change_verify.add_argument("--profile", required=True)
-    change_verify.set_defaults(handler=command_change_verify)
 
     review = change_commands.add_parser("review")
     review_commands = review.add_subparsers(dest="review_command", required=True)
-    review_start = review_commands.add_parser("start")
-    _add_common(review_start)
+    review_start = _leaf(review_commands, "start", command_change_review_start)
     _add_actor(review_start)
     review_start.add_argument("--change-id", required=True)
-    review_start.set_defaults(handler=command_change_review_start)
-    review_submit = review_commands.add_parser("submit")
-    _add_common(review_submit)
+    review_submit = _leaf(review_commands, "submit", command_change_review_submit)
     review_submit.add_argument("--change-id", required=True)
     review_submit.add_argument("--review", type=Path, required=True)
-    review_submit.set_defaults(handler=command_change_review_submit)
 
-    change_finish = change_commands.add_parser("finish")
-    _add_common(change_finish)
+    change_finish = _leaf(change_commands, "finish", command_change_finish)
     _add_actor(change_finish)
     change_finish.add_argument("--change-id", required=True)
-    change_finish.set_defaults(handler=command_change_finish)
 
-    change_status = change_commands.add_parser("status")
-    _add_common(change_status)
+    change_status = _leaf(change_commands, "status", command_change_status)
     change_status.add_argument("--change-id", required=True)
-    change_status.set_defaults(handler=command_change_status)
 
     release = commands.add_parser("release", help="Validate release identity")
     release_commands = release.add_subparsers(dest="release_command", required=True)
-    release_validate = release_commands.add_parser("validate")
-    _add_common(release_validate)
+    release_validate = _leaf(release_commands, "validate", command_release_validate)
     release_validate.add_argument("--tag")
-    release_validate.set_defaults(handler=command_release_validate)
 
     publication = commands.add_parser("publication", help=argparse.SUPPRESS)
     publication_commands = publication.add_subparsers(
         dest="publication_command", required=True
     )
-    publication_branch = publication_commands.add_parser("validate-branch")
+    publication_branch = _leaf(
+        publication_commands, "validate-branch", command_publication, project=False
+    )
     publication_branch.add_argument("--branch", required=True)
-    _add_common(publication_branch, project=False)
-    publication_branch.set_defaults(handler=command_publication_branch)
-    publication_commit = publication_commands.add_parser("validate-commit")
+    publication_commit = _leaf(
+        publication_commands, "validate-commit", command_publication, project=False
+    )
     publication_commit.add_argument("--subject", required=True)
-    _add_common(publication_commit, project=False)
-    publication_commit.set_defaults(handler=command_publication_commit)
-    publication_range = publication_commands.add_parser("validate-range")
-    _add_common(publication_range)
+    publication_range = _leaf(publication_commands, "validate-range", command_publication)
     publication_range.add_argument("--branch", required=True)
     publication_range.add_argument("--range", dest="range_spec", required=True)
-    publication_range.set_defaults(handler=command_publication_range)
-    publication_pr = publication_commands.add_parser("validate-pr")
+    publication_pr = _leaf(
+        publication_commands, "validate-pr", command_publication, project=False
+    )
     publication_pr.add_argument("--title", required=True)
     publication_pr.add_argument("--branch", required=True)
     publication_pr.add_argument("--state", required=True)
     publication_pr.add_argument("--body-file", type=Path)
-    _add_common(publication_pr, project=False)
-    publication_pr.set_defaults(handler=command_publication_pr)
     return parser
 
 

{engineering_process-1.0.0 → engineering_process-1.1.0}/engineering_process/project.py

@@ -10,6 +10,11 @@ from .distribution import schemas_root
 
 
 PROJECT_SCHEMA_VERSION = 5
+PACK_CAPABILITIES = {
+    ("desktop-media", 1): set("application-correctness authoritative-input-integrity cross-platform-portability dependency-audit dependency-security incident-recovery independent-security-review key-custody linux-release-security media-pipeline-integrity package-security recovery-integrity recovery-mechanism-integrity release-integrity runtime-delivery-integrity update-integrity workspace-security".split()),
+    ("library-cli", 1): set("adoption-integrity compatibility correctness distribution-integrity installability portability runtime-safety".split()),
+    ("operations", 1): set("auditability automation-correctness bounded-execution least-privilege policy-integrity recovery target-selection-integrity".split()),
+}
 
 
 def project_path(project_root: Path) -> Path:
@@ -17,7 +22,16 @@ def project_path(project_root: Path) -> Path:
 
 
 def load_project(project_root: Path, process_root: Path) -> dict[str, Any]:
-    return normalize_project(read_json(project_path(project_root)), process_root)
+    project = normalize_project(read_json(project_path(project_root)), process_root)
+    path = project_root / ".process" / "readiness.json"
+    if not path.is_file():
+        return project
+    if "readiness" in project:
+        raise ProcessError("readiness must use either project.json or readiness.json, not both")
+    project["readiness"] = read_json(path)
+    validate_document(project, "project", schema_root=schemas_root(process_root), source=str(path))
+    readiness_summary(project)
+    return project
 
 
 def normalize_project(value: Any, process_root: Path) -> dict[str, Any]:
@@ -103,9 +117,52 @@ def normalize_project(value: Any, process_root: Path) -> dict[str, Any]:
         schema_root=schemas_root(process_root),
         source="normalized project configuration",
     )
+    missing = sorted(set(required_profiles(normalized)) - set(normalized["profiles"]))
+    if missing:
+        raise ProcessError("project requires unknown profiles: " + ", ".join(missing))
+    readiness_summary(normalized)
     return normalized
 
 
+def readiness_summary(project: dict[str, Any]) -> dict[str, Any] | None:
+    readiness = project.get("readiness")
+    if readiness is None:
+        return None
+    entries = readiness["capabilities"]
+    capabilities = {item["id"]: item for item in entries}
+    if len(capabilities) != len(entries):
+        raise ProcessError("readiness capability ids must be unique")
+    packs = [(item["id"], item["version"]) for item in readiness["packs"]]
+    unsupported = [f"{name}@{version}" for name, version in packs if (name, version) not in PACK_CAPABILITIES]
+    if unsupported:
+        raise ProcessError("unsupported readiness pack versions: " + ", ".join(unsupported))
+    required = set().union(*(PACK_CAPABILITIES[pack] for pack in packs))
+    missing = sorted(required - capabilities.keys())
+    if missing:
+        raise ProcessError("readiness packs require missing capabilities: " + ", ".join(missing))
+    available = set(project["profiles"])
+    mandatory_profiles = set(required_profiles(project))
+    coverage: dict[str, Any] = {}
+    planned: list[str] = []
+    for capability_id, item in sorted(capabilities.items()):
+        if item["state"] == "planned":
+            coverage[capability_id] = {"state": "planned", "gap": item["gap"]}
+            planned.append(capability_id)
+            continue
+        evidence = set(item["evidenceProfiles"])
+        unknown = sorted(evidence - available)
+        if unknown:
+            raise ProcessError(f"readiness capability {capability_id} references unknown profiles: " + ", ".join(unknown))
+        if evidence.isdisjoint(mandatory_profiles):
+            raise ProcessError(f"readiness capability {capability_id} relies only on optional profiles: " + ", ".join(sorted(evidence)))
+        coverage[capability_id] = {"state": "enforced", "evidence": {
+            name: [check["id"] for check in project["profiles"][name]] for name in item["evidenceProfiles"]
+        }}
+    if readiness["stage"] == "production" and planned:
+        raise ProcessError("production readiness cannot contain planned capabilities: " + ", ".join(planned))
+    return {"target": readiness["target"], "stage": readiness["stage"], "packs": readiness["packs"], "capabilities": coverage, "plannedCapabilities": planned}
+
+
 def required_profiles(project: dict[str, Any]) -> tuple[str, ...]:
     return tuple(project["lifecycle"]["requiredProfiles"])