pactkit-opencode 3.0.3__tar.gz → 3.0.5__tar.gz

{pactkit_opencode-3.0.3 → pactkit_opencode-3.0.5}/PKG-INFO

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

{pactkit_opencode-3.0.3 → pactkit_opencode-3.0.5}/pyproject.toml

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

pactkit_opencode-3.0.5/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.5/src/pactkit_opencode/declarations.py

@@ -0,0 +1,209 @@
+"""Opencode's own declarations (SPEC-4.0-22 Step 6).
+
+These lived in Core's transitional seed (`_CORE_CAPABILITIES`, `_CORE_SECURITY`,
+`_CORE_PRETOOL_SURFACES`, `_CORE_DEPLOYMENT_CLAIMS`) until Step 6. While they
+did, this adapter could not answer for itself: `import pactkit_opencode` read Core's
+table
+for its own identity, so removing the seed broke the import rather than the
+deployment.
+
+Core still owns the **vocabulary** (`capability.CAPABILITY_VOCABULARY`), the
+four levels, and the hole-filling rule in `resolve_capabilities`. What a given
+Host scores on them is the Host's own declaration — that is the split
+SPEC-4.0-22 R1 draws, and this module is the Opencode side of it.
+
+Every value here was materialised from the seed Core was carrying, so this is a
+move, not a re-measurement. The `Capability.evidence` strings are preserved
+verbatim for the same reason: they are what the seed said, and re-wording them
+here would quietly change what the registry reports.
+"""
+
+from __future__ import annotations
+
+from pactkit.capability import Capability, CapabilityLevel
+from pactkit.profiles import (
+    CLIPolicy,
+    DeploymentClaim,
+    FormatProfile,
+    InputTranslation,
+    SecurityDeclaration,
+    SecurityFacts,
+)
+
+__all__ = [
+    "CAPABILITIES",
+    "DEPLOYMENT_CLAIM",
+    "INPUT_TRANSLATION",
+    "PRETOOL_SURFACE",
+    "PROFILE",
+    "SECURITY",
+]
+
+
+def _cap(
+    name: str, level: CapabilityLevel, implemented: bool, evidence: str
+) -> Capability:
+    return Capability(
+        name=name, level=level, implemented=implemented, evidence=evidence
+    )
+
+
+#: The Host's profile. Core no longer owns it; this module is the source.
+PROFILE = FormatProfile(
+    name='opencode',
+    display_name='OpenCode',
+    global_config_dir='~/.config/opencode',
+    project_config_dir='.opencode',
+    skills_dir='~/.config/opencode/skills',
+    agents_dir='~/.config/opencode/agents',
+    commands_dir='~/.config/opencode/commands',
+    rules_dir='~/.config/opencode/rules',
+    project_instructions_file='AGENTS.md',
+    global_instructions_file='AGENTS.md',
+    pactkit_yaml_path='.opencode/pactkit.yaml',
+    agent_format='md',
+    rules_import_style='inline',
+    excluded_agent_fields=frozenset({'memory', 'permissionMode', 'skills'}),
+    excluded_commands=frozenset(),
+    supports_model_routing=True,
+    skills_path_var='~/.config/opencode/skills',
+    command_deploy_form='flat',
+    agent_dialect='opencode',
+    command_dialect='opencode',
+    core_bundled=False,
+    cli_policy=CLIPolicy.REQUIRED,
+)
+
+#: What this Host scores on the capability vocabulary.
+CAPABILITIES: dict[str, Capability] = {
+    'completion_hook': _cap('completion_hook', CapabilityLevel.DEGRADED, False,
+        "unverified — not measured on this Host; absence of the capability is NOT "
+        "established (SPEC-4.0-04 R2: unverified is not unavailable)",
+    ),
+    'git_hook': _cap('git_hook', CapabilityLevel.NATIVE, True,
+        'shipped (commit_gate pre-commit chain)',
+    ),
+    'global_instruction': _cap('global_instruction', CapabilityLevel.DEGRADED, False,
+        "unverified — not measured on this Host; absence of the capability is NOT "
+        "established (SPEC-4.0-04 R2: unverified is not unavailable)",
+    ),
+    'native_command': _cap('native_command', CapabilityLevel.NATIVE, True,
+        'shipped (generators.deployer command deploy)',
+    ),
+    'native_skill': _cap('native_skill', CapabilityLevel.NATIVE, True,
+        'shipped (generators.deployer._deploy_skills)',
+    ),
+    'persistent_session': _cap('persistent_session', CapabilityLevel.DEGRADED, False,
+        "unverified — not measured on this Host; absence of the capability is NOT "
+        "established (SPEC-4.0-04 R2: unverified is not unavailable)",
+    ),
+    'post_tool_hook': _cap('post_tool_hook', CapabilityLevel.DEGRADED, False,
+        "unverified — not measured on this Host; absence of the capability is NOT "
+        "established (SPEC-4.0-04 R2: unverified is not unavailable)",
+    ),
+    'pre_tool_hook': _cap('pre_tool_hook', CapabilityLevel.EQUIVALENT, True,
+        "shipped as a plugin veto (tool.execute.before) — Equivalent, not Native: it "
+        "is PactKit's plugin, not a host facility. End-to-end in a real session "
+        "2026-09-18 (docs/guides/opencode-pretool-channel-evidence.md)",
+    ),
+    'project_instruction': _cap('project_instruction', CapabilityLevel.EQUIVALENT, True,
+        'shipped (deployed instruction file)',
+    ),
+    'rule_import': _cap('rule_import', CapabilityLevel.DEGRADED, False,
+        "unverified — not measured on this Host; absence of the capability is NOT "
+        "established (SPEC-4.0-04 R2: unverified is not unavailable)",
+    ),
+    'session_resume': _cap('session_resume', CapabilityLevel.DEGRADED, False,
+        "unverified — not measured on this Host; absence of the capability is NOT "
+        "established (SPEC-4.0-04 R2: unverified is not unavailable)",
+    ),
+    'shell_execution': _cap('shell_execution', CapabilityLevel.NATIVE, True,
+        'shipped (native bash tool)',
+    ),
+    'structured_tool_result': _cap('structured_tool_result', CapabilityLevel.DEGRADED,
+        False,
+        "unverified — not measured on this Host; absence of the capability is NOT "
+        "established (SPEC-4.0-04 R2: unverified is not unavailable)",
+    ),
+    'subagent': _cap('subagent', CapabilityLevel.DEGRADED, False,
+        "unverified — not measured on this Host; absence of the capability is NOT "
+        "established (SPEC-4.0-04 R2: unverified is not unavailable)",
+    ),
+}
+
+#: Files a gate must treat specially on this Host (SPEC-4.0-22 R8).
+SECURITY = SecurityDeclaration(
+    env_capable=SecurityFacts.declared(['opencode.json']),
+    protected=SecurityFacts.empty(),
+    conditional=SecurityFacts.empty(),
+)
+
+#: Which mechanism this Host offers for pre-tool interception, when one
+#: has been measured. `None` means unverified — not "cannot".
+PRETOOL_SURFACE = 'tool.execute.before (plugin; veto by throwing)'
+
+#: How this Host executes and where its verification comes from.
+DEPLOYMENT_CLAIM = DeploymentClaim(
+    execution_mode='portable',
+    verification_source='adapter_native_command_facade',
+)
+
+#: Read-side wire-format data (SPEC-4.0-22 Step 4/7).
+#:
+#: **This Host's wire format, not Core's data about it.**  Until Step 7 this
+#: lived in Core (`host_payloads.OPENCODE_INPUT`) and was registered into the
+#: registry at import time.  That made Core the owner of a Host-specific
+#: format, and it stayed invisible for exactly as long as Core seeded this Host
+#: at import — the moment the seed went, Core's import-time registration raised
+#: `UnknownAdapterError` in every process that had not run entry-point
+#: discovery, and the gate it feeds failed **open** (measured 2026-09-24).
+#:
+#: The Step 6 commit on this branch declared the slot but left it `None`, which
+#: would have been worse than the bug it replaced: with Core's copy deleted,
+#: nothing would recognise an OpenCode payload at all and the whole channel
+#: would fail open.  The values below are Core's, moved **verbatim** — this is
+#: a move, not a re-measurement, and re-deriving them would quietly change what
+#: the gate reads.
+#:
+#: Two entries are explicitly *not* evidence, and say so: `patch` has an
+#: unmeasured argument shape (it is listed so that "every write tool is in the
+#: table" holds, and it is refused through `uncovered_write_tools`), and
+#: unknown tools carrying a path-ish argument are treated as writes as a
+#: fallback.
+#:
+#: `tool_map` is **not injective** — `patch` and `write` both canonicalise to
+#: `Write`.  The order below is therefore not semantic: Core's reverse lookup
+#: breaks the tie on `uncovered_write_tools` (preferring the verified spelling)
+#: rather than on iteration order, precisely so this declaration can be written
+#: in whatever order reads best.
+INPUT_TRANSLATION: InputTranslation | None = InputTranslation(
+    requires_keys=('tool', 'args'),
+    excludes_keys=('tool_name',),
+    tool_map={
+        'bash': 'Bash',
+        'edit': 'Edit',
+        'patch': 'Write',
+        'write': 'Write',
+    },
+    arg_map={
+        'bash': {
+            'command': 'command',
+        },
+        'edit': {
+            'filePath': 'file_path',
+            'newString': 'new_string',
+            'oldString': 'old_string',
+            'replaceAll': 'replace_all',
+        },
+        'patch': {
+            'filePath': 'file_path',
+            'patchText': 'content',
+        },
+        'write': {
+            'content': 'content',
+            'filePath': 'file_path',
+        },
+    },
+    read_only_tools=frozenset({'glob', 'grep', 'list', 'read', 'task', 'todoread', 'todowrite', 'webfetch'}),
+    uncovered_write_tools=frozenset({'patch'}),
+    path_arg_keys=('filePath', 'file_path', 'path'))

{pactkit_opencode-3.0.3 → pactkit_opencode-3.0.5}/src/pactkit_opencode/deployer.py

@@ -28,7 +28,7 @@ from pactkit.generators.deployer import (
     _deploy_rules,
     _deploy_skills,
 )
-from pactkit.profiles import get_profile
+from pactkit_opencode import declarations
 from pactkit.utils import atomic_write
 
 # All canonical commands deploy. Sprint has a sequential capability fallback.
@@ -121,7 +121,16 @@ class OpenCodeDeployer(DeployerBase):
       registers, nor recommends external services)
     """
 
-    profile = get_profile("opencode")
+    # SPEC-4.0-22 Step 6: this Host answers for itself. These were Core's
+    # transitional seed until now; `complete_registration` harvests them off the
+    # class, so the adapter no longer reads a table Core owns. `input_translation`
+    # rides its own lifecycle — it is installed after the registration exists.
+    profile = declarations.PROFILE
+    capabilities = declarations.CAPABILITIES
+    security = declarations.SECURITY
+    pretool_surface = declarations.PRETOOL_SURFACE
+    deployment_claim = declarations.DEPLOYMENT_CLAIM
+    input_translation = declarations.INPUT_TRANSLATION
 
     def deploy(self, config=None, target=None):
         opencode_root = Path(target) if target else Path.home() / ".config" / "opencode"

pactkit_opencode-3.0.5/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.3 → pactkit_opencode-3.0.5}/src/pactkit_opencode.egg-info/PKG-INFO

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

{pactkit_opencode-3.0.3 → pactkit_opencode-3.0.5}/src/pactkit_opencode.egg-info/SOURCES.txt

@@ -1,7 +1,9 @@
 README.md
 pyproject.toml
 src/pactkit_opencode/__init__.py
+src/pactkit_opencode/declarations.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 +16,8 @@ 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_step6_self_sufficiency.py
 tests/test_story069_opencode_format.py
 tests/test_story070_opencode_compliance.py
 tests/test_story071_opencode_config_parity.py

pactkit_opencode-3.0.5/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.5/tests/test_step6_self_sufficiency.py

@@ -0,0 +1,128 @@
+"""SPEC-4.0-22 Step 6: this adapter answers for itself.
+
+The claim under test is not "registration is complete" — it already was, because
+Core's transitional seed filled the same members. The claim is that **every one
+of them comes from the adapter**.
+
+The probe removes Core's declaration for this Host and re-seeds, then imports
+the adapter in that state. It does so **without naming Core's tables**: the
+claim does not depend on whether they are called `_CORE_*` (everything
+published up to 3.0.4) or `_BUILTIN_*` (Step 7, where they hold the builtin
+alone). A probe that hardcodes either name is coupled to a Core version — and
+adapter CI installs Core from PyPI, so it would be testing the version it
+happens to pull rather than the adapter.
+
+The assertions name **properties**, not literals from the seed — the seed is
+gone, so quoting it would assert the thing being ruled out.
+"""
+
+from __future__ import annotations
+
+import subprocess
+import sys
+
+HOST = "opencode"
+MODULE = "pactkit_opencode"
+
+#: Asserts Core declares nothing for this Host, then imports the adapter. Runs
+#: in a fresh interpreter so the registry is exactly what `profiles` leaves
+#: behind — no earlier import of this adapter can have registered it.
+_UNSEED_TEMPLATE = '''
+import sys
+from pactkit import profiles as P
+
+# Remove every trace of Core's declaration for this Host — by SHAPE, not by a
+# hardcoded table name. Naming `_CORE_*` breaks on Step 7 core; naming
+# `_BUILTIN_*` breaks on everything published before it. The claim under test
+# does not depend on what the table is called, so the probe must not either.
+removed = [n for n, v in list(vars(P).items())
+           if isinstance(v, dict) and HOST in v]
+for n in removed:
+    vars(P)[n].pop(HOST, None)
+
+# Re-seed through whatever this Core calls its seeder, so the registry is a
+# consistent post-seed state rather than a half-emptied one.
+for seeder in ("_seed_builtin", "_seed_from_core"):
+    fn = getattr(P, seeder, None)
+    if fn is not None:
+        fn()
+        break
+
+# The precondition the import has to survive — and the guard against a probe
+# that proves nothing. On Core 3.0.4 the removal above is what establishes it;
+# on Step 7 Core it was already true, because there is no seed to remove. Both
+# readings are the same claim, so this assertion is meaningful on both rather
+# than demanding that something was removed (which Step 7 Core would fail for
+# having done its job).
+assert HOST not in P.FORMAT_PROFILES, (
+    "Core still carries this Host's profile when the adapter loads"
+)
+assert HOST not in P._ADAPTER_REGISTRY, (
+    "this Host is registered before its adapter has loaded"
+)
+
+import MODULE  # noqa: F401  — the import IS the assertion
+
+from pactkit.profiles import get_registration
+reg = get_registration(HOST)
+assert reg.complete, "registration incomplete after an unseeded import: " + reg.state
+assert reg.source == P.SOURCE_ENTRY_POINT, "source is " + reg.source
+print("OK")
+'''
+
+
+def _code(import_adapter: bool = True) -> str:
+    """The probe, optionally without the adapter import (the control).
+
+    The control substitution happens **before** the MODULE/HOST placeholders are
+    filled in. Doing it after silently matched nothing — the literal it looked
+    for no longer contained `MODULE` — and the control then ran the full probe
+    and passed for the wrong reason. Measured 2026-09-24.
+    """
+    code = _UNSEED_TEMPLATE
+    if not import_adapter:
+        before = code
+        code = code.replace(
+            "import MODULE  # noqa: F401  — the import IS the assertion",
+            "pass  # control: do NOT import the adapter",
+        )
+        assert code != before, "the control substitution matched nothing"
+    return code.replace("HOST", repr(HOST)).replace("MODULE", MODULE)
+
+
+def _run(code: str) -> subprocess.CompletedProcess:
+    return subprocess.run(
+        [sys.executable, "-c", code], capture_output=True, text=True, timeout=180
+    )
+
+
+def test_the_adapter_stands_up_without_its_core_seed():
+    """The unseeded import is the whole claim — it raised before Step 6."""
+    result = _run(_code())
+    assert result.returncode == 0, (
+        "the adapter could not stand up without Core's transitional seed — "
+        "which is exactly what Step 7 deletes:\n" + result.stderr[-2000:]
+    )
+
+
+def test_the_probe_moves_when_the_adapter_is_not_imported():
+    """Control: the probe's assertions must distinguish the two states.
+
+    A control that merely re-runs the probe with one of its own assertions
+    disabled proves nothing — it passes because the check was removed, not
+    because the probe is sound. (Measured: the first version of this control did
+    exactly that and passed for that reason.)
+
+    The discriminating question is whether the probe's assertions *move*. So
+    this runs the same removal **without importing the adapter**: now nothing
+    has registered opencode, and the probe must report that — a registration
+    that is absent or incomplete, and a host still counted as transitional.
+    """
+    probe = _code(import_adapter=False)
+    result = _run(probe)
+    assert result.returncode != 0, (
+        "with no adapter imported, the probe still reported a complete "
+        "entry-point registration — so its assertions do not depend on the "
+        "adapter at all, and the main test is not measuring self-sufficiency"
+    )
+    assert "Traceback" in result.stderr, result.stderr[-800:]

pactkit_opencode-3.0.3/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"]