pactkit-codex 2.25.1__tar.gz → 2.26.0__tar.gz

{pactkit_codex-2.25.1/src/pactkit_codex.egg-info → pactkit_codex-2.26.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pactkit-codex
-Version: 2.25.1
+Version: 2.26.0
 Summary: PactKit adapter for OpenAI Codex CLI
 Author: Slim
 License: MIT
@@ -21,7 +21,7 @@ Classifier: Topic :: Software Development :: Quality Assurance
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: pactkit<2.26.0,>=2.25.1
+Requires-Dist: pactkit<2.27.0,>=2.26.0
 Requires-Dist: tomli>=1.1.0; python_version < "3.11"
 Dynamic: license-file
 

{pactkit_codex-2.25.1 → pactkit_codex-2.26.0}/pyproject.toml

@@ -4,13 +4,13 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pactkit-codex"
-version = "2.25.1"
+version = "2.26.0"
 description = "PactKit adapter for OpenAI Codex CLI"
 readme = "README.md"
 license = {text = "MIT"}
 requires-python = ">=3.10"
 dependencies = [
-    "pactkit>=2.25.1,<2.26.0",
+    "pactkit>=2.26.0,<2.27.0",
     "tomli>=1.1.0; python_version < '3.11'",
 ]
 

{pactkit_codex-2.25.1 → pactkit_codex-2.26.0}/src/pactkit_codex/deployer.py

@@ -701,6 +701,14 @@ class CodexDeployer(DeployerBase):
                     previous_hashes = files
             except (OSError, ValueError, TypeError):
                 pass
+        # STORY-slim-20260903a24e1ece0d7f: merged ownership view — the deploy
+        # check previously read only .pactkit-deployed.json (which never carries
+        # reference paths), so every content change produced a .pactkit-new
+        # candidate. Same merge as _cleanup_stale_command_references.
+        ownership_proofs = {
+            **previous_hashes,
+            **read_command_references(codex_root / "skills"),
+        }
         rendered: dict[str, str] = {}
         references_by_command: dict[str, dict[Path, str]] = {}
 
@@ -844,7 +852,13 @@ class CodexDeployer(DeployerBase):
                     )
                     rendered_bytes = reference_content.encode("utf-8")
                     relative_to_root = reference.relative_to(codex_root).as_posix()
-                    expected_hash = previous_hashes.get(relative_to_root)
+                    # STORY-slim-20260903a24e1ece0d7f: merge the command-manifest
+                    # references table into the ownership view — the deploy path
+                    # previously read only .pactkit-deployed.json, which never
+                    # carried reference paths, so every content change produced a
+                    # .pactkit-new candidate (three recurrences on 2026-09-03).
+                    # Same merged view as _cleanup_stale_command_references.
+                    expected_hash = ownership_proofs.get(relative_to_root)
                     if reference.is_file():
                         actual_hash = hashlib.sha256(reference.read_bytes()).hexdigest()
                         rendered_hash = hashlib.sha256(rendered_bytes).hexdigest()
@@ -909,15 +923,17 @@ class CodexDeployer(DeployerBase):
 
     @staticmethod
     def generate_codex_config_toml(codex_root):
-        """Create config.toml for Codex CLI — but NEVER modify an existing one.
+        """Suggest Codex CLI settings — but NEVER write config.toml.
 
         config.toml carries the user's providers, MCP servers, project trust
-        and other sensitive state. PactKit's share is two scalar defaults and
-        one MCP entry — not worth any write risk. Policy (2026-08-13, user
-        directive after two wipe incidents):
-          - File exists  -> leave it BYTE-IDENTICAL, print the recommended
-            settings for the user to add by hand.
-          - File missing -> create it with the PactKit-managed sections.
+        and other sensitive state. Policy (2026-08-13, user directive after
+        two wipe incidents; extended 2026-09-11 by
+        STORY-slim-20260911b2bbd79889e0 A2/R3+R4):
+          - File exists  -> leave it BYTE-IDENTICAL.
+          - File missing -> ALSO leave it missing. Creating it seeded with
+            host-permission scalars and an MCP server was injection, not
+            convenience — the user starts their own config, and PactKit
+            prints what it would have suggested instead.
         """
         config_path = codex_root / "config.toml"
 
@@ -925,16 +941,12 @@ class CodexDeployer(DeployerBase):
             print("  ℹ️ config.toml exists — left untouched (PactKit never modifies it)")
             return
 
-        lines = [
-            "# [pactkit:managed]",
-            'sandbox_mode = "workspace-write"',
-            'approval_policy = "on-request"',
-            "",
-            "# [pactkit:managed]",
-            "[mcp_servers.context7]",
-            'url = "https://mcp.context7.com/mcp"',
-        ]
-        atomic_write(config_path, chr(10).join(lines) + chr(10))
+        print(
+            "  ℹ️ no config.toml — none created (PactKit never writes it).\n"
+            "     If you want the settings PactKit was designed around, add by hand:\n"
+            '       sandbox_mode = "workspace-write"\n'
+            '       approval_policy = "on-request"'
+        )
 
     @staticmethod
     def generate_codex_project_files(project_root):

{pactkit_codex-2.25.1 → pactkit_codex-2.26.0/src/pactkit_codex.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pactkit-codex
-Version: 2.25.1
+Version: 2.26.0
 Summary: PactKit adapter for OpenAI Codex CLI
 Author: Slim
 License: MIT
@@ -21,7 +21,7 @@ Classifier: Topic :: Software Development :: Quality Assurance
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: pactkit<2.26.0,>=2.25.1
+Requires-Dist: pactkit<2.27.0,>=2.26.0
 Requires-Dist: tomli>=1.1.0; python_version < "3.11"
 Dynamic: license-file
 

{pactkit_codex-2.25.1 → pactkit_codex-2.26.0}/src/pactkit_codex.egg-info/SOURCES.txt

@@ -8,4 +8,5 @@ src/pactkit_codex.egg-info/SOURCES.txt
 src/pactkit_codex.egg-info/dependency_links.txt
 src/pactkit_codex.egg-info/entry_points.txt
 src/pactkit_codex.egg-info/requires.txt
-src/pactkit_codex.egg-info/top_level.txt
+src/pactkit_codex.egg-info/top_level.txt
+tests/test_host_body_snapshot.py

{pactkit_codex-2.25.1 → pactkit_codex-2.26.0}/src/pactkit_codex.egg-info/requires.txt

@@ -1,4 +1,4 @@
-pactkit<2.26.0,>=2.25.1
+pactkit<2.27.0,>=2.26.0
 
 [:python_version < "3.11"]
 tomli>=1.1.0

pactkit_codex-2.26.0/tests/test_host_body_snapshot.py

@@ -0,0 +1,126 @@
+"""This host's deployed prompt bodies, pinned against a golden (R7/AC10).
+
+2026-09-12 review (83/100, gap 2): the zero-credential acceptance split
+left adapter-host body comparison out of CI — the core workflow compares
+classic only. This suite pins the CODEX deployment's prompt bodies:
+
+- digest drift (a rule edited or deleted inside a prompt body) fails,
+  naming the file;
+- a core version mismatch fails with an explicit action — regenerate the
+  golden against the new core, or publish the matching core release
+  (PENDING-COMPATIBLE-CORE, see the spec R8 release-window semantics);
+- a probe test deploys, edits one body in place, and proves the SAME
+  comparison logic flags it (删改必被检出, not vacuous).
+
+Regenerate with: tests/scripts/refresh_host_body_golden.py
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import subprocess
+import sys
+from pathlib import Path
+
+import pytest
+
+HOST = "codex"
+GOLDEN = Path(__file__).parent / "fixtures" / "host_body_golden.json"
+DEPLOY_SUFFIXES = (".md", ".json", ".toml")
+
+
+def _core_version() -> str:
+    import importlib.metadata as m
+
+    return m.version("pactkit")
+
+
+def _normalize(content: str, deploy_root: str) -> str:
+    """Strip only the deterministic environment difference: the deploy root
+    path baked into rendered prompts. Rule text stays — normalizing it would
+    swallow the drift this suite exists to catch."""
+    return content.replace(deploy_root, "<DEPLOY_ROOT>")
+
+
+def _deployed_digests(tmp_path: Path) -> tuple[dict[str, str] | None, subprocess.CompletedProcess]:
+    home = tmp_path / "home"
+    target = tmp_path / "deploy"
+    home.mkdir()
+    proc = subprocess.run(
+        [sys.executable, "-m", "pactkit", "init", "--format", HOST, "--target", str(target)],
+        capture_output=True, text=True, timeout=180,
+        env={"PATH": "/usr/bin:/bin", "HOME": str(home), "COLUMNS": "200"},
+    )
+    if proc.returncode != 0:
+        return None, proc
+    digests: dict[str, str] = {}
+    for path in sorted(target.rglob("*")):
+        if not path.is_file() or path.suffix not in DEPLOY_SUFFIXES:
+            continue
+        body = _normalize(path.read_text(encoding="utf-8"), str(target))
+        digests[path.relative_to(target).as_posix()] = hashlib.sha256(
+            body.encode("utf-8")
+        ).hexdigest()
+    return digests, proc
+
+
+def _assert_no_drift(golden_digests: dict[str, str], live: dict[str, str]) -> None:
+    """The one comparison both the golden test and the tamper probe use."""
+    changed = sorted(
+        k for k in set(golden_digests) & set(live) if golden_digests[k] != live[k]
+    )
+    removed = sorted(set(golden_digests) - set(live))
+    added = sorted(set(live) - set(golden_digests))
+    assert not (changed or removed or added), (
+        f"prompt body drift: changed={changed} removed={removed} added={added} "
+        f"— if the core prompts changed, regenerate the golden "
+        f"(tests/scripts/refresh_host_body_golden.py) or publish the matching "
+        f"core release first (PENDING-COMPATIBLE-CORE)"
+    )
+
+
+class TestHostBodySnapshot:
+    def test_bodies_match_the_golden(self, tmp_path):
+        golden = json.loads(GOLDEN.read_text(encoding="utf-8"))
+        core_v = _core_version()
+        if golden["core_version"] != core_v:
+            pytest.fail(
+                f"PENDING-COMPATIBLE-CORE: the {HOST} golden was generated "
+                f"against core {golden['core_version']}, this environment has "
+                f"{core_v}. Either regenerate it after the core change "
+                f"(tests/scripts/refresh_host_body_golden.py) or publish the "
+                f"matching core release first (spec R8 release-window semantics)."
+            )
+        live, proc = _deployed_digests(tmp_path)
+        assert live is not None, (
+            f"{HOST} deploy failed: {proc.stdout[-300:]}{proc.stderr[-300:]}"
+        )
+        _assert_no_drift(golden["body_digests"], live)
+
+    def test_a_body_edit_is_caught_by_the_same_comparison(self, tmp_path):
+        """Non-vacuity, end to end: deploy, edit one prompt body in place,
+        and the SAME comparison that guards the golden must flag it."""
+        golden = json.loads(GOLDEN.read_text(encoding="utf-8"))
+        live, proc = _deployed_digests(tmp_path)
+        assert live is not None, f"{HOST} deploy failed: {proc.stderr[-300:]}"
+        target = tmp_path / "deploy"
+        # Pick a real deployed prompt body and delete one rule line from it.
+        victims = sorted(
+            p for p in target.rglob("*.md") if p.relative_to(target).as_posix() in golden["body_digests"]
+        )
+        assert victims, "no deployed .md body found to tamper with"
+        victim = victims[0]
+        rel = victim.relative_to(target).as_posix()
+        body = victim.read_text(encoding="utf-8")
+        victim.write_text(body + "\n- deleted in a review\n", encoding="utf-8")
+
+        tampered = {
+            p.relative_to(target).as_posix(): hashlib.sha256(
+                _normalize(p.read_text(encoding="utf-8"), str(target)).encode("utf-8")
+            ).hexdigest()
+            for p in sorted(target.rglob("*"))
+            if p.is_file() and p.suffix in DEPLOY_SUFFIXES
+        }
+        with pytest.raises(AssertionError, match=rel):
+            _assert_no_drift(golden["body_digests"], tampered)