xrefkit 0.7.6__tar.gz → 0.7.8__tar.gz

{xrefkit-0.7.6/xrefkit.egg-info → xrefkit-0.7.8}/PKG-INFO

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

{xrefkit-0.7.6 → xrefkit-0.7.8}/pyproject.toml

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

xrefkit-0.7.8/tests/test_governance_host.py

@@ -0,0 +1,248 @@
+"""Local host integration checks use simulated subprocess/UI, never real approval."""
+import copy
+import json
+from pathlib import Path
+import subprocess
+from types import SimpleNamespace
+
+import pytest
+
+from test_governance_entry import case, host_receipt, HOST_KEY
+from test_subagent_startup import startup
+from xrefkit.governance_entry import digest, validate_result
+from xrefkit.mcp.contribution_adoption import HmacHumanApprovalVerifier
+from xrefkit import governance_host as host
+
+
+@pytest.fixture
+def local(case, monkeypatch):
+    root, packet, _ = case
+    packet_file = root / "work/packet.json"
+    packet_file.write_text(json.dumps(packet))
+    receipt = host_receipt(root, packet)
+    receipt_file = root / "work/receipt.json"
+    receipt_file.write_text(json.dumps(receipt))
+    state_file = root / "authority.dpapi"
+    state = {"schema": "xrefkit.local_host_authority/v1", "root": str(root),
+             "packet_hash": packet["packet_hash"], "receipt_hash": digest(receipt),
+             "host_secret": HOST_KEY, "applied": False}
+    monkeypatch.setattr(host, "_load_state", lambda path: copy.deepcopy(state))
+    monkeypatch.setattr(host, "_save_state", lambda path, value, **kwargs: state.update(value))
+    return root, packet, packet_file, receipt_file, state_file, state
+
+
+def test_native_decline_never_applies_or_issues_human_secret(local, monkeypatch):
+    root, _, packet, receipt, state_file, state = local
+    monkeypatch.setattr(host, "_review_dialog", lambda *args: False)
+    result = host.apply_local(root, packet, receipt, state_file, root / "work/reflection.json")
+    assert result["status"] == "human_declined_no_application"
+    assert not (root / "knowledge/item.md").exists()
+    assert "human_secret" not in state and not state["applied"]
+
+
+def test_native_action_applies_with_separate_keys_and_stale_replay_refuses(local, monkeypatch):
+    root, _, packet, receipt, state_file, state = local
+    observed = []
+    monkeypatch.setattr(host, "_review_dialog", lambda *args: observed.append(args) or True)
+    result = host.apply_local(root, packet, receipt, state_file, root / "work/reflection.json")
+    assert result["runtime_activation"] == "not_performed"
+    assert observed[0][0] == "knowledge/item.md" and "+# New" in observed[0][2]
+    assert state["human_secret"] != state["host_secret"]
+    assert (root / "knowledge/item.md").read_bytes() == (root / "work/candidate.md").read_bytes()
+    with pytest.raises(ValueError, match="unapplied dispatch"):
+        host.apply_local(root, packet, receipt, state_file, root / "work/replay.json")
+
+
+@pytest.mark.parametrize("mutation", ["candidate", "target"])
+def test_change_during_dialog_refuses_even_after_ui_accepts(local, monkeypatch, mutation):
+    root, _, packet, receipt, state_file, state = local
+    def change(*args):
+        path = root / ("work/candidate.md" if mutation == "candidate" else "knowledge/item.md")
+        path.parent.mkdir(exist_ok=True)
+        path.write_text("external change")
+        return True
+    monkeypatch.setattr(host, "_review_dialog", change)
+    with pytest.raises(ValueError, match="changed"):
+        host.apply_local(root, packet, receipt, state_file, root / "work/reflection.json")
+    assert not state["applied"]
+    if mutation == "target":
+        assert (root / "knowledge/item.md").read_text() == "external change"
+
+
+@pytest.mark.parametrize("field", ["packet_hash", "receipt_hash", "root"])
+def test_wrong_dispatch_state_rejected_before_dialog(local, monkeypatch, field):
+    root, _, packet, receipt, state_file, state = local
+    state[field] = "wrong"
+    monkeypatch.setattr(host, "_review_dialog", lambda *args: pytest.fail("UI must not open"))
+    with pytest.raises(ValueError, match="does not match"):
+        host.apply_local(root, packet, receipt, state_file, root / "work/reflection.json")
+
+
+def test_failed_gate_cannot_be_human_approved(local, monkeypatch):
+    root, packet, packet_file, receipt_file, state_file, state = local
+    receipt = host_receipt(root, packet, failed=True)
+    receipt_file.write_text(json.dumps(receipt))
+    state["receipt_hash"] = digest(receipt)
+    monkeypatch.setattr(host, "_review_dialog", lambda *args: pytest.fail("UI must not open"))
+    with pytest.raises(ValueError, match="failed or unknown"):
+        host.apply_local(root, packet_file, receipt_file, state_file, root / "work/reflection.json")
+
+
+def test_tampered_signature_refused_even_with_matching_receipt_digest(local, monkeypatch):
+    root, _, packet, receipt_file, state_file, state = local
+    receipt = json.loads(receipt_file.read_text())
+    receipt["signature"] = "wrong"
+    receipt_file.write_text(json.dumps(receipt))
+    state["receipt_hash"] = digest(receipt)
+    monkeypatch.setattr(host, "_review_dialog", lambda *args: pytest.fail("UI must not open"))
+    with pytest.raises(ValueError, match="signature"):
+        host.apply_local(root, packet, receipt_file, state_file, root / "work/reflection.json")
+
+
+def test_evidence_destination_cannot_overwrite_packet(local, monkeypatch):
+    root, _, packet, receipt, state_file, _ = local
+    monkeypatch.setattr(host, "_review_dialog", lambda *args: pytest.fail("UI must not open"))
+    with pytest.raises(ValueError, match="overwrite"):
+        host.apply_local(root, packet, receipt, state_file, packet)
+
+
+@pytest.mark.parametrize("events", [[], [{"type": "thread.started", "thread_id": "x"}],
+    [{"type": "thread.started", "thread_id": "x"}, {"type": "turn.failed"}],
+    [{"type": "thread.started", "thread_id": "x"}, {"type": "turn.completed"}, {"type": "turn.completed"}]])
+def test_missing_or_failed_terminal_events_are_not_execution(tmp_path, events):
+    path = tmp_path / "events.jsonl"
+    path.write_text("\n".join(json.dumps(event) for event in events))
+    with pytest.raises(ValueError):
+        host._completed_session(path)
+
+
+def test_valid_single_completion(tmp_path):
+    path = tmp_path / "events.jsonl"
+    path.write_text('{"type":"thread.started","thread_id":"actual-session"}\n{"type":"turn.completed"}\n')
+    assert host._completed_session(path) == "actual-session"
+
+
+def test_authority_never_inherited_by_child(monkeypatch):
+    monkeypatch.setenv("XREFKIT_GOVERNANCE_HOST_SECRET", "private")
+    monkeypatch.setenv("XREFKIT_GOVERNANCE_HUMAN_SECRET", "private")
+    monkeypatch.setenv("XREFKIT_CONTRIBUTION_APPROVAL_SECRET", "private")
+    env = host._child_environment()
+    assert not any(key.startswith("XREFKIT_GOVERNANCE_") for key in env)
+    assert "XREFKIT_CONTRIBUTION_APPROVAL_SECRET" not in env
+
+
+def test_child_open_refusal_never_dispatches(case, monkeypatch):
+    root, packet, _ = case
+    source = root / "work/packet.json"
+    source.write_text(json.dumps(packet))
+    binary = root / "codex.exe"
+    binary.write_bytes(b"test fixture, never executable")
+    monkeypatch.setattr(host.subprocess, "run", lambda *args, **kwargs:
+                        SimpleNamespace(returncode=2, stdout='{"ok":false}'))
+    monkeypatch.setattr(host.subprocess, "Popen", lambda *args, **kwargs: pytest.fail("must not dispatch"))
+    with pytest.raises(ValueError, match="Skill run refused"):
+        host.dispatch_local(root, source, binary, root / "work/dispatch")
+
+
+def test_process_failure_never_generates_host_authority(case, monkeypatch):
+    root, packet, _ = case
+    source = root / "work/packet.json"
+    source.write_text(json.dumps(packet))
+    binary = root / "codex.exe"
+    binary.write_bytes(b"test fixture, never executable")
+    monkeypatch.setattr(host.subprocess, "run", lambda *args, **kwargs:
+                        SimpleNamespace(returncode=0, stdout='{"ok":true,"run_id":"opened"}'))
+    process = SimpleNamespace(returncode=7, pid=123, communicate=lambda *args, **kwargs: None)
+    monkeypatch.setattr(host.subprocess, "Popen", lambda *args, **kwargs: process)
+    monkeypatch.setattr(host.secrets, "token_hex", lambda *args: pytest.fail("key must not be generated"))
+    with pytest.raises(ValueError, match="process failed"):
+        host.dispatch_local(root, source, binary, root / "work/dispatch")
+
+
+def test_no_cli_automatic_approval_option():
+    with pytest.raises(SystemExit) as exc:
+        host.main(["--root", ".", "apply", "--packet", "a", "--receipt", "b",
+                   "--authority-state", "c", "--out", "d", "--yes"])
+    assert exc.value.code == 2
+
+
+def test_applied_but_authority_save_failure_carries_reflection(local, monkeypatch):
+    root, _, packet, receipt, state_file, _ = local
+    monkeypatch.setattr(host, "_review_dialog", lambda *args: True)
+    def fail_save(*args, **kwargs):
+        raise OSError("simulated authority disk failure")
+    monkeypatch.setattr(host, "_save_state", fail_save)
+    with pytest.raises(host.AppliedEvidenceError) as exc:
+        host.apply_local(root, packet, receipt, state_file, root / "work/reflection.json")
+    assert (root / "knowledge/item.md").read_bytes() == (root / "work/candidate.md").read_bytes()
+    assert exc.value.reflection["target"]["path"] == "knowledge/item.md"
+
+
+def test_cli_distinguishes_applied_evidence_failure(monkeypatch, capsys):
+    reflection = {"target": {"path": "skills/example/SKILL.v1.md", "sha256": "observed-hash"}}
+    def failed(*args):
+        raise host.AppliedEvidenceError(reflection)
+    monkeypatch.setattr(host, "apply_local", failed)
+    code = host.main(["--root", ".", "apply", "--packet", "a", "--receipt", "b",
+                      "--authority-state", "c", "--out", "d"])
+    assert code == 3
+    assert "observed-hash" in capsys.readouterr().out
+
+
+@pytest.mark.parametrize("invalid_run", [None, "identity", "escalated"])
+def test_dispatch_attests_only_actual_opened_run_and_completed_output(case, monkeypatch, invalid_run):
+    root, packet, _ = case
+    source = root / "work/packet.json"
+    source.write_text(json.dumps(packet))
+    binary = root / "codex.exe"
+    binary.write_bytes(b"test fixture, never executable")
+    host_receipt(root, packet)  # Test-only prepared body/closed log.
+    out = root / "work/dispatch"
+    state = {}
+    child_path = None
+    def open_run(argv, **kwargs):
+        nonlocal child_path
+        child_path = Path(argv[argv.index("--out") + 1])
+        assert child_path.name.endswith("_skill_run_shared_asset_update_gate.md")
+        text = (root / "work/child.md").read_text().replace("work/analysis.md", "work/dispatch/analysis.json")
+        child_path.write_text(text)
+        return SimpleNamespace(returncode=0, stdout='{"ok":true,"run_id":"child-test-run"}')
+    def launch(argv, **kwargs):
+        def communicate(prompt, **options):
+            assert b"Do not open another run" in prompt
+            (out / "analysis.json").write_bytes((root / "work/analysis.md").read_bytes())
+            Path(argv[argv.index("--output-last-message") + 1]).write_text("Analysis complete")
+            kwargs["stdout"].write(b'{"type":"thread.started","thread_id":"simulated-session"}\n{"type":"turn.completed"}\n')
+            if invalid_run == "identity":
+                child_path.write_text(child_path.read_text().replace("child-test-run", "replaced-run"))
+            elif invalid_run == "escalated":
+                child_path.write_text(child_path.read_text().replace(
+                    "## Closure Gate\n- status: `done`", "## Closure Gate\n- status: `escalated`"))
+        return SimpleNamespace(returncode=0, pid=123, communicate=communicate)
+    monkeypatch.setattr(host.subprocess, "run", open_run)
+    monkeypatch.setattr(host.subprocess, "Popen", launch)
+    monkeypatch.setattr(host, "_state_path", lambda execution_id: root / "authority.dpapi")
+    monkeypatch.setattr(host, "_save_state", lambda path, value, **kwargs: state.update(value))
+    if invalid_run:
+        expected = "host-opened child identity" if invalid_run == "identity" else "completed child Skill run"
+        with pytest.raises(ValueError, match=expected):
+            host.dispatch_local(root, source, binary, out)
+        assert not state and not (out / "receipt.json").exists()
+    else:
+        result = host.dispatch_local(root, source, binary, out)
+        receipt = json.loads(Path(result["receipt"]).read_text())
+        verifier = HmacHumanApprovalVerifier(state["host_secret"])
+        assert validate_result(root, packet, receipt, verifier)["packet_hash"] == packet["packet_hash"]
+        provenance = json.loads((out / "dispatch.json").read_text())
+        verifier.verify_event(provenance["event"], provenance["signature"])
+        assert provenance["event"]["thread_id"] == "simulated-session"
+        assert state["host_secret"] not in (out / "receipt.json").read_text()
+        assert not (root / "knowledge/item.md").exists()
+
+
+@pytest.mark.skipif(host.os.name != "nt", reason="Windows operator adapter")
+def test_windows_dpapi_roundtrip():
+    disposable = b"non-secret disposable integration test"
+    ciphertext = host._protect(disposable)
+    assert ciphertext != disposable
+    assert host._protect(ciphertext, decrypt=True) == disposable

xrefkit-0.7.8/tests/test_package_knowledge_resolution.py

@@ -0,0 +1,166 @@
+from dataclasses import replace
+
+import pytest
+
+from xrefkit.discovery import DiscoveredSkillPackage
+from xrefkit.loaders import load_package_manifest
+from xrefkit.mcp.catalog import XRefCatalog
+
+
+def package_catalog(tmp_path, asset_path="knowledge/rules.md"):
+    import yaml
+    package_root = tmp_path / "package"
+    package_root.mkdir()
+    (package_root / "knowledge").mkdir()
+    (package_root / "knowledge/rules.md").write_text("# Package rules\n\nRequired rules.\n")
+    (package_root / "method.md").write_text("# Method\n")
+    manifest = package_root / "package_manifest.yaml"
+    manifest.write_text(yaml.safe_dump({
+        "package_id": "example.rules", "package_type": "skill_package", "version": "1.0.0",
+        "requires": {"xrefkit_core": ">=2.0.0 <3.0.0"},
+        "provides": {
+            "skills": [{"id": "example.review", "xid": "xid-skill-example", "path": "method.md"}],
+            "knowledge": [{"id": "rules", "xid": "xid-knowledge-rules", "path": asset_path}],
+        },
+        "contract": {},
+    }))
+    package = DiscoveredSkillPackage("example", package_root, manifest, load_package_manifest(manifest))
+    repo = tmp_path / "repo"
+    repo.mkdir()
+    return replace(XRefCatalog.build(repo), discovered_packages=(package,))
+
+
+def test_manifest_identity_resolves_without_inline_xid(tmp_path):
+    catalog = package_catalog(tmp_path)
+    document = catalog.get_document_by_xid("xid-knowledge-rules")
+    assert document["content"] == catalog.expand_knowledge("xid-knowledge-rules")["content"]
+    assert document["xid"] == "xid-knowledge-rules"
+    assert catalog.search_knowledge_catalog("Required rules")[0]["xid"] == "xid-knowledge-rules"
+    cached = catalog.get_document_by_xid("xid-knowledge-rules", document["content_hash"])
+    assert cached["content_hash"] == document["content_hash"]
+    assert cached["content_omitted"] == document["cache_policy"]["cache_recommended"]
+
+
+def test_duplicate_package_xid_refuses_selection(tmp_path):
+    catalog = package_catalog(tmp_path)
+    catalog = replace(catalog, discovered_packages=catalog.discovered_packages * 2)
+    assert catalog.get_document_by_xid("xid-knowledge-rules")["error"] == "xid_conflict"
+    with pytest.raises(ValueError, match="knowledge xid conflict"):
+        catalog.expand_knowledge("xid-knowledge-rules")
+
+
+def test_package_path_cannot_escape_root(tmp_path):
+    catalog = package_catalog(tmp_path, "../outside.md")
+    with pytest.raises(ValueError, match="escapes root"):
+        catalog.get_document_by_xid("xid-knowledge-rules")
+
+
+def installed_catalog(tmp_path, monkeypatch):
+    """Simulate entry-point installation, then use the real package discovery loader."""
+    import yaml
+    from types import SimpleNamespace
+    from xrefkit import discovery
+    catalog = package_catalog(tmp_path)
+    package = catalog.discovered_packages[0]
+    root = package.package_root
+    manifest = yaml.safe_load(package.manifest_path.read_text())
+    manifest["provides"]["skills"][0]["path"] = "method.skill.yaml"
+    manifest["provides"]["skills"][0]["required_knowledge"] = ["xid-knowledge-rules"]
+    manifest["provides"]["review_axes"] = [{"id": "axis", "xid": "xid-axis-rules", "path": "axis.yaml"}]
+    manifest["provides"]["schemas"] = [{"id": "schema", "xid": "xid-schema-rules", "path": "schema.json"}]
+    package.manifest_path.write_text(yaml.safe_dump(manifest))
+    (root / "method.skill.yaml").write_text(yaml.safe_dump({
+        "skill_id": "example.review", "xid": "xid-skill-example",
+        "entry": {"xid": "xid-entry-example", "path": "method.md", "load_policy": "required_inline"},
+        "required_outputs": ["report"], "required_knowledge": ["xid-knowledge-rules"],
+        "review_axes": ["xid-axis-rules"], "schemas": ["xid-schema-rules"],
+        "must_not": [], "extension_policy": {},
+    }))
+    (root / "axis.yaml").write_text("axis_id: example\nxid: xid-axis-rules\nchecks: []\n")
+    (root / "schema.json").write_text('{"type":"object"}\n')
+    ep = SimpleNamespace(name="example", load=lambda: lambda: root)
+    monkeypatch.setattr(discovery, "_select_entry_points", lambda group: [ep])
+    return XRefCatalog.build(catalog.repo_root, discover_packages=True)
+
+
+def test_discovered_required_knowledge_is_resolved_and_all_declared_assets_are_fetchable(tmp_path, monkeypatch):
+    catalog = installed_catalog(tmp_path, monkeypatch)
+    skill = catalog.get_skill("example.review")
+    assert skill["required_knowledge"] == [{"xid": "xid-knowledge-rules", "required": True, "reason": "package declaration"}]
+    resolved = catalog.resolve_skill_knowledge("example.review")
+    assert not resolved["unsatisfied_required"]
+    assert resolved["slots"][0]["bind"] == "xid-knowledge-rules"
+    assert resolved["slots"][0]["required"] is True and resolved["slots"][0]["satisfied"] is True
+    for xid in ("xid-knowledge-rules", "xid-axis-rules", "xid-schema-rules", "xid-entry-example", "xid-skill-example"):
+        assert catalog.get_document_by_xid(xid)["content"]
+    assert catalog.expand_knowledge("xid-knowledge-rules")["content"].startswith("# Package rules")
+
+
+def test_undeclared_file_is_not_exposed_and_absent_need_remains_unsatisfied(tmp_path, monkeypatch):
+    catalog = installed_catalog(tmp_path, monkeypatch)
+    package = catalog.discovered_packages[0]
+    (package.package_root / "secret.md").write_text("<!-- xid: ABCDEF123456 -->\n# Never declared")
+    with pytest.raises(KeyError):
+        catalog.get_document_by_xid("ABCDEF123456")
+    package.manifest.provides.knowledge.clear()
+    resolved = catalog.resolve_skill_knowledge("example.review")
+    assert resolved["unsatisfied_required"] == ["xid-knowledge-rules"]
+    assert resolved["slots"][0]["candidates"] == []
+    with pytest.raises(KeyError):
+        catalog.expand_knowledge("xid-knowledge-rules")
+
+
+def test_live_asset_changes_invalidate_catalog_and_document_cache(tmp_path, monkeypatch):
+    catalog = installed_catalog(tmp_path, monkeypatch)
+    path = catalog.discovered_packages[0].package_root / "axis.yaml"
+    before = catalog.catalog_version
+    document = catalog.get_document_by_xid("xid-axis-rules")
+    path.write_text(path.read_text() + "summary: revised\n")
+    current = catalog.get_document_by_xid("xid-axis-rules", document["content_hash"])
+    assert not current["content_omitted"]
+    assert current["content_hash"] != document["content_hash"]
+    assert catalog.catalog_version != before
+
+
+def test_duplicate_knowledge_cannot_silently_satisfy_required_slot(tmp_path, monkeypatch):
+    catalog = installed_catalog(tmp_path, monkeypatch)
+    (catalog.repo_root / "knowledge").mkdir()
+    (catalog.repo_root / "knowledge/local.md").write_text("<!-- xid: xid-knowledge-rules -->\n# Conflicting local rules")
+    with pytest.raises(ValueError, match="knowledge xid conflict"):
+        catalog.resolve_skill_knowledge("example.review")
+
+
+@pytest.mark.parametrize("relative", ["../outside.md", "/absolute.md", "C:/absolute.md", "knowledge/../rules.md", "knowledge\\rules.md"])
+def test_nonportable_or_escaping_declarations_refused(tmp_path, relative):
+    catalog = package_catalog(tmp_path, relative)
+    with pytest.raises(ValueError, match="package asset escapes root"):
+        catalog.get_document_by_xid("xid-knowledge-rules")
+
+
+def test_symlink_escape_is_not_exposed(tmp_path):
+    catalog = package_catalog(tmp_path)
+    outside = tmp_path / "outside.md"
+    outside.write_text("private outside content")
+    inside = catalog.discovered_packages[0].package_root / "knowledge/rules.md"
+    inside.unlink()
+    try:
+        inside.symlink_to(outside)
+    except OSError:
+        pytest.skip("symlink creation not available")
+    with pytest.raises(ValueError, match="escapes root"):
+        catalog.get_document_by_xid("xid-knowledge-rules")
+
+
+def test_package_cannot_shadow_embedded_startup_identity(tmp_path):
+    catalog = package_catalog(tmp_path)
+    catalog.discovered_packages[0].manifest.provides.knowledge[0].xid = "0B5C58B5E5B2"
+    with pytest.raises(ValueError, match="core startup XID"):
+        catalog.get_document_by_xid("0B5C58B5E5B2")
+
+
+def test_inline_identity_mismatch_refused(tmp_path):
+    catalog = package_catalog(tmp_path)
+    path = catalog.discovered_packages[0].package_root / "knowledge/rules.md"
+    path.write_text("<!-- xid: ABCDEF123456 -->\n# Wrong identity")
+    with pytest.raises(ValueError, match="identity does not match"):
+        catalog.expand_knowledge("xid-knowledge-rules")

{xrefkit-0.7.6 → xrefkit-0.7.8}/tests/test_package_skill_run.py

@@ -18,6 +18,13 @@ def test_installed_package_run_binds_over_mcp(tmp_path, module, reference, xid):
     from pathlib import Path
 
     pytest.importorskip(module)
+    from xrefkit.discovery import discover_skill_packages
+    package_id = reference.split("::")[0]
+    package = next(item for item in discover_skill_packages() if item.package_id == package_id)
+    package_knowledge_xids = [asset.xid for asset in package.manifest.provides.knowledge]
+    package_reference_xids = [asset.xid for asset in (
+        *package.manifest.provides.review_axes, *package.manifest.provides.schemas
+    )]
     anyio = pytest.importorskip("anyio")
     pytest.importorskip("mcp")
     from mcp.client.session import ClientSession
@@ -94,8 +101,30 @@ def test_installed_package_run_binds_over_mcp(tmp_path, module, reference, xid):
                     )
                     assert not requirements.isError, requirements.content
                     assert not requirements.structuredContent["missing"]
+                    for xid in package_knowledge_xids:
+                        document = await session.call_tool("get_document_by_xid", {"xid": xid})
+                        assert not document.isError, document.content
+                        expanded = await session.call_tool("expand_knowledge", {"xid": xid})
+                        assert not expanded.isError, expanded.content
+                        assert expanded.structuredContent["content"]
+
                     skill = await session.call_tool("get_skill", {"skill_id": run["skill_id"]})
                     assert not skill.isError, skill.content
                     assert skill.structuredContent["skill_id"] == run["skill_id"]
+                    for asset_xid in package_reference_xids:
+                        document = await session.call_tool("get_document_by_xid", {"xid": asset_xid})
+                        assert not document.isError, document.content
+                        assert document.structuredContent["content"]
+                    resolved = await session.call_tool(
+                        "resolve_skill_knowledge", {"skill_id": run["skill_id"]}
+                    )
+                    assert not resolved.isError, resolved.content
+                    required_xids = {need["xid"] for need in skill.structuredContent["required_knowledge"]}
+                    assert required_xids <= {slot["bind"] for slot in resolved.structuredContent["slots"]}
+                    for slot in resolved.structuredContent["slots"]:
+                        if slot["bind"] in package_knowledge_xids:
+                            assert slot["satisfied"]
+                        if not slot["satisfied"]:
+                            assert slot["slot"] in resolved.structuredContent["unsatisfied_required"]
 
     anyio.run(scenario)

{xrefkit-0.7.6 → xrefkit-0.7.8}/xrefkit/__init__.py

@@ -2,4 +2,4 @@
 
 __all__ = ["__version__"]
 
-__version__ = "0.7.6"
+__version__ = "0.7.8"