pactkit-opencode 2.25.2__tar.gz → 2.27.0__tar.gz

{pactkit_opencode-2.25.2 → pactkit_opencode-2.27.0}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: pactkit-opencode
-Version: 2.25.2
+Version: 2.27.0
 Summary: PactKit adapter for OpenCode IDE
 License-Expression: MIT
 Requires-Python: >=3.10
-Requires-Dist: pactkit<2.26.0,>=2.25.2
+Requires-Dist: pactkit<2.28.0,>=2.27.0

{pactkit_opencode-2.25.2 → pactkit_opencode-2.27.0}/pyproject.toml

@@ -4,12 +4,12 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pactkit-opencode"
-version = "2.25.2"
+version = "2.27.0"
 description = "PactKit adapter for OpenCode IDE"
 requires-python = ">=3.10"
 license = "MIT"
 dependencies = [
-    "pactkit>=2.25.2,<2.26.0",
+    "pactkit>=2.27.0,<2.28.0",
 ]
 
 [project.entry-points."pactkit.deployers"]

{pactkit_opencode-2.25.2 → pactkit_opencode-2.27.0}/src/pactkit_opencode/deployer.py

@@ -10,10 +10,10 @@ from pathlib import Path
 from pactkit import __version__
 from pactkit.config import (
     DEFAULT_RULE_IDS,
-    activate_pactkit_maintainer_overlay,
     VALID_AGENTS,
     VALID_COMMANDS,
     VALID_SKILLS,
+    activate_pactkit_maintainer_overlay,
     auto_merge_config_file,
     load_config,
 )
@@ -35,6 +35,70 @@ from pactkit.utils import atomic_write
 OPENCODE_EXCLUDED_COMMANDS: frozenset[str] = frozenset()
 
 
+def _instruction_ref_is_ours(opencode_root, ref) -> bool:
+    """Whether an instruction ref is provably PactKit's (R4, 2026-09-11 review).
+
+    名称不构成所有权证据: a ref whose filename merely collides with a registry
+    id or legacy id (the user's own ``rules/08-architecture-principles.md``)
+    is NOT ours. Proven ownership requires one of:
+
+    - the exact legacy wildcard value PactKit once wrote (``rules/*.md``);
+    - a ref in the current managed core set (re-added after the filter);
+    - a ref recorded in the deployment manifest's ``opencode_instructions``
+      history (authoritative once any 2.26+ deploy has run);
+    - the referenced file still being byte-identical to managed content
+      PactKit deployed for that filename (legacy managed contents).
+    """
+    if not isinstance(ref, str):
+        return False
+    if ref == "rules/*.md":
+        return True
+    from pactkit.prompts.rules import LEGACY_RULE_CONTENTS, RULES_INSTRUCTIONS_CORE
+
+    if ref in RULES_INSTRUCTIONS_CORE:
+        return True
+    from pactkit.deploy_manifest import load_previous_manifest
+
+    recorded = load_previous_manifest(opencode_root).get("opencode_instructions")
+    if isinstance(recorded, list) and ref in recorded:
+        return True
+    import re
+
+    match = re.fullmatch(r"rules/([^/]+)\.md", ref)
+    if match is None:
+        return False
+    filename = f"{match.group(1)}.md"
+    expected = LEGACY_RULE_CONTENTS.get(filename)
+    if expected is None:
+        return False
+    path = Path(opencode_root) / "rules" / filename
+    if not path.is_file():
+        return False
+    try:
+        return path.read_text(encoding="utf-8") == expected
+    except OSError:
+        return False
+
+
+def _ref_resembles_pactkit(ref) -> bool:
+    """Reporting-only heuristic: a ref that *looks* like a PactKit rule ref
+    (filename matches a registry id or legacy id) but failed the ownership
+    evidence. Used to explain preserved entries — never to remove them."""
+    import re
+
+    if not isinstance(ref, str):
+        return False
+    match = re.fullmatch(r"rules/([^/]+)\.md", ref)
+    if match is None:
+        return False
+    from pactkit.prompts.rules import RULE_DEFINITIONS
+
+    ids = {rule.id for rule in RULE_DEFINITIONS.values()}
+    for rule in RULE_DEFINITIONS.values():
+        ids.update(rule.legacy_ids)
+    return match.group(1) in ids
+
+
 class OpenCodeDeployer(DeployerBase):
     """OpenCode deployment — generate OpenCode-native configuration (STORY-069).
 
@@ -52,7 +116,9 @@ class OpenCodeDeployer(DeployerBase):
     - Calls auto_merge_config_file() for automatic config updates (R2)
     - Calls _cleanup_legacy() to remove stale skill files (R3)
     - Generates project-level AGENTS.md when not in preview mode (R4)
-    - Prints MCP server recommendations (R5)
+    - Third-party MCP recommendations are retired (R5 superseded by
+      STORY-slim-20260911b2bbd79889e0 A2/R3: deploy neither installs,
+      registers, nor recommends external services)
     """
 
     profile = get_profile("opencode")
@@ -113,6 +179,16 @@ class OpenCodeDeployer(DeployerBase):
             if replaced != content:
                 atomic_write(skill_md, replaced)
 
+        # HOTFIX-slim-20260903d464746b1909: post-pass rewrites deployed bytes in
+        # place; record the FINAL (transformed) digests or the next deploy cannot
+        # prove ownership and re-produces .pactkit-new candidates.
+        from pactkit.deploy_manifest import record_deployed_file
+
+        for skill_md in skills_dir.glob("*/SKILL.md"):
+            record_deployed_file(
+                opencode_root, skill_md.relative_to(opencode_root).as_posix(),
+            )
+
         # Deploy commands to commands/ directory (OpenCode uses /command-name to invoke)
         n_commands = _deploy_commands(commands_dir, enabled_commands, profile=self.profile, config=cfg)
 
@@ -123,10 +199,14 @@ class OpenCodeDeployer(DeployerBase):
             if replaced != content:
                 atomic_write(cmd_md, replaced)
 
-        _deploy_rules(opencode_root, enabled_rules, profile=self.profile)
-        _deploy_guides(opencode_root, profile=self.profile)
-        self._deploy_agents_md_inline(opencode_root)
+        for cmd_md in commands_dir.glob("*.md"):
+            record_deployed_file(
+                opencode_root, cmd_md.relative_to(opencode_root).as_posix(),
+            )
 
+        # R4 (2026-09-11 review): retire instruction refs BEFORE _deploy_rules
+        # deletes byte-identical legacy files — ref ownership is proven by the
+        # referenced file's content, so the files must still exist here.
         providers = self._load_opencode_providers(opencode_root)
         if not providers:
             providers = self._load_opencode_providers(
@@ -140,6 +220,10 @@ class OpenCodeDeployer(DeployerBase):
             enabled_commands=enabled_commands,
         )
 
+        _deploy_rules(opencode_root, enabled_rules, profile=self.profile)
+        _deploy_guides(opencode_root, profile=self.profile)
+        self._deploy_agents_md_inline(opencode_root)
+
         n_agents = _deploy_agents(agents_dir, enabled_agents, profile=self.profile)
 
         ci_config = cfg.get("ci", {})
@@ -160,8 +244,6 @@ class OpenCodeDeployer(DeployerBase):
         if target is None:
             self._generate_project_agents_md()
 
-        self._print_mcp_recommendations_opencode()
-
     # --- OpenCode-specific helpers ---
 
     @staticmethod
@@ -200,45 +282,6 @@ class OpenCodeDeployer(DeployerBase):
         ]
         atomic_write(opencode_root / "AGENTS.md", "\n".join(lines))
 
-    @staticmethod
-    def _deploy_opencode_json(opencode_root):
-        """Generate opencode.json project configuration (STORY-071 R1/R2)."""
-        config = {
-            "$schema": "https://opencode.ai/config.json",
-            "instructions": ["AGENTS.md", "docs/product/context.md"],
-            "agent": {
-                "build": {"model": "inherit"},
-                "plan": {"model": "inherit"},
-            },
-            "permission": {
-                "edit": "allow",
-                "bash": {
-                    "*": "allow",
-                    "rm -rf /*": "deny",
-                    "rm -rf /Users/*": "deny",
-                    "rm -rf /System/*": "deny",
-                    "sudo rm *": "deny",
-                    "sudo mkfs *": "deny",
-                    "curl * | sh": "deny",
-                    "wget * | sh": "deny",
-                },
-                "read": {
-                    "*": "allow",
-                    "*.env": "deny",
-                    "*.env.*": "deny",
-                    "*.env.example": "allow",
-                },
-            },
-            "mcp": {
-                "context7": {
-                    "type": "remote",
-                    "url": "https://mcp.context7.com/mcp",
-                },
-            },
-        }
-        content = json.dumps(config, indent=2, ensure_ascii=False) + "\n"
-        atomic_write(opencode_root / "opencode.json", content)
-
     @staticmethod
     def _resolve_opencode_model_id(short_name, providers):
         """Resolve a short model name to a full provider/model-id (STORY-073)."""
@@ -268,33 +311,85 @@ class OpenCodeDeployer(DeployerBase):
     def _update_global_opencode_json(
         opencode_root, command_models=None, providers=None, enabled_commands=None
     ):
-        """Update global opencode.json with instructions, command templates, and model routing."""
+        """Update global opencode.json with instructions, command templates, and model routing.
+
+        STORY-slim-20260911b2bbd79889e0 A1/R4 — three contracts:
+
+        - A file that cannot be parsed is left byte-identical with a
+          diagnostic. Falling back to an empty object would overwrite the
+          user's providers, models and MCP entries with nothing.
+        - An overwrite is preceded by a timestamped backup under
+          ``.pactkit-backups/`` (core's ``backup_existing``).
+        - Instruction entries are only removed when provably PactKit's own —
+          the legacy ``rules/*.md`` wildcard, a current managed core ref, a
+          manifest-recorded ref, or a ref whose file bytes still match managed
+          content (R4: a registry-id name collision is not ownership). A
+          user's own ``rules/my-team.md`` — or their own
+          ``rules/08-architecture-principles.md`` — must survive the update,
+          and preserved look-alikes are reported explicitly.
+        """
         json_path = opencode_root / "opencode.json"
         config = {}
 
         if json_path.is_file():
+            original_bytes = json_path.read_bytes()
             try:
-                config = json.loads(json_path.read_text(encoding="utf-8"))
-            except (json.JSONDecodeError, OSError):
-                config = {}
+                config = json.loads(original_bytes.decode("utf-8"))
+            except (json.JSONDecodeError, UnicodeDecodeError):
+                print(
+                    f"  ⚠️  {json_path} is not valid JSON — left untouched; "
+                    "fix or remove it manually, then re-run pactkit update"
+                )
+                return
+            except OSError as exc:
+                print(f"  ⚠️  {json_path} is unreadable ({exc}) — left untouched")
+                return
+            if not isinstance(config, dict):
+                print(
+                    f"  ⚠️  {json_path} is not a JSON object — left untouched; "
+                    "merge it manually if needed"
+                )
+                return
+            from pactkit.deploy_manifest import backup_existing
+
+            backup_existing(opencode_root, json_path)
 
         config.setdefault("$schema", "https://opencode.ai/config.json")
 
         # Always-load layer: only the self-contained Runtime Kernel is global.
         # Phase, command, conditional, and risk rules are activated by the
         # current command instead of through a wildcard instruction.
+        #
+        # R4 (2026-09-11 review, finding 1): retire only refs with ownership
+        # EVIDENCE — the legacy wildcard, managed core refs, a manifest
+        # record, or byte-identical managed file content. A name that merely
+        # collides with a registry id is the user's; preserved refs that
+        # resemble PactKit's are reported explicitly, never silently kept.
         from pactkit.prompts.rules import RULES_INSTRUCTIONS_CORE
 
-        managed = set(RULES_INSTRUCTIONS_CORE)
-        existing = [
-            i
-            for i in config.get("instructions", [])
-            if i != "rules/*.md" and not (i.startswith("rules/") and i not in managed)
-        ]
+        instructions = config.get("instructions", [])
+        if not isinstance(instructions, list):
+            instructions = []
+        kept: list = []
+        unproven_lookalikes: list[str] = []
+        for ref in instructions:
+            if isinstance(ref, str) and _instruction_ref_is_ours(opencode_root, ref):
+                continue  # provably ours — retired (core refs re-added below)
+            kept.append(ref)
+            if _ref_resembles_pactkit(ref):
+                unproven_lookalikes.append(ref)
         for entry in RULES_INSTRUCTIONS_CORE:
-            if entry not in existing:
-                existing.append(entry)
-        config["instructions"] = existing
+            if entry not in kept:
+                kept.append(entry)
+        config["instructions"] = kept
+        if unproven_lookalikes:
+            print(
+                f"  ⚠️  preserved {len(unproven_lookalikes)} instruction ref(s) "
+                "that resemble PactKit's but are not provably ours (no manifest "
+                "record, and the file is absent or differs from managed "
+                f"content): {', '.join(unproven_lookalikes)} — remove manually "
+                "if you know they are PactKit's"
+            )
 
         # OpenCode auto-discovers commands from commands/*.md directory.
         # opencode.json "command" section requires BOTH "model" AND "template" fields.
@@ -314,28 +409,6 @@ class OpenCodeDeployer(DeployerBase):
         content = json.dumps(config, indent=2, ensure_ascii=False) + "\n"
         atomic_write(json_path, content)
 
-    @staticmethod
-    def _print_mcp_recommendations_opencode():
-        """Print MCP server recommendations for OpenCode deployment (STORY-071 R4)."""
-        print("\n📦 MCP Server Configuration (add to opencode.json):")
-        print()
-        print("  Remote MCP (no install needed):")
-        print('    "context7": { "type": "remote", "url": "https://mcp.context7.com/mcp" }')
-        print()
-        print("  Local MCP (requires npx):")
-        print(
-            '    "memory":     { "type": "local", "command": '
-            '["npx", "-y", "@modelcontextprotocol/server-memory"] }'
-        )
-        print(
-            '    "playwright":  { "type": "local", "command": '
-            '["npx", "-y", "@playwright/mcp"] }'
-        )
-        print(
-            '    "puppeteer":   { "type": "local", "command": '
-            '["npx", "-y", "@anthropic/mcp-puppeteer"] }'
-        )
-
     @staticmethod
     def _cleanup_command_skills(skills_dir):
         """Remove legacy command skills from skills/ directory.
@@ -368,7 +441,8 @@ _CLI_TO_SCRIPT = [
     # scaffold
     ("Run `python3 ~/.config/opencode/skills/pactkit-scaffold/scripts/scaffold.py", f"Run `{_SCAFFOLD_SCRIPT}"),
     # pactkit CLI → manual fallback hint
-    ("Run `pactkit clean`", "Run language-specific cleanup (e.g., `find . -name '__pycache__' -exec rm -rf {} +` for Python)"),
+    ("Run `pactkit clean`",
+     "Run language-specific cleanup (e.g., `find . -name '__pycache__' -exec rm -rf {} +`)"),
 ]
 
 

{pactkit_opencode-2.25.2 → pactkit_opencode-2.27.0}/src/pactkit_opencode.egg-info/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: pactkit-opencode
-Version: 2.25.2
+Version: 2.27.0
 Summary: PactKit adapter for OpenCode IDE
 License-Expression: MIT
 Requires-Python: >=3.10
-Requires-Dist: pactkit<2.26.0,>=2.25.2
+Requires-Dist: pactkit<2.28.0,>=2.27.0

{pactkit_opencode-2.25.2 → pactkit_opencode-2.27.0}/src/pactkit_opencode.egg-info/SOURCES.txt

@@ -8,8 +8,11 @@ src/pactkit_opencode.egg-info/dependency_links.txt
 src/pactkit_opencode.egg-info/entry_points.txt
 src/pactkit_opencode.egg-info/requires.txt
 src/pactkit_opencode.egg-info/top_level.txt
+tests/test_a1_config_recovery.py
+tests/test_a2_mcp_retired.py
 tests/test_bug035_opencode_dual_layer.py
 tests/test_deploy_opencode_parity.py
+tests/test_host_body_snapshot.py
 tests/test_story069_opencode_format.py
 tests/test_story070_opencode_compliance.py
 tests/test_story071_opencode_config_parity.py

pactkit_opencode-2.27.0/src/pactkit_opencode.egg-info/requires.txt

@@ -0,0 +1 @@
+pactkit<2.28.0,>=2.27.0

pactkit_opencode-2.27.0/tests/test_a1_config_recovery.py

@@ -0,0 +1,224 @@
+"""Recoverable config updates for the user's opencode.json (A1).
+
+STORY-slim-20260911b2bbd79889e0 A1/R4. Three failure modes were replayed at
+core HEAD 9faaf8d by reading `_update_global_opencode_json`:
+
+1. Parse failure fell back to ``config = {}`` and overwrote the user's file
+   with an essentially empty object — every provider, model and MCP entry gone.
+2. The overwrite wrote directly with no backup — nothing to restore from.
+3. The instructions filter dropped every ``rules/`` entry not in PactKit's
+   managed set — a user's own ``rules/my-team.md`` reference included.
+
+These tests pin the contract the umbrella spec demands: ownership first,
+recoverable writes, user content preserved.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from pactkit_opencode.deployer import OpenCodeDeployer
+
+from pactkit.deploy_manifest import BACKUPS_DIR
+
+USER_CONFIG = {
+    "$schema": "https://opencode.ai/config.json",
+    "instructions": ["rules/my-team.md"],
+    "provider": {
+        "kimi": {"npm": "@ai-sdk/openai-compatible",
+                 "options": {"baseURL": "https://example.invalid/moonshot",
+                             "apiKey": "sk-test-not-a-real-key"}},
+    },
+    "mcp_servers": {"memory": {"type": "local", "enabled": False}},
+}
+
+
+def _write_user_config(root: Path, payload) -> Path:
+    path = root / "opencode.json"
+    path.write_text(
+        payload if isinstance(payload, str) else json.dumps(payload, indent=2),
+        encoding="utf-8",
+    )
+    return path
+
+
+class TestParseFailure:
+    def test_corrupt_config_is_left_byte_identical(self, tmp_path):
+        corrupt = '{"instructions": [truncated'
+        path = _write_user_config(tmp_path, corrupt)
+
+        OpenCodeDeployer._update_global_opencode_json(tmp_path)
+
+        assert path.read_text(encoding="utf-8") == corrupt
+
+    def test_corrupt_config_produces_a_diagnostic(self, tmp_path, capsys):
+        _write_user_config(tmp_path, '{"instructions": [truncated')
+
+        OpenCodeDeployer._update_global_opencode_json(tmp_path)
+
+        out = capsys.readouterr().out
+        assert "opencode.json" in out
+        assert "left untouched" in out or "untouched" in out
+
+    def test_no_empty_object_is_written(self, tmp_path):
+        _write_user_config(tmp_path, 'not json at all')
+
+        OpenCodeDeployer._update_global_opencode_json(tmp_path)
+
+        text = (tmp_path / "opencode.json").read_text(encoding="utf-8")
+        assert text == "not json at all"
+
+
+class TestBackup:
+    def test_valid_update_backs_up_the_original(self, tmp_path):
+        path = _write_user_config(tmp_path, USER_CONFIG)
+
+        OpenCodeDeployer._update_global_opencode_json(tmp_path)
+
+        backups = list((tmp_path / BACKUPS_DIR).rglob("opencode.json"))
+        assert backups, "no backup was taken before overwriting"
+        assert backups[0].read_text(encoding="utf-8") == path.read_text(
+            encoding="utf-8"
+        ) or json.loads(backups[0].read_text(encoding="utf-8")) == USER_CONFIG
+
+    def test_missing_config_takes_no_backup(self, tmp_path):
+        OpenCodeDeployer._update_global_opencode_json(tmp_path)
+
+        assert not (tmp_path / BACKUPS_DIR).exists()
+
+
+class TestUserContentPreserved:
+    def _update(self, tmp_path) -> dict:
+        _write_user_config(tmp_path, USER_CONFIG)
+        OpenCodeDeployer._update_global_opencode_json(tmp_path)
+        return json.loads((tmp_path / "opencode.json").read_text(encoding="utf-8"))
+
+    def test_user_rule_references_survive(self, tmp_path):
+        updated = self._update(tmp_path)
+
+        assert "rules/my-team.md" in updated["instructions"], (
+            "a user-authored rule reference was dropped by the update"
+        )
+
+    def test_providers_survive(self, tmp_path):
+        updated = self._update(tmp_path)
+
+        assert updated["provider"] == USER_CONFIG["provider"]
+
+    def test_user_mcp_servers_survive(self, tmp_path):
+        updated = self._update(tmp_path)
+
+        assert updated["mcp_servers"] == USER_CONFIG["mcp_servers"]
+
+    def test_managed_instructions_are_still_added(self, tmp_path):
+        updated = self._update(tmp_path)
+
+        from pactkit.prompts.rules import RULES_INSTRUCTIONS_CORE
+
+        for entry in RULES_INSTRUCTIONS_CORE:
+            assert entry in updated["instructions"]
+
+    def test_wildcard_rule_glob_is_still_retired(self, tmp_path):
+        """The legacy `rules/*.md` wildcard is provably PactKit's — retiring
+        it stays; only unknown user entries gain protection."""
+        payload = {"instructions": ["rules/*.md", "rules/my-team.md"]}
+        _write_user_config(tmp_path, payload)
+
+        OpenCodeDeployer._update_global_opencode_json(tmp_path)
+        updated = json.loads((tmp_path / "opencode.json").read_text(encoding="utf-8"))
+
+        assert "rules/*.md" not in updated["instructions"]
+        assert "rules/my-team.md" in updated["instructions"]
+
+
+class TestOwnershipByEvidence:
+    """2026-09-11 review, finding 1 (opencode side): the instruction filter
+    still retired refs by NAME — a registry legacy id colliding with the
+    user's own file name was enough to delete their reference.
+
+    R4: 名称不构成所有权证据. A ref is PactKit's only with trusted evidence:
+    the exact legacy wildcard value, a current managed ref, a manifest record,
+    or the referenced file's bytes still matching managed content.
+    """
+
+    def test_user_authored_legacy_named_ref_survives(self, tmp_path, capsys):
+        """Reviewer probe: the user's own rules/08-architecture-principles.md
+        (a registry legacy id, user-authored content) keeps its ref."""
+        (tmp_path / "rules").mkdir()
+        (tmp_path / "rules" / "08-architecture-principles.md").write_text(
+            "# Our architecture principles\n- ours, not PactKit's\n", encoding="utf-8",
+        )
+        _write_user_config(
+            tmp_path, {"instructions": ["rules/08-architecture-principles.md"]},
+        )
+
+        OpenCodeDeployer._update_global_opencode_json(tmp_path)
+
+        updated = json.loads((tmp_path / "opencode.json").read_text(encoding="utf-8"))
+        assert "rules/08-architecture-principles.md" in updated["instructions"], (
+            "a user-authored rule reference was retired by name collision"
+        )
+        assert "08-architecture-principles" in capsys.readouterr().out, (
+            "the preserved ref must be reported (R4: 有明确说明), not silent"
+        )
+
+    def test_manifest_recorded_ref_is_retired(self, tmp_path):
+        """Positive control: a ref the deployment manifest records as ours is
+        retired even when the file no longer exists to content-verify."""
+        from pactkit.deploy_manifest import MANIFEST_NAME
+
+        (tmp_path / MANIFEST_NAME).write_text(
+            json.dumps({"opencode_instructions": ["rules/old-managed.md"]}),
+            encoding="utf-8",
+        )
+        _write_user_config(tmp_path, {"instructions": ["rules/old-managed.md"]})
+
+        OpenCodeDeployer._update_global_opencode_json(tmp_path)
+
+        updated = json.loads((tmp_path / "opencode.json").read_text(encoding="utf-8"))
+        assert "rules/old-managed.md" not in updated["instructions"]
+
+    def test_legacy_content_matching_ref_is_retired(self, tmp_path):
+        """Positive control: the file's bytes still equal the managed content
+        PactKit deployed for that filename — ours, retired."""
+        from pactkit.prompts.rules import LEGACY_RULE_CONTENTS
+
+        filename = sorted(LEGACY_RULE_CONTENTS)[0]
+        (tmp_path / "rules").mkdir()
+        (tmp_path / "rules" / filename).write_text(
+            LEGACY_RULE_CONTENTS[filename], encoding="utf-8",
+        )
+        _write_user_config(tmp_path, {"instructions": [f"rules/{filename}"]})
+
+        OpenCodeDeployer._update_global_opencode_json(tmp_path)
+
+        updated = json.loads((tmp_path / "opencode.json").read_text(encoding="utf-8"))
+        assert f"rules/{filename}" not in updated["instructions"]
+
+    def test_modified_legacy_content_ref_survives(self, tmp_path):
+        """Same filename, user-edited bytes — the ref is preserved."""
+        from pactkit.prompts.rules import LEGACY_RULE_CONTENTS
+
+        filename = sorted(LEGACY_RULE_CONTENTS)[0]
+        (tmp_path / "rules").mkdir()
+        (tmp_path / "rules" / filename).write_text(
+            LEGACY_RULE_CONTENTS[filename] + "\n# user override\n", encoding="utf-8",
+        )
+        _write_user_config(tmp_path, {"instructions": [f"rules/{filename}"]})
+
+        OpenCodeDeployer._update_global_opencode_json(tmp_path)
+
+        updated = json.loads((tmp_path / "opencode.json").read_text(encoding="utf-8"))
+        assert f"rules/{filename}" in updated["instructions"]
+
+
+class TestIdempotence:
+    def test_repeated_updates_are_stable(self, tmp_path):
+        _write_user_config(tmp_path, USER_CONFIG)
+        OpenCodeDeployer._update_global_opencode_json(tmp_path)
+        first = (tmp_path / "opencode.json").read_text(encoding="utf-8")
+
+        OpenCodeDeployer._update_global_opencode_json(tmp_path)
+
+        assert (tmp_path / "opencode.json").read_text(encoding="utf-8") == first

pactkit_opencode-2.27.0/tests/test_a2_mcp_retired.py

@@ -0,0 +1,69 @@
+"""MCP injection surfaces are retired (STORY-slim-20260911b2bbd79889e0 A2/R3).
+
+Two dead-connection templates lived in this adapter:
+
+- ``_deploy_opencode_json`` — a full opencode.json generator embedding a
+  ``context7`` MCP server entry. It had **no production caller** (verified:
+  only tests referenced it), so nothing on a user's machine depends on it —
+  but leaving it in place is leaving a loaded injection template for the
+  next refactor to wire back up.
+- ``_print_mcp_recommendations_opencode`` — printed a Context7 registration
+  snippet after every deploy (R3: 部署不输出 MCP 安装推荐).
+
+A deploy now neither recommends nor references third-party servers. Optional
+tools the user configures themselves remain usable — that is the host's
+business, not the deployer's.
+"""
+
+from __future__ import annotations
+
+import json
+
+from pactkit_opencode.deployer import OpenCodeDeployer
+
+
+class TestDeadTemplatesRemoved:
+    def test_mcp_injection_template_is_gone(self):
+        """The dead generator must not ship — dead code with a live MCP
+        payload is a future injection waiting to be wired up."""
+        assert not hasattr(OpenCodeDeployer, "_deploy_opencode_json")
+
+    def test_mcp_recommendations_are_gone(self):
+        assert not hasattr(OpenCodeDeployer, "_print_mcp_recommendations_opencode")
+
+    def test_deployer_source_has_no_context7_reference(self):
+        import inspect
+
+        source = inspect.getsource(OpenCodeDeployer)
+        assert "context7" not in source.lower()
+        assert "mcp.context7.com" not in source
+
+
+class TestDeployOutputClean:
+    def test_deploy_prints_no_mcp_recommendation(self, tmp_path, capsys):
+        OpenCodeDeployer().deploy(target=str(tmp_path))
+
+        out = capsys.readouterr().out
+        # Assert on recommendation phrasing, not the bare word "mcp" — the
+        # output legitimately contains the target path, and this test's own
+        # tmp dir name contains "mcp" (substring false positive, same class
+        # as the pytest-of-slim lesson in the project's Key Decisions).
+        assert "context7" not in out.lower()
+        assert "recommended mcp" not in out.lower()
+        assert "mcp_servers" not in out.lower()
+        assert "mcp.context7.com" not in out.lower()
+
+    def test_global_config_update_mentions_no_mcp(self, tmp_path, capsys):
+        (tmp_path / "opencode.json").write_text(
+            json.dumps({"instructions": []}), encoding="utf-8"
+        )
+
+        OpenCodeDeployer._update_global_opencode_json(tmp_path)
+
+        out = capsys.readouterr().out
+        assert "mcp_servers" not in out.lower()
+        assert "context7" not in out.lower()
+        # The user's file must not gain an mcp_servers key either.
+        data = json.loads((tmp_path / "opencode.json").read_text(encoding="utf-8"))
+        assert "mcp_servers" not in data
+        assert "mcp" not in data

{pactkit_opencode-2.25.2 → pactkit_opencode-2.27.0}/tests/test_bug035_opencode_dual_layer.py

@@ -4,8 +4,8 @@ Tests for dual-layer deployment: global (pactkit init) vs project (/project-init
 """
 
 
+
 from pactkit.generators.deployer import deploy
-from pactkit_opencode.deployer import OpenCodeDeployer
 
 # ===========================================================================
 # R1: Global deployment does NOT generate opencode.json
@@ -96,27 +96,4 @@ class TestR3ProjectInitOpencodeDetection:
 # ===========================================================================
 
 
-class TestR5OpencodeJsonStructure:
-    """R5: _deploy_opencode_json helper produces correct structure."""
-
-    def test_opencode_json_helper_exists(self):
-        """_deploy_opencode_json function still exists for project-init use."""
-        assert callable(OpenCodeDeployer._deploy_opencode_json)
-
-    def test_opencode_json_has_schema(self, tmp_path):
-        """opencode.json contains $schema field."""
-        import json
-
-        OpenCodeDeployer._deploy_opencode_json(tmp_path)
-        data = json.loads((tmp_path / "opencode.json").read_text())
-        assert "$schema" in data
-        assert "opencode.ai" in data["$schema"]
-
-    def test_opencode_json_has_instructions(self, tmp_path):
-        """opencode.json contains instructions field."""
-        import json
-
-        OpenCodeDeployer._deploy_opencode_json(tmp_path)
-        data = json.loads((tmp_path / "opencode.json").read_text())
-        assert "instructions" in data
-        assert isinstance(data["instructions"], list)
+# Retired with STORY-slim-20260911b2bbd79889e0 A2/R3: _deploy_opencode_json is deleted (dead MCP-injection template).

{pactkit_opencode-2.25.2 → pactkit_opencode-2.27.0}/tests/test_deploy_opencode_parity.py

@@ -15,7 +15,6 @@ from pathlib import Path
 from unittest.mock import patch
 
 import yaml
-
 from pactkit_opencode.deployer import OpenCodeDeployer
 
 _PROJECT_ROOT = Path(__file__).parent.parent.parent
@@ -54,10 +53,9 @@ class TestOpenCodeSelectiveDeploy:
 
         with patch("pactkit_opencode.deployer.auto_merge_config_file", return_value=[]):
             with patch.object(OpenCodeDeployer, "_generate_project_agents_md"):
-                with patch.object(OpenCodeDeployer, "_print_mcp_recommendations_opencode"):
-                    with patch.object(OpenCodeDeployer, "_load_opencode_providers", return_value={}):
-                        with patch.object(OpenCodeDeployer, "_update_global_opencode_json"):
-                            OpenCodeDeployer().deploy(target=output_path)
+                with patch.object(OpenCodeDeployer, "_load_opencode_providers", return_value={}):
+                    with patch.object(OpenCodeDeployer, "_update_global_opencode_json"):
+                        OpenCodeDeployer().deploy(target=output_path)
 
         # Resolve macOS /var → /private/var symlink
         agents_dir = Path(output_path).resolve() / "agents"
@@ -73,11 +71,10 @@ class TestOpenCodeSelectiveDeploy:
 
         # No pactkit.yaml — no .opencode dir either
         with patch.object(OpenCodeDeployer, "_generate_project_agents_md"):
-            with patch.object(OpenCodeDeployer, "_print_mcp_recommendations_opencode"):
-                with patch.object(OpenCodeDeployer, "_load_opencode_providers", return_value={}):
-                    with patch.object(OpenCodeDeployer, "_update_global_opencode_json"):
-                        with patch("pactkit_opencode.deployer.Path.cwd", return_value=tmp_path):
-                            OpenCodeDeployer().deploy(target=str(tmp_path / "output"))
+            with patch.object(OpenCodeDeployer, "_load_opencode_providers", return_value={}):
+                with patch.object(OpenCodeDeployer, "_update_global_opencode_json"):
+                    with patch("pactkit_opencode.deployer.Path.cwd", return_value=tmp_path):
+                        OpenCodeDeployer().deploy(target=str(tmp_path / "output"))
 
         agents_dir = tmp_path / "output" / "agents"
         deployed_agents = list(agents_dir.glob("*.md")) if agents_dir.exists() else []
@@ -116,11 +113,10 @@ class TestOpenCodeAutoMerge:
         with patch("pactkit_opencode.deployer.auto_merge_config_file") as mock_merge:
             mock_merge.return_value = []
             with patch.object(OpenCodeDeployer, "_generate_project_agents_md"):
-                with patch.object(OpenCodeDeployer, "_print_mcp_recommendations_opencode"):
-                    with patch.object(OpenCodeDeployer, "_load_opencode_providers", return_value={}):
-                        with patch.object(OpenCodeDeployer, "_update_global_opencode_json"):
-                            with patch("pactkit_opencode.deployer.Path.cwd", return_value=tmp_path):
-                                OpenCodeDeployer().deploy(target=str(tmp_path / "output"))
+                with patch.object(OpenCodeDeployer, "_load_opencode_providers", return_value={}):
+                    with patch.object(OpenCodeDeployer, "_update_global_opencode_json"):
+                        with patch("pactkit_opencode.deployer.Path.cwd", return_value=tmp_path):
+                            OpenCodeDeployer().deploy(target=str(tmp_path / "output"))
 
         mock_merge.assert_called_once()
 
@@ -129,11 +125,10 @@ class TestOpenCodeAutoMerge:
         with patch("pactkit_opencode.deployer.auto_merge_config_file") as mock_merge:
             mock_merge.return_value = []
             with patch.object(OpenCodeDeployer, "_generate_project_agents_md"):
-                with patch.object(OpenCodeDeployer, "_print_mcp_recommendations_opencode"):
-                    with patch.object(OpenCodeDeployer, "_load_opencode_providers", return_value={}):
-                        with patch.object(OpenCodeDeployer, "_update_global_opencode_json"):
-                            with patch("pactkit_opencode.deployer.Path.cwd", return_value=tmp_path):
-                                OpenCodeDeployer().deploy(target=str(tmp_path / "output"))
+                with patch.object(OpenCodeDeployer, "_load_opencode_providers", return_value={}):
+                    with patch.object(OpenCodeDeployer, "_update_global_opencode_json"):
+                        with patch("pactkit_opencode.deployer.Path.cwd", return_value=tmp_path):
+                            OpenCodeDeployer().deploy(target=str(tmp_path / "output"))
         # auto_merge not called when no yaml found
         mock_merge.assert_not_called()
 
@@ -149,11 +144,10 @@ class TestOpenCodeCleanupLegacy:
     def test_cleanup_legacy_called(self, tmp_path):
         with patch("pactkit_opencode.deployer._cleanup_legacy") as mock_cleanup:
             with patch.object(OpenCodeDeployer, "_generate_project_agents_md"):
-                with patch.object(OpenCodeDeployer, "_print_mcp_recommendations_opencode"):
-                    with patch.object(OpenCodeDeployer, "_load_opencode_providers", return_value={}):
-                        with patch.object(OpenCodeDeployer, "_update_global_opencode_json"):
-                            with patch("pactkit_opencode.deployer.Path.cwd", return_value=tmp_path):
-                                OpenCodeDeployer().deploy(target=str(tmp_path / "output"))
+                with patch.object(OpenCodeDeployer, "_load_opencode_providers", return_value={}):
+                    with patch.object(OpenCodeDeployer, "_update_global_opencode_json"):
+                        with patch("pactkit_opencode.deployer.Path.cwd", return_value=tmp_path):
+                            OpenCodeDeployer().deploy(target=str(tmp_path / "output"))
         mock_cleanup.assert_called_once()
 
 
@@ -198,26 +192,24 @@ class TestGenerateProjectAgentsMd:
     def test_called_from_deploy_opencode_when_no_target(self, tmp_path):
         """_generate_project_agents_md is called only when target is None."""
         with patch.object(OpenCodeDeployer, "_generate_project_agents_md") as mock_gen:
-            with patch.object(OpenCodeDeployer, "_print_mcp_recommendations_opencode"):
-                with patch.object(OpenCodeDeployer, "_load_opencode_providers", return_value={}):
-                    with patch.object(OpenCodeDeployer, "_update_global_opencode_json"):
-                        with patch("pactkit_opencode.deployer.Path.cwd", return_value=tmp_path):
-                            # With explicit target: should NOT call generate
-                            OpenCodeDeployer().deploy(target=str(tmp_path / "output"))
+            with patch.object(OpenCodeDeployer, "_load_opencode_providers", return_value={}):
+                with patch.object(OpenCodeDeployer, "_update_global_opencode_json"):
+                    with patch("pactkit_opencode.deployer.Path.cwd", return_value=tmp_path):
+                        # With explicit target: should NOT call generate
+                        OpenCodeDeployer().deploy(target=str(tmp_path / "output"))
         mock_gen.assert_not_called()
 
     def test_called_from_deploy_opencode_without_target(self, tmp_path):
         """When target is None, _generate_project_agents_md IS called."""
         with patch.object(OpenCodeDeployer, "_generate_project_agents_md") as mock_gen:
-            with patch.object(OpenCodeDeployer, "_print_mcp_recommendations_opencode"):
-                with patch.object(OpenCodeDeployer, "_load_opencode_providers", return_value={}):
-                    with patch.object(OpenCodeDeployer, "_update_global_opencode_json"):
-                        with patch("pactkit_opencode.deployer.Path") as MockPath:
-                            MockPath.side_effect = Path
-                            MockPath.home.return_value = Path.home()
-                            MockPath.cwd.return_value = tmp_path
-                            # Pass target so we don't write to real ~/.config/opencode
-                            OpenCodeDeployer().deploy(target=str(tmp_path / "output"))
+            with patch.object(OpenCodeDeployer, "_load_opencode_providers", return_value={}):
+                with patch.object(OpenCodeDeployer, "_update_global_opencode_json"):
+                    with patch("pactkit_opencode.deployer.Path") as MockPath:
+                        MockPath.side_effect = Path
+                        MockPath.home.return_value = Path.home()
+                        MockPath.cwd.return_value = tmp_path
+                        # Pass target so we don't write to real ~/.config/opencode
+                        OpenCodeDeployer().deploy(target=str(tmp_path / "output"))
         # With explicit target, not called
         mock_gen.assert_not_called()
 
@@ -251,14 +243,6 @@ class TestDeployChainParity:
         src = self._get_opencode_source()
         assert "_generate_project_agents_md" in src
 
-    def test_opencode_calls_print_mcp_recommendations(self):
-        src = self._get_opencode_source()
-        assert "mcp_recommendations" in src or "_print_mcp_recommendations" in src
-
-
-# ---------------------------------------------------------------------------
-# R7: _generate_config_if_missing format param
-# ---------------------------------------------------------------------------
 
 
 class TestGenerateConfigIfMissing:

pactkit_opencode-2.27.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 OPENCODE 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 = "opencode"
+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)

{pactkit_opencode-2.25.2 → pactkit_opencode-2.27.0}/tests/test_story069_opencode_format.py

@@ -3,12 +3,10 @@ STORY-069: OpenCode Deployment Format Support
 Tests for `pactkit init --format opencode` deployment mode.
 """
 
-import json
 from unittest.mock import patch
 
 from pactkit.config import VALID_AGENTS, VALID_COMMANDS, VALID_FORMATS, VALID_SKILLS
 from pactkit.generators.deployer import deploy
-from pactkit_opencode.deployer import OpenCodeDeployer
 
 # OpenCode deploys commands to commands/{name}.md (invoked via /command-name)
 # and embedded skills to skills/{name}/SKILL.md (auto-discovered by AI agent).
@@ -230,36 +228,9 @@ class TestR5SkillsPathRewriting:
 # ===========================================================================
 
 
-class TestR6OpenCodeJsonGeneration:
-    """R6: opencode.json helper has correct structure (BUG-035: project-level file)."""
-
-    def test_opencode_json_has_schema(self, tmp_path):
-        """opencode.json contains $schema field."""
-        OpenCodeDeployer._deploy_opencode_json(tmp_path)
-        data = json.loads((tmp_path / "opencode.json").read_text())
-        assert "$schema" in data
-        assert "opencode.ai" in data["$schema"]
-
-    def test_opencode_json_has_instructions(self, tmp_path):
-        """opencode.json contains instructions field."""
-        OpenCodeDeployer._deploy_opencode_json(tmp_path)
-        data = json.loads((tmp_path / "opencode.json").read_text())
-        assert "instructions" in data
-        assert isinstance(data["instructions"], list)
-
-    def test_opencode_json_no_api_key(self, tmp_path):
-        """opencode.json does NOT contain apiKey or provider secrets."""
-        OpenCodeDeployer._deploy_opencode_json(tmp_path)
-        content = (tmp_path / "opencode.json").read_text()
-        assert "apiKey" not in content
-        assert "api_key" not in content
-        assert "API_KEY" not in content
-
-
-# ===========================================================================
-# R11: CLI --format opencode
-# ===========================================================================
-
+# Retired with STORY-slim-20260911b2bbd79889e0 A2/R3: _deploy_opencode_json
+# (the dead MCP-injection template) is deleted; the live global-config path
+# is covered by test_a1_config_recovery + test_a2_mcp_retired.
 
 class TestR11CliFormatOpenCode:
     """R11: CLI --format includes opencode option."""

{pactkit_opencode-2.25.2 → pactkit_opencode-2.27.0}/tests/test_story071_opencode_config_parity.py

@@ -6,88 +6,17 @@ Tests for rules splitting, permission config, MCP template, and global opencode.
 import json
 
 from pactkit.generators.deployer import deploy
-from pactkit_opencode.deployer import OpenCodeDeployer
 
 # ===========================================================================
 # AC1: opencode.json (project-level) contains permission
 # ===========================================================================
 
 
-class TestAC1Permission:
-    """AC1: _deploy_opencode_json generates permission config."""
+# Retired with STORY-slim-20260911b2bbd79889e0 A2/R3: _deploy_opencode_json is deleted (dead MCP-injection template).
 
-    def test_has_permission_field(self, tmp_path):
-        """opencode.json contains 'permission' key."""
-        OpenCodeDeployer._deploy_opencode_json(tmp_path)
-        data = json.loads((tmp_path / "opencode.json").read_text())
-        assert "permission" in data
-
-    def test_bash_deny_rules(self, tmp_path):
-        """permission.bash contains dangerous command deny rules."""
-        OpenCodeDeployer._deploy_opencode_json(tmp_path)
-        data = json.loads((tmp_path / "opencode.json").read_text())
-        bash_perms = data["permission"]["bash"]
-        assert bash_perms.get("rm -rf /*") == "deny"
-        assert bash_perms.get("sudo rm *") == "deny"
-        assert bash_perms.get("curl * | sh") == "deny"
-
-    def test_env_file_deny(self, tmp_path):
-        """permission.read denies .env files."""
-        OpenCodeDeployer._deploy_opencode_json(tmp_path)
-        data = json.loads((tmp_path / "opencode.json").read_text())
-        read_perms = data["permission"]["read"]
-        assert read_perms.get("*.env") == "deny"
-        assert read_perms.get("*.env.example") == "allow"
-
-
-# ===========================================================================
-# AC2: opencode.json (project-level) contains MCP template
-# ===========================================================================
-
-
-class TestAC2MCP:
-    """AC2: _deploy_opencode_json generates MCP config template."""
-
-    def test_has_mcp_field(self, tmp_path):
-        """opencode.json contains 'mcp' key."""
-        OpenCodeDeployer._deploy_opencode_json(tmp_path)
-        data = json.loads((tmp_path / "opencode.json").read_text())
-        assert "mcp" in data
-
-    def test_context7_remote(self, tmp_path):
-        """mcp.context7 exists with type=remote."""
-        OpenCodeDeployer._deploy_opencode_json(tmp_path)
-        data = json.loads((tmp_path / "opencode.json").read_text())
-        ctx7 = data["mcp"]["context7"]
-        assert ctx7["type"] == "remote"
-        assert "context7.com" in ctx7["url"]
-
-
-# ===========================================================================
-# AC3: opencode.json preserves existing fields
-# ===========================================================================
-
-
-class TestAC3PreserveFields:
-    """AC3: opencode.json still has $schema and instructions."""
-
-    def test_has_schema(self, tmp_path):
-        """opencode.json contains $schema."""
-        OpenCodeDeployer._deploy_opencode_json(tmp_path)
-        data = json.loads((tmp_path / "opencode.json").read_text())
-        assert "$schema" in data
-
-    def test_has_instructions(self, tmp_path):
-        """opencode.json contains instructions."""
-        OpenCodeDeployer._deploy_opencode_json(tmp_path)
-        data = json.loads((tmp_path / "opencode.json").read_text())
-        assert "instructions" in data
-
-
-# ===========================================================================
-# AC4: project-init playbook mentions pactkit.yaml location
-# ===========================================================================
+# Retired with STORY-slim-20260911b2bbd79889e0 A2/R3: the MCP template never shipped to users (no production caller).
 
+# Retired with STORY-slim-20260911b2bbd79889e0 A2/R3: pinned the deleted template's fields.
 
 class TestAC4PlaybookPactkitYaml:
     """AC4: project-init playbook explains pactkit.yaml stays in .claude/ (classic) or .opencode/ (OpenCode)."""

{pactkit_opencode-2.25.2 → pactkit_opencode-2.27.0}/tests/test_story073_command_model_routing.py

@@ -5,9 +5,10 @@ Tests for command model routing (in opencode.json), project-init conditional, YA
 
 import json
 
+from pactkit_opencode.deployer import OpenCodeDeployer
+
 from pactkit.config import get_default_config
 from pactkit.generators.deployer import deploy
-from pactkit_opencode.deployer import OpenCodeDeployer
 
 _resolve_opencode_model_id = OpenCodeDeployer._resolve_opencode_model_id
 

{pactkit_opencode-2.25.2 → pactkit_opencode-2.27.0}/tests/test_story_work_units.py

@@ -1,9 +1,10 @@
 import json
 
+from pactkit_opencode.deployer import OpenCodeDeployer
+
 from pactkit.generators.deployer import _render_skill_md
 from pactkit.portable_methods import get_portable_methods
 from pactkit.profiles import get_profile
-from pactkit_opencode.deployer import OpenCodeDeployer
 
 
 def test_opencode_uses_native_current_session_contract_without_portable_methods(tmp_path):

pactkit_opencode-2.25.2/src/pactkit_opencode.egg-info/requires.txt

@@ -1 +0,0 @@
-pactkit<2.26.0,>=2.25.2