engineering-process 0.6.0__tar.gz → 0.6.1__tar.gz

{engineering_process-0.6.0/engineering_process.egg-info → engineering_process-0.6.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: engineering-process
-Version: 0.6.0
+Version: 0.6.1
 Summary: Agent-neutral end-to-end engineering lifecycle and deterministic process CLI
 License-Expression: MIT
 Project-URL: Homepage, https://github.com/phuongnse/engineering-process
@@ -291,6 +291,14 @@ project-native dependency commands, dependency edges, and remediation. Project s
 does not carry a generic downloader, archive installer, doctor, or setup lifecycle.
 Host prerequisites with no safe automated setup action stay blocking.
 
+The exact logical executable `python` is reserved by the distribution and resolves to
+the absolute interpreter running the selected immutable process authority. This rule
+applies consistently to requirement probes, verification profiles, setup command
+actions, and `processctl exec`; callers do not activate a virtual environment or
+modify `PATH` first. Manifests and reports retain the portable logical token, managed
+tools cannot shadow it, and absolute executables plus non-Python commands keep their
+existing resolution behavior.
+
 Probe `readOnly`, foreground-only execution, and command-action mutation scopes are
 project-owner attestations, not an operating-system sandbox: `processctl` cannot infer
 arbitrary subprocess side effects. Commands must not daemonize, start a detached

{engineering_process-0.6.0 → engineering_process-0.6.1}/PRODUCTION_STANDARD.md

@@ -55,6 +55,12 @@ canonical command, or installing a consumer wrapper. Durable reports record only
 policy, severity, stream, line number, bounded count, truncation state, and line
 SHA-256. They never copy the diagnostic line into lifecycle evidence.
 
+The portable logical command `python` resolves to the exact absolute interpreter of
+the running immutable process authority across doctor, setup, execution, and
+verification. Ambient `PATH` cannot select another Python installation, managed tools
+cannot shadow the reserved binding, and evidence retains the logical command rather
+than a host-specific activation sequence.
+
 Missing, stale, truncated beyond a declared policy, blocked, or unverifiable evidence
 never becomes a pass. Independent review records each accepted dimension as
 `verified`, `failed`, or `not-applicable-confirmed`; lifecycle submission compares

{engineering_process-0.6.0 → engineering_process-0.6.1}/README.md

@@ -256,6 +256,14 @@ project-native dependency commands, dependency edges, and remediation. Project s
 does not carry a generic downloader, archive installer, doctor, or setup lifecycle.
 Host prerequisites with no safe automated setup action stay blocking.
 
+The exact logical executable `python` is reserved by the distribution and resolves to
+the absolute interpreter running the selected immutable process authority. This rule
+applies consistently to requirement probes, verification profiles, setup command
+actions, and `processctl exec`; callers do not activate a virtual environment or
+modify `PATH` first. Manifests and reports retain the portable logical token, managed
+tools cannot shadow it, and absolute executables plus non-Python commands keep their
+existing resolution behavior.
+
 Probe `readOnly`, foreground-only execution, and command-action mutation scopes are
 project-owner attestations, not an operating-system sandbox: `processctl` cannot infer
 arbitrary subprocess side effects. Commands must not daemonize, start a detached

{engineering_process-0.6.0 → engineering_process-0.6.1}/engineering_process/__init__.py

@@ -1,3 +1,3 @@
 """Agent-neutral engineering process."""
 
-VERSION = "0.6.0"
+VERSION = "0.6.1"

{engineering_process-0.6.0 → engineering_process-0.6.1}/engineering_process/environment.py

@@ -9,13 +9,14 @@ import threading
 import time
 from datetime import UTC, datetime
 from pathlib import Path
-from typing import Any, Mapping
+from typing import Any, Iterable, Mapping
 
 import regex as bounded_regex
 
 from .contracts import (
     ContractError,
     EnvironmentRequirement,
+    ManagedTool,
     MUTATION_SCOPES,
     Project,
     ProjectEnvironment,
@@ -479,10 +480,29 @@ def environment_path_entries(
     return tuple(entries)
 
 
+def _authority_command_bindings(
+    tools: Iterable[ManagedTool],
+) -> dict[str, ManagedCommandBinding]:
+    bindings = managed_command_bindings(tools)
+    if "python" in bindings:
+        raise ContractError(
+            "managed tools cannot provide the reserved authority command: python"
+        )
+    authority_python = Path(sys.executable)
+    if not authority_python.is_absolute() or not authority_python.is_file():
+        raise ContractError(
+            "the active process authority does not expose an absolute Python executable"
+        )
+    return {
+        "python": ManagedCommandBinding(application=authority_python),
+        **bindings,
+    }
+
+
 def environment_command_bindings(
     project: Project, *, profile: str
 ) -> dict[str, ManagedCommandBinding]:
-    return managed_command_bindings(
+    return _authority_command_bindings(
         _environment_managed_tools(project, profile=profile)
     )
 
@@ -684,7 +704,7 @@ def setup_environment(
         installed_paths = ()
         preflight_issues.append(str(error))
     try:
-        installed_bindings = managed_command_bindings(
+        installed_bindings = _authority_command_bindings(
             environment.managed_tools[identifier]
             for identifier in sorted(planned_tool_ids)
         )
@@ -698,9 +718,18 @@ def setup_environment(
                 tool = environment.managed_tools[action.tool]
                 artifact = selected_artifact(tool)
                 issue = None
+                if "python" in artifact.commands:
+                    issue = (
+                        f"setup action {action.identifier}: managed tools cannot provide "
+                        "the reserved authority command: python"
+                    )
                 install_issue = managed_tool_preflight(tool)
                 if install_issue is not None:
-                    issue = f"setup action {action.identifier}: {install_issue}"
+                    issue = (
+                        f"{issue}; {install_issue}"
+                        if issue is not None
+                        else f"setup action {action.identifier}: {install_issue}"
+                    )
                 for command_name in artifact.commands:
                     previous = provided_commands.get(command_name)
                     if previous is not None and previous != action.identifier:
@@ -841,7 +870,7 @@ def setup_environment(
                         environment.managed_tools[identifier]
                         for identifier in sorted(planned_tool_ids)
                     ),
-                    command_bindings=managed_command_bindings(
+                    command_bindings=_authority_command_bindings(
                         environment.managed_tools[identifier]
                         for identifier in sorted(planned_tool_ids)
                     ),

{engineering_process-0.6.0 → engineering_process-0.6.1/engineering_process.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: engineering-process
-Version: 0.6.0
+Version: 0.6.1
 Summary: Agent-neutral end-to-end engineering lifecycle and deterministic process CLI
 License-Expression: MIT
 Project-URL: Homepage, https://github.com/phuongnse/engineering-process
@@ -291,6 +291,14 @@ project-native dependency commands, dependency edges, and remediation. Project s
 does not carry a generic downloader, archive installer, doctor, or setup lifecycle.
 Host prerequisites with no safe automated setup action stay blocking.
 
+The exact logical executable `python` is reserved by the distribution and resolves to
+the absolute interpreter running the selected immutable process authority. This rule
+applies consistently to requirement probes, verification profiles, setup command
+actions, and `processctl exec`; callers do not activate a virtual environment or
+modify `PATH` first. Manifests and reports retain the portable logical token, managed
+tools cannot shadow it, and absolute executables plus non-Python commands keep their
+existing resolution behavior.
+
 Probe `readOnly`, foreground-only execution, and command-action mutation scopes are
 project-owner attestations, not an operating-system sandbox: `processctl` cannot infer
 arbitrary subprocess side effects. Commands must not daemonize, start a detached

{engineering_process-0.6.0 → engineering_process-0.6.1}/improvement-catalog.json

@@ -4,8 +4,8 @@
       "activeChangeId": null,
       "id": "deterministic-cross-platform-test-environment",
       "lastResolution": {
-        "changeId": "extend-windows-natural-drain",
-        "version": "0.5.1"
+        "changeId": "bind-authority-python-runtime-v2",
+        "version": "0.6.1"
       },
       "publicSurfaces": [
         "cross-platform-tests",

{engineering_process-0.6.0 → engineering_process-0.6.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "engineering-process"
-version = "0.6.0"
+version = "0.6.1"
 description = "Agent-neutral end-to-end engineering lifecycle and deterministic process CLI"
 readme = "README.md"
 license = "MIT"

engineering_process-0.6.1/release.json

@@ -0,0 +1,46 @@
+{
+  "schemaVersion": 3,
+  "previousVersion": "0.6.0",
+  "version": "0.6.1",
+  "classification": "patch",
+  "compatibility": "backward-compatible",
+  "schemaImpact": "unchanged",
+  "migration": null,
+  "identity": {
+    "package": "engineering-process",
+    "distribution": "engineering_process",
+    "tag": "v0.6.1",
+    "releaseName": "v0.6.1",
+    "runtimeVersion": {
+      "path": "engineering_process/__init__.py",
+      "variable": "VERSION"
+    },
+    "artifacts": [
+      "engineering_process-0.6.1-py3-none-any.whl",
+      "engineering_process-0.6.1.tar.gz"
+    ],
+    "receiptAsset": "engineering-process-v0.6.1-evidence.json",
+    "authorizationAsset": null
+  },
+  "provenance": {
+    "mode": "governed",
+    "statement": "The public N-1 lifecycle receipt and reviewed Release PR authorize this release.",
+    "lifecycleReceipt": {
+      "asset": "engineering-process-v0.6.1-evidence.json",
+      "project": "engineering-process",
+      "changeId": "release-0-6-1",
+      "cycle": 1
+    }
+  },
+  "changes": [
+    {
+      "id": "bind-authority-python-runtime-v2",
+      "type": "fix",
+      "surfaces": [
+        "command-execution",
+        "environment-resolution"
+      ],
+      "rationale": "Bind the portable logical command python to the exact interpreter running the immutable process authority across doctor, setup, exec, and verification so ambient shell PATH cannot select an unrelated Python runtime or require consumer activation wrappers."
+    }
+  ]
+}

{engineering_process-0.6.0 → engineering_process-0.6.1}/tests/test_environment.py

@@ -12,6 +12,7 @@ from unittest.mock import patch
 from engineering_process.contracts import ContractError, validate_project
 from engineering_process.environment import (
     doctor_environment,
+    environment_command_bindings,
     execute_command,
     setup_environment,
 )
@@ -30,7 +31,7 @@ def project_document(*, setup: bool = True, dependency: bool = False):
                 "id": "prepare-parent",
                 "kind": "command",
                 "run": [
-                    sys.executable,
+                    "python",
                     "-c",
                     "from pathlib import Path; Path('parent.txt').write_text('ready')",
                 ],
@@ -46,7 +47,7 @@ def project_document(*, setup: bool = True, dependency: bool = False):
         action = {
             "id": "prepare-environment",
             "kind": "command",
-            "run": [sys.executable, "-c", command],
+            "run": ["python", "-c", command],
             "timeoutSeconds": 30,
             "mutations": ["project-files"],
         }
@@ -58,7 +59,7 @@ def project_document(*, setup: bool = True, dependency: bool = False):
         "id": "project-environment",
         "description": "Project environment marker",
         "probe": {
-            "run": [sys.executable, "-c", ready_probe],
+            "run": ["python", "-c", ready_probe],
             "timeoutSeconds": 30,
             "readOnly": True,
         },
@@ -74,14 +75,14 @@ def project_document(*, setup: bool = True, dependency: bool = False):
             "development": [
                 {
                     "id": "unit",
-                    "run": [sys.executable, "-c", "raise SystemExit(0)"],
+                    "run": ["python", "-c", "raise SystemExit(0)"],
                     "timeoutSeconds": 30,
                 }
             ],
             "review": [
                 {
                     "id": "review",
-                    "run": [sys.executable, "-c", "raise SystemExit(0)"],
+                    "run": ["python", "-c", "raise SystemExit(0)"],
                     "timeoutSeconds": 30,
                 }
             ],
@@ -101,6 +102,44 @@ def project_document(*, setup: bool = True, dependency: bool = False):
 
 
 class EnvironmentTests(unittest.TestCase):
+    def test_portable_python_uses_authority_without_path_activation(self):
+        with tempfile.TemporaryDirectory() as directory:
+            root = Path(directory)
+            project = validate_project(project_document(setup=False))
+            bindings = environment_command_bindings(project, profile="development")
+
+            with patch.dict(os.environ, {"PATH": str(root)}):
+                report = execute_command(
+                    root,
+                    identifier="authority-python",
+                    run=("python", "-c", "import sys; print(sys.executable)"),
+                    timeout_seconds=30,
+                    working_directory=".",
+                    command_bindings=bindings,
+                )
+
+            self.assertEqual("passed", report["status"])
+            self.assertEqual(
+                ["python", "-c", "import sys; print(sys.executable)"],
+                report["command"],
+            )
+            self.assertEqual(Path(sys.executable), Path(report["stdout"].strip()))
+
+    def test_managed_tool_cannot_shadow_the_authority_python_binding(self):
+        project = validate_project(project_document(setup=False))
+        shadow = ManagedCommandBinding(application=Path(sys.executable))
+
+        with (
+            patch(
+                "engineering_process.environment.managed_command_bindings",
+                return_value={"python": shadow},
+            ),
+            self.assertRaisesRegex(
+                ContractError, "reserved authority command: python"
+            ),
+        ):
+            environment_command_bindings(project, profile="development")
+
     def test_exit_zero_warning_or_error_diagnostic_fails_closed(self):
         cases = (
             ("stdout", "WARN: degraded validation"),
@@ -254,6 +293,25 @@ class EnvironmentTests(unittest.TestCase):
             self.assertEqual("missing", report["requirements"][0]["status"])
             self.assertFalse((root / "ready.txt").exists())
 
+    def test_doctor_uses_authority_python_when_ambient_path_has_no_python(self):
+        with tempfile.TemporaryDirectory() as directory:
+            root = Path(directory)
+            document = project_document(setup=False)
+            document["environment"]["requirements"][0]["probe"] = {
+                "run": ["python", "-c", "print('authority ready')"],
+                "timeoutSeconds": 30,
+                "readOnly": True,
+                "outputStream": "stdout",
+                "outputRegex": "^authority ready$",
+            }
+            project = validate_project(document)
+
+            with patch.dict(os.environ, {"PATH": str(root)}):
+                report = doctor_environment(root, project)
+
+            self.assertEqual("passed", report["status"])
+            self.assertEqual("satisfied", report["requirements"][0]["status"])
+
     def test_setup_plan_does_not_mutate_and_lists_required_approval(self):
         with tempfile.TemporaryDirectory() as directory:
             root = Path(directory)
@@ -625,6 +683,28 @@ class EnvironmentTests(unittest.TestCase):
             self.assertIn("not a directory", "\n".join(report["blocked"]))
             self.assertFalse((root / "mutated").exists())
 
+    def test_setup_rejects_managed_tool_that_provides_reserved_python(self):
+        with tempfile.TemporaryDirectory() as directory:
+            root = Path(directory)
+            document = self.managed_setup_document()
+            artifact = document["environment"]["managedTools"][0]["artifacts"][0]
+            executable = "python.exe" if os.name == "nt" else "python"
+            artifact["commands"] = {"python": executable}
+            project = validate_project(document)
+
+            report = setup_environment(
+                root,
+                project,
+                profile=None,
+                apply=False,
+                allowed_mutations=set(),
+            )
+
+            self.assertEqual("blocked", report["status"])
+            self.assertIn(
+                "reserved authority command: python", "\n".join(report["blocked"])
+            )
+
     def test_setup_preserves_partial_evidence_for_operational_installer_error(self):
         with tempfile.TemporaryDirectory() as directory:
             root = Path(directory)

{engineering_process-0.6.0 → engineering_process-0.6.1}/tests/test_runner.py

@@ -84,6 +84,35 @@ class RunnerTests(unittest.TestCase):
             ]
             validate_verification(legacy)
 
+    def test_profile_uses_authority_python_from_portable_command(self):
+        with tempfile.TemporaryDirectory() as directory:
+            root = Path(directory)
+            project = Project(
+                identifier="sample",
+                profiles={
+                    "development": (
+                        Check(
+                            identifier="portable-python",
+                            run=(
+                                "python",
+                                "-c",
+                                "import sys; print(sys.executable)",
+                            ),
+                            timeout_seconds=10,
+                            working_directory=".",
+                        ),
+                    )
+                },
+            )
+
+            with patch(
+                "engineering_process.environment.sys.stderr", io.StringIO()
+            ):
+                report = run_profile(root, project, "development")
+
+            self.assertEqual("passed", report["status"])
+            self.assertEqual("python", report["checks"][0]["command"][0])
+
     def test_warning_after_evidence_prefix_and_split_across_writes_fails(self):
         with tempfile.TemporaryDirectory() as directory:
             root = Path(directory)

engineering_process-0.6.0/release.json

@@ -1,51 +0,0 @@
-{
-  "schemaVersion": 3,
-  "previousVersion": "0.5.1",
-  "version": "0.6.0",
-  "classification": "minor",
-  "compatibility": "incompatible",
-  "schemaImpact": "additive",
-  "migration": "evidence-valid-remote-verification: After immutable release and adoption, route every new material owner decision through recommendation review and resolution. Projects that need remote claims separately add named remoteVerification requirements to the target-version project manifest and select them through requiredEvidence on new change contracts; historical decisions and completed lifecycles require no backfill.",
-  "identity": {
-    "package": "engineering-process",
-    "distribution": "engineering_process",
-    "tag": "v0.6.0",
-    "releaseName": "v0.6.0",
-    "runtimeVersion": {
-      "path": "engineering_process/__init__.py",
-      "variable": "VERSION"
-    },
-    "artifacts": [
-      "engineering_process-0.6.0-py3-none-any.whl",
-      "engineering_process-0.6.0.tar.gz"
-    ],
-    "receiptAsset": "engineering-process-v0.6.0-evidence.json",
-    "authorizationAsset": null
-  },
-  "provenance": {
-    "mode": "governed",
-    "statement": "The public N-1 lifecycle receipt and reviewed Release PR authorize this release.",
-    "lifecycleReceipt": {
-      "asset": "engineering-process-v0.6.0-evidence.json",
-      "project": "engineering-process",
-      "changeId": "release-0-6-0",
-      "cycle": 1
-    }
-  },
-  "changes": [
-    {
-      "id": "evidence-valid-remote-verification",
-      "type": "breaking",
-      "surfaces": [
-        "cli",
-        "governance",
-        "lifecycle",
-        "recommendation",
-        "schema",
-        "skills",
-        "verification"
-      ],
-      "rationale": "Require evidence-derived valid recommendations with stateful independent challenge, and add project-owned exact-checkpoint remote evidence requests whose complete selector set must be ingested before review or completion."
-    }
-  ]
-}