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

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

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

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

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

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.4 → 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.4 → 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.4
+Version: 3.0.5
 Summary: PactKit adapter for OpenCode IDE
 License-Expression: MIT
 Requires-Python: >=3.10

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

@@ -1,6 +1,7 @@
 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
@@ -16,6 +17,7 @@ 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_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:]