pactkit-opencode 3.0.1__tar.gz → 3.0.4__tar.gz

{pactkit_opencode-3.0.1 → pactkit_opencode-3.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pactkit-opencode
-Version: 3.0.1
+Version: 3.0.4
 Summary: PactKit adapter for OpenCode IDE
 License-Expression: MIT
 Requires-Python: >=3.10

{pactkit_opencode-3.0.1 → pactkit_opencode-3.0.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pactkit-opencode"
-version = "3.0.1"
+version = "3.0.4"
 description = "PactKit adapter for OpenCode IDE"
 requires-python = ">=3.10"
 license = "MIT"

pactkit_opencode-3.0.4/src/pactkit_opencode/__init__.py

@@ -0,0 +1,20 @@
+"""PactKit adapter for OpenCode IDE.
+
+Auto-registers OpenCodeDeployer via entry_points when imported.
+"""
+
+from pactkit_opencode.deployer import OpenCodeDeployer
+
+# The second import is for its side effect: it registers OpenCode's
+# enforcement channel (SPEC-4.0-06 R3), and registration IS Core's
+# availability signal — an adapter that is not installed cannot register, so
+# `format == "all"` never installs a channel for a host that never deployed.
+#
+# This adapter's channel is the one exception to that sentence: Core installs
+# nothing for opencode, because `_deploy_gate_plugin()` installs the plugin
+# itself, globally.  Registering still matters — without it Core answers "no
+# channel" for a host that has one, and `gate_coverage` reports the pre-tool
+# gates as unenforced while the plugin is on disk and blocking.
+from pactkit_opencode.enforcement import opencode_channel  # noqa: F401
+
+__all__ = ["OpenCodeDeployer"]

pactkit_opencode-3.0.4/src/pactkit_opencode/enforcement.py

@@ -0,0 +1,59 @@
+"""OpenCode's enforcement channel, stated by its owner (SPEC-4.0-06 R3).
+
+OpenCode's veto surface is a plugin hook (``tool.execute.before``, throwing
+denies the call), not a PreToolUse hook.  Unlike Codex's — and unlike the
+classic host's — **Core does not install it**: ``_deploy_gate_plugin()``
+writes it, globally, from this adapter.  There is no project-relative config
+file for Core to merge into, and the plugin lives outside the deploy root, so
+Core can neither install nor verify it.
+
+So the provider returns None.  That is the registry's word for "this host has
+no channel for Core to install": ``_selected_channels`` yields nothing for
+opencode and ``deploy("all")`` skips it, both correct — the plugin is this
+adapter's to deploy and always was.
+
+What registering buys is the *other* reader.  ``gate_matrix.host_channel_registered``
+asks "did this host register?", and until this module existed the answer was
+no, so ``gate_coverage("opencode")`` reported ``spec_guard`` and
+``tamper_guard`` as not enforced — while the plugin was on disk and blocking.
+Measured 2026-09-22: those two gates flipped from ``not_enforced`` to
+``enforced`` with the registration and nothing else, and no deploy behaviour
+changed.
+
+The looseness is the same one Codex already carries, accepted deliberately
+(owner ruling 2026-09-22): registration is evidence that the *adapter* is
+installed, not that the plugin reached disk.  A project that installed this
+adapter and never ran ``pactkit init --format opencode`` is reported as
+covered.  Making that claim verifiable needs a channel shape for
+adapter-installed plugins; it is not this module's job to fake it with a
+``HookChannel`` whose ``relative_path`` would make Core write a
+project-relative file for a channel that is global by design.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from pactkit.commit_gate import HookChannel, register_enforcement_channel
+
+#: MUST equal the string `gate_matrix.channels_for("opencode")` advertises, or
+#: the coverage notice names a channel that is not the one installed — the
+#: divergence SPEC-4.0-06 R4 records as `HookChannel`'s standing tension.
+#: There is no `HookChannel` here to carry it (Core installs nothing), so the
+#: agreement is asserted by `test_opencode_enforcement_channel.py` instead of
+#: being structural.
+ADVERTISED_IDENTITY = "tool.execute.before plugin (veto by throwing)"
+
+
+def opencode_channel(root: Path) -> HookChannel | None:
+    """None: Core installs nothing for this host, and that is the whole point.
+
+    Returning a `HookChannel` would send Core's installer after a
+    project-relative file for a channel that is global by design.  A None
+    provider is a registered host whose channel Core does not own — distinct
+    from a host that never registered at all.
+    """
+    return None
+
+
+register_enforcement_channel("opencode", opencode_channel)

{pactkit_opencode-3.0.1 → pactkit_opencode-3.0.4}/src/pactkit_opencode.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pactkit-opencode
-Version: 3.0.1
+Version: 3.0.4
 Summary: PactKit adapter for OpenCode IDE
 License-Expression: MIT
 Requires-Python: >=3.10

{pactkit_opencode-3.0.1 → pactkit_opencode-3.0.4}/src/pactkit_opencode.egg-info/SOURCES.txt

@@ -2,6 +2,7 @@ README.md
 pyproject.toml
 src/pactkit_opencode/__init__.py
 src/pactkit_opencode/deployer.py
+src/pactkit_opencode/enforcement.py
 src/pactkit_opencode.egg-info/PKG-INFO
 src/pactkit_opencode.egg-info/SOURCES.txt
 src/pactkit_opencode.egg-info/dependency_links.txt
@@ -14,6 +15,7 @@ tests/test_bug035_opencode_dual_layer.py
 tests/test_deploy_opencode_parity.py
 tests/test_gate_plugin_deploy.py
 tests/test_host_body_snapshot.py
+tests/test_opencode_enforcement_channel.py
 tests/test_story069_opencode_format.py
 tests/test_story070_opencode_compliance.py
 tests/test_story071_opencode_config_parity.py

pactkit_opencode-3.0.4/tests/test_opencode_enforcement_channel.py

@@ -0,0 +1,115 @@
+"""OpenCode's enforcement channel is registered by its owner, not by Core.
+
+OpenCode's veto surface is a plugin hook (`tool.execute.before`, throwing
+denies the call).  `_deploy_gate_plugin()` installs it, globally, from this
+adapter — Core does not install it and cannot verify it, so the provider
+returns None and `_selected_channels` yields nothing.
+
+That makes this the one host whose channel is registered but not installable
+by Core, and the distinction is the whole point of the file:
+
+  * registering is what makes `gate_matrix.host_channel_registered` answer yes,
+    which is what makes `gate_coverage("opencode")` credit `spec_guard` and
+    `tamper_guard` — measured 2026-09-22, those two flipped from `not_enforced`
+    to `enforced` with this registration and nothing else;
+  * it must NOT make Core write anything, because the plugin is already this
+    adapter's to deploy and is global by design.
+
+The looseness carried here is the same one Codex already has, accepted
+deliberately (owner ruling 2026-09-22): registration is evidence that the
+*adapter* is installed, not that the plugin reached disk.
+"""
+
+from __future__ import annotations
+
+from pactkit import commit_gate, gate_matrix
+from pactkit_opencode.enforcement import ADVERTISED_IDENTITY, opencode_channel
+
+
+def gate_coverage_for(fmt: str) -> dict:
+    """The default (measured) path — `has_git=False` so only the host layer moves."""
+    from pactkit.gate_matrix import gate_coverage
+
+    return gate_coverage(fmt, has_git=False)
+
+
+class TestRegistration:
+    """The registry, not the deploy summary, is the availability signal."""
+
+    def test_importing_the_adapter_registers_a_channel(self):
+        import pactkit_opencode  # noqa: F401  — the import IS the registration
+
+        assert gate_matrix.host_channel_registered("opencode"), (
+            "importing this adapter registered no opencode enforcement channel — "
+            "Core will then answer 'no channel' for a host whose plugin is on "
+            "disk and blocking"
+        )
+
+    def test_the_registration_is_what_credits_the_host_gates(self):
+        """The observable consequence, and the reason this module exists.
+
+        Before it, `gate_coverage("opencode")` reported `spec_guard` and
+        `tamper_guard` as not enforced.  Both halves are asserted: the default
+        (measured) path credits them, and taking the registration away puts
+        them back — so the credit is coming from the registry, not from the
+        channel list alone.
+        """
+        import pactkit_opencode  # noqa: F401
+
+        measured = gate_coverage_for("opencode")
+        assert measured["channel_basis"] == "registered"
+        for gate in ("spec_guard", "tamper_guard"):
+            assert gate in measured["enforced"], (
+                f"{gate} is not credited although the adapter registered — this "
+                "is the display defect the registration fixes"
+            )
+
+        saved = dict(commit_gate._ENFORCEMENT_CHANNELS)
+        try:
+            commit_gate._ENFORCEMENT_CHANNELS.pop("opencode")
+            gap = gate_coverage_for("opencode")
+            for gate in ("spec_guard", "tamper_guard"):
+                assert gate in gap["not_enforced"], gate
+            assert "not registered" in gap["not_enforced"]["tamper_guard"], (
+                "the reason must name the missing registration, not blame the "
+                "host — opencode does offer a pre-tool surface"
+            )
+        finally:
+            commit_gate._ENFORCEMENT_CHANNELS.clear()
+            commit_gate._ENFORCEMENT_CHANNELS.update(saved)
+
+    def test_core_still_installs_nothing_for_opencode(self, tmp_path):
+        """The negative: registering must not send Core's installer anywhere.
+
+        The plugin is global and lives outside the deploy root; a HookChannel
+        here would make Core write a project-relative file for it.
+        """
+        import pactkit_opencode  # noqa: F401
+
+        assert commit_gate._selected_channels(tmp_path, "opencode") == [], (
+            "Core selected a channel to install for opencode — it owns none"
+        )
+        assert opencode_channel(tmp_path) is None
+
+    def test_all_does_not_pick_opencode_up(self, tmp_path):
+        """`all` traverses the registry, and opencode contributes no channel."""
+        import pactkit_opencode  # noqa: F401
+
+        identities = [
+            channel.identity
+            for channel in commit_gate._selected_channels(tmp_path, "all")
+        ]
+        assert ADVERTISED_IDENTITY not in identities
+
+
+class TestTheAdvertisedName:
+    def test_the_identity_is_the_advertised_one(self):
+        """R4's tension, asserted: `gate_matrix.channels_for` names this
+        channel in the coverage notice, and there is no `HookChannel` here to
+        carry the string — so nothing structural holds the two together."""
+        advertised = gate_matrix.channels_for("opencode", has_git=False)
+        assert advertised, "anti-vacuity: opencode advertises no channel at all"
+        assert ADVERTISED_IDENTITY in advertised, (
+            f"this module names the channel {ADVERTISED_IDENTITY!r} but the "
+            f"coverage notice advertises {advertised!r}"
+        )

pactkit_opencode-3.0.1/src/pactkit_opencode/__init__.py

@@ -1,8 +0,0 @@
-"""PactKit adapter for OpenCode IDE.
-
-Auto-registers OpenCodeDeployer via entry_points when imported.
-"""
-
-from pactkit_opencode.deployer import OpenCodeDeployer
-
-__all__ = ["OpenCodeDeployer"]