xrefkit 0.7.1__tar.gz → 0.7.3__tar.gz

{xrefkit-0.7.1/xrefkit.egg-info → xrefkit-0.7.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xrefkit
-Version: 0.7.1
+Version: 0.7.3
 Summary: Portable XID, Skill, Knowledge, workflow, and MCP runtime for XRefKit
 Author: synthaicode
 License: MIT License

{xrefkit-0.7.1 → xrefkit-0.7.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "xrefkit"
-version = "0.7.1"
+version = "0.7.3"
 description = "Portable XID, Skill, Knowledge, workflow, and MCP runtime for XRefKit"
 readme = "README.md"
 requires-python = ">=3.11"

{xrefkit-0.7.1 → xrefkit-0.7.3}/tests/test_ci_workflow_invariants.py

@@ -1,5 +1,7 @@
 """CI cleanup must retain release coverage and only cancel obsolete PR runs."""
 from pathlib import Path
+import shutil
+import subprocess
 
 import pytest
 import yaml
@@ -16,6 +18,36 @@ PACKAGES = {
 }
 
 
+@pytest.mark.parametrize("stop_status,remains,expected", [
+    (0, False, 0), (1, False, 0), (1, True, 1), (2, False, 2),
+])
+def test_core_updater_stop_handles_exit_race_without_hiding_errors(stop_status, remains, expected):
+    bash = shutil.which("bash")
+    if Path("C:/Program Files/Git/bin/bash.exe").is_file():
+        bash = "C:/Program Files/Git/bin/bash.exe"
+    if not bash:
+        pytest.skip("Bash is required to execute the workflow stop block")
+    steps = workflow("python-package.yml")["jobs"]["artifact-inspection"]["steps"]
+    update = next(s["run"] for s in steps if "sudo apt-get install --yes clamav" in s.get("run", ""))
+    block = update.split("# Package installation", 1)[1].split("# A failed definition update", 1)[0]
+    block = "# Package installation" + block
+    mocks = f"""
+set -euo pipefail
+calls=0
+pgrep() {{
+  calls=$((calls + 1))
+  if [ "$calls" -eq 1 ]; then return 0; fi
+  return {0 if remains else 1}
+}}
+sudo() {{ return {stop_status}; }}
+sleep() {{ :; }}
+"""
+    result = subprocess.run([bash, "-c", mocks + block + "\necho stop-complete\n"],
+                            capture_output=True, text=True)
+    assert result.returncode == expected, result.stdout + result.stderr
+    assert ("stop-complete" in result.stdout) == (expected == 0)
+
+
 def workflow(filename):
     # BaseLoader preserves GitHub's `on` key instead of YAML 1.1's boolean True.
     return yaml.load((WORKFLOWS / filename).read_text(encoding="utf-8"), Loader=yaml.BaseLoader)
@@ -188,3 +220,38 @@ def test_shared_tools_trigger_only_consumers():
         assert not accepts_changes(filename, "pull_request", ["tools/run_quality_gate.py"])
     assert not accepts_changes("python-skill-csharp-package.yml", "pull_request", ["tools/run_import_smoke.py"])
     assert not accepts_changes("xrefkit-skills-xddp-design.yml", "pull_request", ["xrefkit/cli.py"])
+
+
+def test_pages_deployment_is_main_only_and_release_dispatch_has_no_environment():
+    data = workflow("pages.yml")
+    deploy = data["jobs"]["deploy"]
+    condition = " ".join(deploy["if"].split())
+    assert condition.startswith("github.ref == 'refs/heads/main' && (")
+    assert deploy["environment"]["name"] == "github-pages"
+    route = data["jobs"]["dispatch-release"]
+    assert route["if"] == "github.event_name == 'release'"
+    assert "environment" not in route
+    assert route["permissions"] == {"contents": "read", "actions": "write"}
+    assert data["permissions"]["pages"] == "write"
+    step = route["steps"][0]
+    assert step["env"]["RELEASE_REPOSITORY"] == "${{ github.repository }}"
+    assert step["env"]["GH_TOKEN"] == "${{ github.token }}"
+    assert "github.event.release" not in step["run"]
+
+
+@pytest.mark.parametrize("dispatch_exit", [0, 37])
+def test_pages_release_dispatch_executes_fixed_main_target_and_preserves_failure(dispatch_exit):
+    bash = shutil.which("bash")
+    if Path("C:/Program Files/Git/bin/bash.exe").is_file():
+        bash = "C:/Program Files/Git/bin/bash.exe"
+    if not bash:
+        pytest.skip("Bash is required to execute the Pages dispatch block")
+    script = workflow("pages.yml")["jobs"]["dispatch-release"]["steps"][0]["run"]
+    mock = ('set -euo pipefail\nRELEASE_REPOSITORY=synthaicode/XRefKit\n'
+            'gh() { printf "<%s>\\n" "$@"; return ' + str(dispatch_exit) + '; }\n')
+    result = subprocess.run([bash, "-c", mock + script + "\necho dispatch-complete\n"],
+                            capture_output=True, text=True)
+    assert result.returncode == dispatch_exit, result.stdout + result.stderr
+    assert result.stdout.splitlines()[:6] == ["<api>", "<--method>", "<POST>",
+        "<repos/synthaicode/XRefKit/actions/workflows/pages.yml/dispatches>", "<-f>", "<ref=main>"]
+    assert ("dispatch-complete" in result.stdout) == (dispatch_exit == 0)

{xrefkit-0.7.1 → xrefkit-0.7.3}/tests/test_cli.py

@@ -1000,7 +1000,13 @@ class CliTests(unittest.TestCase):
             )
             text = out.read_text(encoding="utf-8")
             self.assertIn("## Domain Knowledge Inputs", text)
-            self.assertIn("- rule: available and selected brownfield domain knowledge is recorded by XID only", text)
+            self.assertIn("- log_format: `compact_v1`", text)
+            self.assertIn("- operating_contract_xid: `B7A2C94F0E61`", text)
+            self.assertIn(
+                "### Selected Knowledge Inputs\n\n- target_service_structure:\n"
+                "  - `LOCAL-SERVICE-MAP-001`\n  - `LOCAL-DB-SCHEMA-001`",
+                text,
+            )
             self.assertIn("- xid: `LOCAL-SERVICE-MAP-001`", text)
             self.assertIn("content_hash: `sha256-service-map`", text)
             self.assertIn("last_verified: `2026-07-04`", text)

xrefkit-0.7.3/tests/test_compact_skill_logs.py

@@ -0,0 +1,190 @@
+import pytest
+
+from test_skill_definition_runtime import _open_run
+from test_subagent_startup import command
+from xrefkit.skillrun import _section_body
+
+
+@pytest.mark.parametrize("legacy", [False, True])
+def test_compact_and_legacy_logs_keep_evidence_through_closure(tmp_path, legacy):
+    _, log = _open_run(tmp_path)
+    text = log.read_text(encoding="utf-8")
+    marker = "- log_format: `compact_v1`\n- operating_contract_xid: `B7A2C94F0E61`\n"
+    assert marker in text
+    assert "- rule:" not in text
+    if legacy:
+        text = text.replace(marker, "", 1)
+        text = text.replace(
+            "## Token Usage\n\n", "## Token Usage\n\n- rule: legacy token guidance\n", 1
+        )
+        log.write_text(text, encoding="utf-8")
+
+    def update(*args):
+        code, output = command("skill", *args, "--log", str(log))
+        assert code == 0, output
+
+    # User data that resembles omitted template lines must survive updates.
+    note = "literal evidence\n- rule: user supplied detail\n- log_format: `compact_v1`"
+    update("tokens", "--input", "120", "--output", "30", "--note", note)
+    update("workitem", "--item", "WI-1", "--completion-criterion", "report covers target", "--status", "done", "--role", "definition_sample:executor")
+    for artifact_id, kind, target in (
+        ("OUT", "output", "report.md"), ("EVIDENCE", "evidence", "tests passed"),
+    ):
+        update("artifact", "--artifact", artifact_id, "--kind", kind, "--target", target,
+               "--item", "WI-1", "--status", "done", "--role", "definition_sample:executor")
+    update("concern", "--concern", "RISK", "--kind", "risk", "--status", "resolved",
+           "--text", "Compatibility checked", "--target", "tests passed", "--role", "definition_sample:executor")
+    for phase in ("startup", "planning", "execution"):
+        update("phase", "--phase", phase, "--status", "done", "--role", "definition_sample:executor")
+    update("verify")
+    update("phase", "--phase", "handoff", "--status", "done", "--role", "definition_sample:handoff_owner")
+    update("close")
+    text = log.read_text(encoding="utf-8")
+    assert note in text
+    assert "Compatibility checked" in text
+    assert ("- rule: each work item requires" in text) is legacy
+    assert ("- rule: outputs, evidence" in text) is legacy
+    assert ("- rule: unknowns, missing evidence" in text) is legacy
+    assert "- total: `150`" in text
+    assert "- target: report.md" in text or "target=`report.md`" in text
+    assert "## Closure Gate\n\n- status: `done`" in text
+    assert ("- rule: record tokens consumed" in text) is legacy
+    for section in ("Worklist", "Quality Gate"):
+        body, _, _ = _section_body(text, section)
+        for heading in ("Status", "Result", "Checks Performed", "Evidence", "Open Items", "Handoff"):
+            assert f"### {heading}\n" in body
+
+
+def test_workflow_log_keeps_existing_format(tmp_path):
+    log = tmp_path / "work" / "workflow.md"
+    code, output = command(
+        "workflow", "run", "--root", str(tmp_path), "--task", "Inspect target",
+        "--completion-condition", "Target inspected", "--out", str(log),
+    )
+    assert code == 0, output
+    original = log.read_text(encoding="utf-8")
+    assert "log_format" not in original
+    assert "- rule: do not treat the instruction" in original
+    code, output = command("skill", "tokens", "--log", str(log), "--total", "20")
+    assert code == 0, output
+    assert "- rule: record tokens consumed" in log.read_text(encoding="utf-8")
+
+
+def test_compaction_only_removes_template_rules_and_preserves_task(monkeypatch, tmp_path):
+    from xrefkit import skillrun
+
+    render = skillrun._render_log
+    captured = {}
+
+    def capture(**kwargs):
+        captured.update(kwargs)
+        return render(**kwargs)
+
+    monkeypatch.setattr(skillrun, "_render_log", capture)
+    _open_run(tmp_path)
+    captured["task"] = "Keep these literal lines:\n- rule: task requirement\n- log_format: `other`"
+    compact = render(**captured)
+    verbose = render(**{**captured, "compact": False})
+    assert captured["task"] in compact
+    assert len(compact.encode("utf-8")) < len(verbose.encode("utf-8")) * 0.8
+
+    # Every non-boilerplate line survives in the same order, including reports.
+    def data_lines(text):
+        return [line for line in text.splitlines() if line and not line.startswith((
+            "- rule:", "- log_format:", "- operating_contract_xid:",
+        ))]
+
+    assert data_lines(compact) == data_lines(verbose)
+
+
+def test_dashboard_payload_is_identical_for_compact_and_verbose_runs(monkeypatch, tmp_path):
+    import json
+    import os
+    from datetime import datetime, timezone
+    from itertools import count
+    from uuid import UUID
+
+    from xrefkit import dashboard, skillrun
+
+    render = skillrun._render_log
+    captured = {}
+
+    def capture(**kwargs):
+        captured.update(kwargs)
+        return render(**kwargs)
+
+    monkeypatch.setattr(skillrun, "_render_log", capture)
+    _, log = _open_run(tmp_path)
+    provenance = {"capability": {"origin": "explicit_input", "selected_value": "repository inspection"}}
+
+    class FixedDatetime(datetime):
+        @classmethod
+        def now(cls, tz=None):
+            fixed = cls(2026, 10, 25, 12, 0, tzinfo=timezone.utc)
+            return fixed.astimezone(tz) if tz else fixed.replace(tzinfo=None)
+
+    monkeypatch.setattr(skillrun, "datetime", FixedDatetime)
+    monkeypatch.setattr(dashboard, "datetime", FixedDatetime)
+    snapshots = []
+    for compact in (False, True):
+        event_ids = count(1)
+        monkeypatch.setattr(skillrun.uuid, "uuid4", lambda: UUID(int=next(event_ids)))
+        identity = {**captured["definition_identity"], "runtime_provenance": json.dumps(
+            provenance, sort_keys=True, separators=(",", ":") if compact else None,
+        )}
+        log.write_text(render(**{**captured, "definition_identity": identity, "compact": compact}), encoding="utf-8")
+
+        def snapshot():
+            # Compare the whole public payload, with no fields removed. The same
+            # file path and frozen clocks make file/observation timestamps equal.
+            os.utime(log, (1792929600, 1792929600))
+            return dashboard.build_payload(tmp_path, log.parent)
+
+        def update(*args):
+            code, output = command("skill", *args, "--log", str(log))
+            assert code == 0, output
+
+        initial = snapshot()
+        assert "token_usage" in {item["code"] for item in initial["runs"][0]["missing_information"]}
+        update("workitem", "--item", "WI-1", "--text", "Inspect target",
+               "--completion-criterion", "report covers target", "--status", "done", "--role", "definition_sample:executor")
+        for artifact_id, kind, target in (("OUT-1", "output", "report.md"), ("EVD-1", "evidence", "tests passed")):
+            update("artifact", "--artifact", artifact_id, "--kind", kind, "--target", target,
+                   "--item", "WI-1", "--status", "done", "--role", "definition_sample:executor")
+        update("concern", "--concern", "RISK-1", "--kind", "risk", "--status", "resolved",
+               "--text", "Compatibility checked", "--target", "tests passed", "--role", "definition_sample:executor")
+        update("correlate", "--run-id", captured["run_id"], "--mcp-session-id", "mcp-1", "--repository-fingerprint", "repo-1")
+        update("routing", "--selected-skill", "definition_sample", "--candidate", "definition_sample", "--reason", "best match")
+        update("knowledge", "--action", "search", "--query", "service map", "--status", "hit", "--xid", "SERVICE123456")
+        update("knowledge", "--action", "load", "--xid", "SERVICE123456", "--content-hash", "hash-1")
+        update("knowledge", "--action", "apply", "--xid", "SERVICE123456", "--content-hash", "hash-1", "--target", "OUT-1")
+        update("feedback", "--kind", "human", "--status", "accepted", "--note", "accepted")
+        update("feedback", "--kind", "outcome", "--status", "successful", "--note", "successful")
+        update("tokens", "--input", "120", "--output", "30")
+        populated = snapshot()
+        run = populated["runs"][0]
+        assert run["missing_information"] == []
+        assert run["counts"]["work_items"] == 1
+        assert run["counts"]["artifacts"] == 2
+        assert run["counts"]["risks"] == 1
+        assert run["loaded_xids"] == run["used_xids"] == ["SERVICE123456"]
+        assert run["definition_format"] == "skill_definition_v1"
+        assert run["definition_xid"] == "ABCDEF123456"
+        assert run["definition_sha256"] == captured["definition_identity"]["sha256"]
+        assert run["capability"] == "repository inspection"
+        assert {event["event"] for event in run["observation_events"]} >= {
+            "skill.routed", "knowledge.search", "knowledge.loaded", "knowledge.applied", "human.feedback", "outcome.feedback",
+        }
+        for phase in ("startup", "planning", "execution"):
+            update("phase", "--phase", phase, "--status", "done", "--role", "definition_sample:executor")
+        update("verify")
+        update("phase", "--phase", "handoff", "--status", "done", "--role", "definition_sample:handoff_owner")
+        update("close")
+        closed = snapshot()
+        assert closed["runs"][0]["status"] == "closed"
+        text = log.read_text(encoding="utf-8")
+        assert json.loads(skillrun._log_field(text, "definition_runtime_provenance")) == provenance
+        assert skillrun._parse_token_usage(text) == {"status": "recorded", "input": "120", "output": "30", "total": "150"}
+        snapshots.append((initial, populated, closed))
+
+    assert snapshots[0] == snapshots[1]

xrefkit-0.7.3/tests/test_contribution_adoption_bytes.py

@@ -0,0 +1,240 @@
+"""Raw-byte preparation checks without human review, gate dispatch or adoption."""
+from __future__ import annotations
+
+import hashlib
+import json
+import uuid
+from pathlib import Path
+
+import pytest
+
+from test_subagent_startup import command
+from xrefkit import governance_entry
+from xrefkit.mcp import contribution_returns as cr
+from xrefkit.mcp.audit import SessionRunBinding
+from xrefkit.mcp.catalog import XRefCatalog
+from xrefkit.mcp.update_gate_intake import prepare_contribution_gate
+from xrefkit.ownership import Ownership, Zone
+
+
+VARIANTS = [
+    pytest.param(b"# Rule\nalpha\nbeta\n", id="LF"),
+    pytest.param(b"# Rule\r\nalpha\r\nbeta\r\n", id="CRLF"),
+    pytest.param(b"# Rule\ralpha\rbeta\r", id="CR"),
+    pytest.param(b"# Rule\r\nalpha\nbeta\rgamma\r\n", id="mixed"),
+    pytest.param("# 検証\n条件：日本語\n".encode(), id="nonASCII-LF"),
+    pytest.param("# 検証\r\n条件：日本語\r\n".encode(), id="nonASCII-CRLF"),
+]
+
+
+def _pending(root: Path, raw: bytes) -> tuple[Path, dict]:
+    content = "<!-- xid: BUG3TEST01 -->\n" + raw.decode("utf-8", errors="strict")
+    identity = str(uuid.uuid4())
+    cr.submit_contribution_return(
+        root,
+        binding=SessionRunBinding(str(uuid.uuid4()), str(uuid.uuid4()), "a" * 32, "sample"),
+        source_snapshot={"provider_id": "xrefkit-mcp", "provider_version": "test",
+                         "package_id": None, "package_version": None, "skill_id": "sample",
+                         "skill_content_hash": "b" * 64, "knowledge_versions": [],
+                         "verification": "matched_current_catalog"},
+        contribution_id=identity, kind="knowledge", title="Byte fixture",
+        summary="Unapproved preparation fixture", files=[{"path": "rule.md", "content": content,
+        "content_hash": hashlib.sha256(content.encode()).hexdigest()}],
+        knowledge={"xid": "BUG3TEST01"}, proposed_target_path="knowledge/byte_fixture.md",
+    )
+    record = root / cr.STORE_RELATIVE / identity
+    return record, json.loads((record / "manifest.json").read_bytes())
+
+
+def _inventory(root: Path) -> dict[str, bytes]:
+    return {p.relative_to(root).as_posix(): p.read_bytes()
+            for p in root.rglob("*") if p.is_file()}
+
+
+@pytest.mark.parametrize("raw", VARIANTS)
+def test_stored_files_preserve_original_bytes_and_repeated_reads(tmp_path: Path, raw: bytes) -> None:
+    record, manifest = _pending(tmp_path, raw)
+    original = (record / "files/rule.md").read_bytes()
+    before = _inventory(tmp_path)
+    assert cr.list_contribution_returns(tmp_path)[0]["status"] == "pending_review"
+    exported = cr.export_contribution_return(tmp_path, manifest["contribution_id"])
+    assert exported["review_bundle"]["files"][0]["content"].encode() == original
+    cr._verify_manifest_payload(record, manifest)
+    first = cr._stored_files(record, manifest)
+    assert first == cr._stored_files(record, manifest)
+    assert first[0].content.encode("utf-8") == original
+    assert first[0].content_hash == hashlib.sha256(original).hexdigest()
+    assert manifest["files"][0]["byte_count"] == len(original)
+    # This is the same encode used by gate intake, without bypassing its approval gate.
+    staged = tmp_path / "scratch/unapproved-candidate.md"
+    staged.parent.mkdir()
+    staged.write_bytes(first[0].content.encode("utf-8"))
+    assert staged.read_bytes() == original
+    staged.unlink()
+    assert _inventory(tmp_path) == before
+    assert not (record / "events").exists()
+    assert not (tmp_path / "knowledge").exists()
+
+
+@pytest.mark.parametrize("corruption", ["hash", "byte_count", "invalid_utf8", "changed_bytes", "missing", "newline_only"])
+def test_stored_files_reject_corrupt_candidate(tmp_path: Path, corruption: str) -> None:
+    record, manifest = _pending(tmp_path, b"# Rule\nbody\n")
+    stored = record / "files/rule.md"
+    if corruption == "hash":
+        manifest["files"][0]["content_hash"] = "0" * 64
+    elif corruption == "byte_count":
+        manifest["files"][0]["byte_count"] += 1
+    elif corruption == "invalid_utf8":
+        invalid = stored.read_bytes() + b"\xff"
+        stored.write_bytes(invalid)
+        manifest["files"][0].update(content_hash=hashlib.sha256(invalid).hexdigest(), byte_count=len(invalid))
+    elif corruption == "changed_bytes":
+        stored.write_bytes(stored.read_bytes() + b"tamper")
+    elif corruption == "newline_only":
+        stored.write_bytes(stored.read_bytes().replace(b"\n", b"\r\n"))
+    else:
+        stored.unlink()
+    before = _inventory(tmp_path)
+    with pytest.raises((ValueError, FileNotFoundError)):
+        cr._stored_files(record, manifest)
+    assert _inventory(tmp_path) == before
+
+
+@pytest.mark.parametrize("corruption", ["payload", "extra_file", "deleted_file", "byte_count", "metadata_xid_tamper"])
+def test_preparation_verifier_retains_manifest_and_tree_rejections(tmp_path: Path, corruption: str) -> None:
+    record, manifest = _pending(tmp_path, b"# Rule\nbody\n")
+    if corruption == "payload":
+        manifest["summary"] += " tampered"
+    elif corruption == "extra_file":
+        (record / "files/extra.md").write_bytes(b"extra")
+    elif corruption == "deleted_file":
+        (record / "files/rule.md").unlink()
+    elif corruption == "byte_count":
+        manifest["files"][0]["byte_count"] += 1
+    else:
+        manifest["kind_metadata"]["xid"] = "UNLISTED01"
+    before = _inventory(tmp_path)
+    with pytest.raises(ValueError):
+        cr._verify_manifest_payload(record, manifest)
+    assert _inventory(tmp_path) == before
+
+
+class _ReadOnlyTargetRoot:
+    """Route a logical target to a real scratch file; never create canonical paths."""
+    def __init__(self, target: Path):
+        self.target = target
+
+    def joinpath(self, *parts: str) -> Path:
+        assert parts == ("knowledge", "byte_fixture.md")
+        return self.target
+
+
+def _target_check(target: Path, raw: bytes, **changes) -> str:
+    xid = "BUG3TEST01"
+    logical = "knowledge/byte_fixture.md"
+    kwargs = dict(ownership=Ownership((Zone("kernel-content", "base", ("knowledge/",), True,
+                                          True, True, False),)),
+                  existing_knowledge_xids={xid}, existing_knowledge_xid_locations={xid: {logical}},
+                  repository_xid_paths={xid: {logical}}, allow_same_xid_after_prepare=True)
+    kwargs.update(changes)
+    return cr._validate_canonical_target(
+        _ReadOnlyTargetRoot(target),
+        {"kind": "knowledge", "kind_metadata": {"xid": xid},
+         "files": [{"content_hash": hashlib.sha256(raw).hexdigest(), "byte_count": len(raw)}]},
+        logical, **kwargs,
+    )
+
+
+@pytest.mark.parametrize("raw", VARIANTS)
+def test_recovery_target_matches_raw_hash_without_newline_conversion(tmp_path: Path, raw: bytes) -> None:
+    target = tmp_path / "scratch-target.md"
+    target.write_bytes(raw)
+    before = target.read_bytes()
+    assert _target_check(target, raw) == "knowledge/byte_fixture.md"
+    assert target.read_bytes() == before
+    assert not (tmp_path / "knowledge").exists()
+
+
+@pytest.mark.parametrize("mismatch", ["target_version", "expected_hash", "duplicate_xid", "unlocated_xid", "no_prepare", "missing_target", "newline_only"])
+def test_recovery_retains_collision_and_version_rejections(tmp_path: Path, mismatch: str) -> None:
+    original = b"# Original\nbody\n"
+    target = tmp_path / "scratch-target.md"
+    target.write_bytes(original)
+    expected = original
+    changes = {}
+    if mismatch == "target_version":
+        target.write_bytes(b"# Other version\nbody\n")
+    elif mismatch == "newline_only":
+        target.write_bytes(original.replace(b"\n", b"\r\n"))
+    elif mismatch == "expected_hash":
+        expected = b"# Different expected base\nbody\n"
+    elif mismatch == "duplicate_xid":
+        changes["repository_xid_paths"] = {"BUG3TEST01": {"knowledge/byte_fixture.md", "knowledge/other.md"}}
+    elif mismatch == "unlocated_xid":
+        changes["unlocated_existing_knowledge_xids"] = {"BUG3TEST01"}
+    elif mismatch == "no_prepare":
+        changes["allow_same_xid_after_prepare"] = False
+    else:
+        target.unlink()
+    before = _inventory(tmp_path)
+    with pytest.raises(ValueError, match="Knowledge XID already exists"):
+        _target_check(target, expected, **changes)
+    assert _inventory(tmp_path) == before
+
+
+def test_gate_preparation_requires_real_approval_and_leaves_pending_state(tmp_path: Path) -> None:
+    record, manifest = _pending(tmp_path, b"# Rule\r\nbody\r\n")
+    before = _inventory(tmp_path)
+    with pytest.raises(RuntimeError, match="trusted human approval verifier"):
+        prepare_contribution_gate(tmp_path, contribution_id=manifest["contribution_id"],
+                                  log="work/not-created.md", binding_request={},
+                                  specialist_evidence=[], approval_verifier=None)
+    assert _inventory(tmp_path) == before
+    assert not (record / "events").exists()
+    assert not (tmp_path / "knowledge").exists()
+
+
+def test_unsigned_gate_packet_revalidation_rejects_wrong_base_hash(tmp_path: Path) -> None:
+    log = tmp_path / "work/run.md"
+    code, output = command("workflow", "run", "--root", str(tmp_path), "--task",
+                           "Unsigned base hash regression fixture", "--out", str(log),
+                           "--completion-condition", "read-only packet checked", "--json")
+    assert code == 0, output
+    code, output = command("skill", "workitem", "--log", str(log), "--item", "WI-BASE",
+                           "--text", "Validate unsigned frozen packet", "--completion-criterion",
+                           "base mismatch rejected without writing target", "--status", "pending",
+                           "--role", "instruction:executor", "--json")
+    assert code == 0, output
+    paths = ["work/candidate.md", *sorted(governance_entry.RULE_SOURCES)]
+    for name in paths:
+        path = tmp_path / name
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_bytes(b"# Isolated unsigned packet material\r\n")
+    request = {"work_item_id": "WI-BASE", "source_mode": "filesystem", "purpose": "base hash test",
+               "capability": "analysis", "tuning": "read-only fixture", "responsibility": "reject changed base",
+               "instruction_basis": "Authorized BUG3 regression scope", "scope_in": paths,
+               "scope_out": ["approval", "dispatch", "adoption"], "stop_conditions": ["unexpected write"],
+               "protocols": ["workflow"], "knowledge_access": {"mode": "on_demand", "catalog": "work/index.md"}}
+    packet = governance_entry.prepare(
+        tmp_path, kind="asset_update", log="work/run.md", binding_request=request, materials=paths,
+        payload={"candidate": "work/candidate.md", "target": "knowledge/not-created.md",
+                 "rules": sorted(governance_entry.RULE_SOURCES), "checks": sorted(governance_entry.CORE_CHECKS),
+                 "specialist_evidence": []},
+    )
+    assert packet["payload"]["expected_target_hash"] is None
+    before = _inventory(tmp_path)
+    governance_entry.revalidate(tmp_path, packet)
+    packet["payload"]["expected_target_hash"] = "0" * 64
+    # Packet digest is an unsigned content digest, never human authority or a host receipt.
+    packet["packet_hash"] = governance_entry.digest({k: v for k, v in packet.items() if k != "packet_hash"})
+    with pytest.raises(ValueError, match="target baseline changed"):
+        governance_entry.revalidate(tmp_path, packet)
+    assert _inventory(tmp_path) == before
+    assert not (tmp_path / "knowledge").exists()
+
+
+def test_nonexistent_xid_lookup_does_not_invent_a_document(tmp_path: Path) -> None:
+    before = _inventory(tmp_path)
+    with pytest.raises(KeyError, match="document xid not found: ABCDEF987654"):
+        XRefCatalog.build(tmp_path).get_document_by_xid("ABCDEF987654")
+    assert _inventory(tmp_path) == before