xrefkit 0.7.4__tar.gz → 0.7.6__tar.gz

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

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

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

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

xrefkit-0.7.6/tests/test_package_skill_run.py

@@ -0,0 +1,101 @@
+import pytest
+
+
+@pytest.mark.parametrize(
+    ("module", "reference", "xid"),
+    [
+        ("xrefkit_skills_csharp", "xrefkit.skills.csharp::csharp.review", "xid-skill-csharp-review"),
+        ("xrefkit_skills_brownfield", "xrefkit.skills.brownfield::brownfield.workflow", "xid-skill-brownfield-workflow"),
+        ("xrefkit_skills_batch_regression", "xrefkit.skills.batch_regression::batch.impact_regression", "xid-skill-batch-impact-regression"),
+    ],
+)
+def test_installed_package_run_binds_over_mcp(tmp_path, module, reference, xid):
+    import json
+    import os
+    import subprocess
+    import sys
+    import tempfile
+    from pathlib import Path
+
+    pytest.importorskip(module)
+    anyio = pytest.importorskip("anyio")
+    pytest.importorskip("mcp")
+    from mcp.client.session import ClientSession
+    from mcp.client.stdio import StdioServerParameters, stdio_client
+
+    repo = Path(__file__).resolve().parents[1]
+    cli = [sys.executable, "-m", "xrefkit"]
+
+    env = {**os.environ, "PYTHONPATH": str(repo)}
+
+    def run_cli(*args):
+        return subprocess.check_output(
+            cli + list(args), cwd=tmp_path, env=env, encoding="utf-8"
+        )
+
+    args = [
+        "skill", "run",
+        "--package-skill", reference,
+        "--task", "Verify package run startup and MCP binding",
+        "--capability", "integration verification", "--tuning", "XRefKit package startup",
+        "--responsibility", "Verify run creation and correlation",
+        "--execution-mode", "subagent_required", "--json",
+    ]
+    run = json.loads(run_cli(*args))
+    assert run["skill_id"] == reference.split("::")[1]
+    log_path = Path(run["run_log"])
+    assert log_path.is_relative_to(tmp_path)
+    assert Path(run["skill_doc"]).is_file()
+    log = log_path.read_text(encoding="utf-8")
+    assert "maturity: `unassessed`" in log
+    assert f"package_skill_xid: `{xid}`" in log
+    assert "package_skill_sha256:" in log
+
+    rejected = subprocess.run(
+        cli + [arg for arg in args if arg not in {"--capability", "integration verification"}],
+        cwd=tmp_path, env=env, capture_output=True, encoding="utf-8",
+    )
+    assert rejected.returncode == 1
+    assert json.loads(rejected.stdout)["run_id"] is None
+
+    async def scenario():
+        server = StdioServerParameters(
+            command=sys.executable,
+            args=[
+                "-m", "xrefkit.mcp.server", "--repo", str(repo),
+                "--audit-log", str(tmp_path / "mcp-audit.jsonl"),
+            ],
+            cwd=str(repo),
+        )
+        with tempfile.TemporaryFile(mode="w+", encoding="utf-8") as stderr:
+            async with stdio_client(server, errlog=stderr) as (read, write):
+                async with ClientSession(read, write) as session:
+                    await session.initialize()
+                    startup = await session.call_tool("get_startup_context", {})
+                    assert not startup.isError, startup.content
+                    binding = await session.call_tool(
+                        "bind_skill_run",
+                        {"run_id": run["run_id"], "skill_id": run["skill_id"]},
+                    )
+                    assert not binding.isError, binding.content
+                    bound = binding.structuredContent
+                    assert bound["run_id"] == run["run_id"]
+                    assert bound["skill_id"] == run["skill_id"]
+                    assert "xrefkit skill correlate" in bound["client_record_command"]
+                    run_cli(
+                        "skill", "correlate", "--log", str(log_path),
+                        "--run-id", bound["run_id"],
+                        "--mcp-session-id", bound["mcp_session_id"],
+                        "--repository-fingerprint", bound["repository_fingerprint"],
+                    )
+                    assert bound["mcp_session_id"] in log_path.read_text(encoding="utf-8")
+                    requirements = await session.call_tool(
+                        "get_skill_requirements", {"skill_id": run["skill_id"]}
+                    )
+                    assert not requirements.isError, requirements.content
+                    assert not requirements.structuredContent["missing"]
+                    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"]
+
+    anyio.run(scenario)

xrefkit-0.7.6/tests/test_packaged_native_governance.py

@@ -0,0 +1,54 @@
+import json
+import hashlib
+from pathlib import Path
+
+import pytest
+import yaml
+
+from xrefkit.discovery import DiscoveredSkillPackage
+from xrefkit.loaders import load_package_manifest
+from xrefkit.mcp.catalog import _build_package_skills
+from xrefkit.models.package_manifest import ProvidedSkill
+
+
+def fixture(tmp_path):
+    root=Path(__file__).resolve().parents[1]
+    source=root/'skills/packs/project-management/progress_rules_setup/SKILL.v1.md'
+    (tmp_path/'skill.md').write_bytes(source.read_bytes())
+    gov=json.loads((root/'governance/skills/progress_rules_setup.json').read_text())
+    gov['definition_content_hash']=hashlib.sha256(source.read_bytes()).hexdigest()
+    (tmp_path/'governance.json').write_text(json.dumps(gov))
+    manifest={'package_id':'test.native','package_type':'skill_package','version':'0.1.0',
+              'requires':{'xrefkit_core':'>=2.0.0 <3.0.0'},'contract':{},
+              'provides':{'skills':[{'id':'progress_rules_setup','xid':'91F7D3B6A204','path':'skill.md','governance_path':'governance.json'}]}}
+    (tmp_path/'package_manifest.yaml').write_text(yaml.safe_dump(manifest))
+    return DiscoveredSkillPackage('test',tmp_path,tmp_path/'package_manifest.yaml',load_package_manifest(tmp_path/'package_manifest.yaml'))
+
+
+def test_bound_native_draft_and_live_hash_check(tmp_path):
+    package=fixture(tmp_path)
+    assert _build_package_skills(package)[0].maturity=='draft'
+    (tmp_path/'skill.md').write_bytes((tmp_path/'skill.md').read_bytes()+b'\nchanged\n')
+    with pytest.raises(ValueError,match='content_hash'):
+        _build_package_skills(package)
+
+
+def test_omitted_governance_preserves_existing_unassessed_behavior(tmp_path):
+    package=fixture(tmp_path)
+    package.manifest.provides.skills[0].governance_path=None
+    assert _build_package_skills(package)[0].maturity=='unassessed'
+
+
+def test_legacy_governance_field_is_rejected():
+    with pytest.raises(ValueError,match='native Markdown'):
+        ProvidedSkill(id='legacy',xid='legacy.xid',path='legacy.yaml',governance_path='gov.json')
+
+def test_packaged_draft_ranking_is_not_runnable(tmp_path):
+    from xrefkit.mcp.catalog import XRefCatalog
+    package=fixture(tmp_path)
+    catalog=XRefCatalog(tmp_path,'test','test',[],discovered_packages=(package,))
+    ranked=catalog.rank_skills_for_purpose('confirm progress rules and destinations')
+    row=next(r for r in ranked if r['skill_id']=='progress_rules_setup')
+    assert row['maturity']=='draft'
+    assert row['execution_readiness']['runnable'] is False
+    assert 'draft' in row['execution_readiness']['governance_block_reason']

xrefkit-0.7.6/tests/test_project_management_materialization.py

@@ -0,0 +1,39 @@
+import json
+import shutil
+from pathlib import Path
+
+import pytest
+
+from tools.materialize_project_management_package import generate, main, PACKAGE
+
+
+def test_approved_bytes_cannot_be_rebound_after_link_transform(tmp_path):
+    root=Path(__file__).resolve().parents[1]
+    for rel in ['skills','governance','docs']:
+        # Source links resolve against the actual tree; copy only governed inputs,
+        # then use the real remaining targets through a full temporary fixture.
+        shutil.copytree(root/rel,tmp_path/rel)
+    gp=tmp_path/'governance/skills/requirements_discovery_coordination.json'
+    record=json.loads(gp.read_text())
+    record['maturity']='trial'
+    record['promotion']['decision']='approved'
+    gp.write_text(json.dumps(record))
+    with pytest.raises(ValueError,match='separate package governance'):
+        generate(tmp_path)
+
+
+def test_stale_extra_managed_asset_is_rejected(tmp_path,monkeypatch):
+    target=tmp_path/PACKAGE/'skills'
+    target.mkdir(parents=True)
+    (target/'retired.md').write_text('stale')
+    monkeypatch.setattr('tools.materialize_project_management_package.generate',lambda root:{})
+    monkeypatch.setattr('sys.argv',['materialize','--root',str(tmp_path),'--check'])
+    with pytest.raises(SystemExit,match='unexpected managed asset'):
+        main()
+
+
+def test_embedded_migration_adoption_matches_raw_bytes():
+    from xrefkit.repository_skills import load_repository_adoption
+    import xrefkit
+    root=Path(xrefkit.__file__).parent/'resources/migration'
+    assert load_repository_adoption(root)['entries']

{xrefkit-0.7.4 → xrefkit-0.7.6}/tests/test_skill_release_compatibility.py

@@ -91,6 +91,31 @@ def test_real_resolver_probe_passes_representative_fixture(tmp_path, monkeypatch
     assert installed.verify_installed("demo", "official.demo", "0.6.1")["skills"] == ["demo.skill"]
 
 
+def test_native_probe_uses_bound_catalog_and_rejects_changed_governance(tmp_path, monkeypatch):
+    from test_packaged_native_governance import fixture
+    from xrefkit import discovery
+    candidate = fixture(tmp_path)
+    monkeypatch.setattr(discovery, "discover_skill_packages", lambda: [candidate])
+    monkeypatch.setattr(installed.metadata, "version", lambda name: "0.7.5")
+    monkeypatch.setattr(installed.metadata, "distribution", lambda name: SimpleNamespace(
+        version="0.1.0", entry_points=[SimpleNamespace(group="xrefkit.skill_packages", name="test")]))
+    # This minimal fixture method uses repository links, so first replace it with
+    # an equivalent native method with no external file dependency and rebind draft.
+    path = tmp_path / "skill.md"
+    text = path.read_text().split("## Method", 1)[0] + "## Method\nInspect requested target.\n"
+    path.write_text(text)
+    import hashlib
+    gp = tmp_path / "governance.json"
+    record = json.loads(gp.read_text())
+    record["definition_content_hash"] = hashlib.sha256(path.read_bytes()).hexdigest()
+    gp.write_text(json.dumps(record))
+    assert installed.verify_installed("demo", "test.native", "0.7.5")["skills"] == ["progress_rules_setup"]
+    record["definition_content_hash"] = "0" * 64
+    gp.write_text(json.dumps(record))
+    with pytest.raises(ValueError, match="content_hash"):
+        installed.verify_installed("demo", "test.native", "0.7.5")
+
+
 def test_real_protocol_rejection_stops_installed_probe(tmp_path, monkeypatch):
     root, manifest, _ = contract_fixture(tmp_path, monkeypatch)
     manifest["requires"]["xrefkit_core"] = ">=3.0.0"

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

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

{xrefkit-0.7.4 → xrefkit-0.7.6}/xrefkit/mcp/catalog.py

@@ -1055,8 +1055,8 @@ class XRefCatalog:
             ]
             # Declared preconditions travel with the ranking so the client can
             # filter to Skills runnable in the current state (084 M4). Empty
-            # until metas adopt preconditions; tool-availability stays the only
-            # server-known readiness signal.
+            # until metas adopt preconditions; known adoption and packaged
+            # governance restrictions also constrain readiness below.
             readiness = {
                 "runnable": not missing_tools,
                 "missing_tool_contracts": missing_tools,
@@ -1071,6 +1071,11 @@ class XRefCatalog:
                     "repository_adopted": skill.repository_adoption["effective_adopted"],
                     "historical_repository_adopted": skill.repository_adoption["adopted"],
                 })
+            if skill.package_id and skill.maturity_governance and skill.maturity in {"draft", "deprecated"}:
+                readiness.update({
+                    "runnable": False,
+                    "governance_block_reason": f"Packaged Skill maturity {skill.maturity} prohibits execution",
+                })
             if score <= 0:
                 continue
             results.append(
@@ -2343,12 +2348,24 @@ def _build_package_skills(package: DiscoveredSkillPackage) -> list[SkillCatalogE
                 worklist_policy="required",
             )
             knowledge_needs = [dict(item) for item in meta["knowledge_needs"]]
+            maturity_governance = None
+            if provided.governance_path is not None:
+                from ..skill_definition_governance import (
+                    governance_projection, load_governance_record, match_definition,
+                )
+                governance_path = (package_root / provided.governance_path).resolve()
+                if not governance_path.is_relative_to(package_root):
+                    raise ValueError("package Skill governance path escapes package root")
+                record = load_governance_record(governance_path)
+                match_definition(record, definition)
+                maturity_governance = governance_projection(record)
+                maturity_governance["record_ref"]["path"] = governance_path.relative_to(package_root).as_posix()
             entries.append(
                 SkillCatalogEntry(
                     skill_id=meta["skill_id"],
                     title=first_heading(method, meta["skill_id"]),
                     summary=meta["summary"],
-                    maturity="unassessed",
+                    maturity=maturity_governance["maturity"] if maturity_governance else "unassessed",
                     intent=list(meta["applies_when"]),
                     target_artifacts=list(meta["outputs"]),
                     applies_when=list(meta["applies_when"]),
@@ -2378,6 +2395,7 @@ def _build_package_skills(package: DiscoveredSkillPackage) -> list[SkillCatalogE
                     definition_format="skill_definition_v1",
                     definition_xid=meta["xid"],
                     definition_content_hash=definition["content_hash"],
+                    maturity_governance=maturity_governance,
                 )
             )
             continue

{xrefkit-0.7.4 → xrefkit-0.7.6}/xrefkit/models/package_manifest.py

@@ -35,12 +35,21 @@ class ProvidedAsset(StrictModel):
 
 
 class ProvidedSkill(ProvidedAsset):
+    governance_path: str | None = None
     contract_role: str | None = None
     required_outputs: list[str] = Field(default_factory=list)
     required_knowledge: list[str] = Field(default_factory=list)
     required_review_axes: list[str] = Field(default_factory=list)
     must_not: list[str] = Field(default_factory=list)
 
+    @model_validator(mode="after")
+    def _validate_governance_path(self) -> "ProvidedSkill":
+        if self.governance_path is not None:
+            validate_non_empty(self.governance_path, "governance_path")
+            if not self.path.lower().endswith(".md"):
+                raise ValueError("governance_path requires a native Markdown SkillDefinition")
+        return self
+
     @field_validator("required_outputs", "required_knowledge", "required_review_axes", "must_not")
     @classmethod
     def _validate_string_list(cls, values: list[str]) -> list[str]:

{xrefkit-0.7.4 → xrefkit-0.7.6}/xrefkit/operations_cli.py

@@ -413,6 +413,7 @@ def _build_parser() -> argparse.ArgumentParser:
     p_skill_run_source = p_skill_run.add_mutually_exclusive_group(required=True)
     p_skill_run_source.add_argument("--meta", help="Relative path to the legacy Skill meta.md to run")
     p_skill_run_source.add_argument("--definition", help="Explicit SkillDefinition document to run without a legacy meta source")
+    p_skill_run_source.add_argument("--package-skill", help="Explicit installed Skill Package reference (package_id::skill_id)")
     p_skill_run.add_argument(
         "--governance",
         default=None,

{xrefkit-0.7.4 → xrefkit-0.7.6}/xrefkit/skillrun.py

@@ -660,7 +660,7 @@ def _render_log(
         ]
     )
     definition_lines = "".join(
-        f"- definition_{key}: `{value}`\n"
+        f"- {key if key.startswith('package_') else 'definition_' + key}: `{value}`\n"
         for key, value in (definition_identity or {}).items()
     )
     runtime_responsibility = role_responsibilities.get("executor") or "not declared"
@@ -2929,15 +2929,50 @@ def update_token_usage(args) -> SkillRunResult:
     return SkillRunResult(ok=True, skill_id=_log_skill_id(text), skill_doc=None, run_log=str(log_path), errors=[])
 
 
+def _resolve_package_run_source(reference: str) -> tuple[Path, str, dict[str, str]]:
+    from xrefkit.discovery import enabled_discovered_packages
+    from xrefkit.hashing import sha256_file
+    from xrefkit.workspace import build_registry
+
+    package_id, separator, skill_id = reference.partition("::")
+    if not separator or not package_id or not skill_id:
+        raise ValueError("--package-skill requires package_id::skill_id")
+    packages = enabled_discovered_packages(enabled_package_ids={package_id})
+    if len(packages) != 1:
+        raise ValueError(f"expected one installed package for {package_id}, found {len(packages)}")
+    package = packages[0]
+    provided = next((item for item in package.manifest.provides.skills if item.id == skill_id), None)
+    if provided is None:
+        raise ValueError(f"package does not provide Skill: {reference}")
+    if not provided.path.endswith(".skill.yaml"):
+        raise ValueError("--package-skill requires a split YAML Skill; use --definition with packaged governance for Markdown")
+
+    registry = build_registry(package_manifests=[package.manifest_path])
+    record = registry.skills.require(skill_id)
+    if record.package_id != package_id or record.xid != provided.xid:
+        raise ValueError(f"package Skill identity mismatch: {reference}")
+    entry = (record.root / record.definition.entry.path).resolve()
+    identity = {
+        "format": "legacy_split_v1",
+        "package_id": package_id,
+        "package_version": package.manifest.version,
+        "package_skill_xid": record.xid,
+        "package_skill_path": record.path.relative_to(record.root).as_posix(),
+        "package_skill_sha256": sha256_file(record.path),
+    }
+    return entry, skill_id, identity
+
+
 def run_skill(args) -> SkillRunResult:
     root = Path(args.root).resolve()
     definition_arg = getattr(args, "definition", None)
     governance_arg = getattr(args, "governance", None)
     meta_arg = getattr(args, "meta", None)
-    if bool(definition_arg) == bool(meta_arg):
-        return SkillRunResult(ok=False, skill_id=None, skill_doc=None, run_log=None, errors=["exactly one of --meta or --definition is required"])
+    package_arg = getattr(args, "package_skill", None)
+    if sum(bool(source) for source in (definition_arg, meta_arg, package_arg)) != 1:
+        return SkillRunResult(ok=False, skill_id=None, skill_doc=None, run_log=None, errors=["exactly one of --meta, --definition, or --package-skill is required"])
     try:
-        adoption = load_repository_adoption(root)
+        adoption = None if package_arg else load_repository_adoption(root)
         adapter = repository_skill(root, definition_arg or meta_arg, adoption) if adoption else None
     except (ValueError, OSError) as exc:
         return SkillRunResult(ok=False, skill_id=None, skill_doc=None, run_log=None, errors=[str(exc)])
@@ -2946,15 +2981,26 @@ def run_skill(args) -> SkillRunResult:
             return SkillRunResult(ok=False, skill_id=adapter["skill_id"], skill_doc=None, run_log=None,
                                   errors=["draft or deprecated repository Skills are not adopted and cannot execute"])
         definition_arg = adapter["definition_path"]
-    if not definition_arg and (governance_arg or any(
+    if package_arg and governance_arg:
+        return SkillRunResult(ok=False, skill_id=None, skill_doc=None, run_log=None,
+                              errors=["--governance requires a Markdown SkillDefinition"])
+    if not (definition_arg or package_arg) and (governance_arg or any(
         getattr(args, key, None)
         for key in ("capability", "tuning", "responsibility", "execution_mode")
     )):
         return SkillRunResult(
             ok=False, skill_id=None, skill_doc=None, run_log=None,
-            errors=["--governance, --capability, --tuning, --responsibility, and --execution-mode are definition-only runtime inputs"],
+            errors=["--governance, --capability, --tuning, --responsibility, and --execution-mode require --definition or --package-skill"],
         )
-    meta_path = (root / (definition_arg or meta_arg)).resolve()
+    definition_identity = None
+    if package_arg:
+        try:
+            meta_path, package_skill_id, definition_identity = _resolve_package_run_source(package_arg)
+        except (ImportError, KeyError, OSError, ValueError) as exc:
+            return SkillRunResult(ok=False, skill_id=None, skill_doc=None, run_log=None, errors=[str(exc)])
+    else:
+        meta_path = (root / (definition_arg or meta_arg)).resolve()
+    instruction_bound = bool(definition_arg or package_arg)
     task, task_errors = _read_task(args)
     if task_errors:
         return SkillRunResult(ok=False, skill_id=None, skill_doc=None, run_log=None, errors=task_errors)
@@ -2964,7 +3010,6 @@ def run_skill(args) -> SkillRunResult:
         source_name = "definition" if definition_arg else "meta"
         return SkillRunResult(ok=False, skill_id=None, skill_doc=None, run_log=None, errors=[f"{source_name} not found: {meta_path}"])
 
-    definition_identity = None
     if definition_arg:
         try:
             definition = load_skill_definition(meta_path)
@@ -3018,6 +3063,12 @@ def run_skill(args) -> SkillRunResult:
                 "governance_sha256": str(governance["_content_hash"]),
                 "promotion_decision": str(governance["promotion"]["decision"]),
             })
+    elif package_arg:
+        parsed = {"skill_id": package_skill_id}
+        skill_id = package_skill_id
+        definition_maturity = "unassessed"
+
+    if instruction_bound:
         runtime = {key: str(getattr(args, key, "") or
                    (adapter["runtime"][key]["value"] if adapter else "") or "").strip()
                    for key in RUNTIME_FIELDS}
@@ -3058,7 +3109,7 @@ def run_skill(args) -> SkillRunResult:
             domain_knowledge=domain_knowledge,
         )
     maturity, _ = _resolve_maturity(parsed)
-    maturity = (str(parsed.get("maturity") or "unassessed") if definition_arg else (maturity or "stable"))
+    maturity = (str(parsed.get("maturity") or "unassessed") if instruction_bound else (maturity or "stable"))
 
     if maturity == "draft":
         return SkillRunResult(
@@ -3080,8 +3131,8 @@ def run_skill(args) -> SkillRunResult:
         )
 
     validation_level = "trial" if maturity == "trial" else "stable"
-    validation = validate_skill_meta(meta_path, check_level=validation_level) if not definition_arg else None
-    if definition_arg:
+    validation = validate_skill_meta(meta_path, check_level=validation_level) if not instruction_bound else None
+    if instruction_bound:
         blocking_errors = []
     elif maturity == "trial":
         allowed_trial_errors = {"trial-or-higher skills must include at least one observation_refs entry"}
@@ -3147,7 +3198,7 @@ def run_skill(args) -> SkillRunResult:
             errors=[f"skill_doc not found: {skill_doc_path}"],
         )
     os_contract = resolve_os_contract(parsed.get("os_contract"))
-    if definition_arg:
+    if instruction_bound:
         os_contract = dict(REQUIRED_OS_CONTRACT)
     if maturity == "trial":
         merged_os_contract = dict(REQUIRED_OS_CONTRACT)
@@ -3226,8 +3277,8 @@ def run_skill(args) -> SkillRunResult:
         node_id=getattr(args, "node_id", None),
         skill_id=skill_id,
         maturity=maturity,
-        meta_path=Path("-") if definition_arg else meta_path.relative_to(root),
-        skill_doc=skill_doc_path.relative_to(root),
+        meta_path=Path("-") if instruction_bound else meta_path.relative_to(root),
+        skill_doc=skill_doc_path if package_arg else skill_doc_path.relative_to(root),
         execution_mode=execution_mode,
         guard_policy=guard_policy,
         capability_layering=capability_layering,
@@ -3244,7 +3295,7 @@ def run_skill(args) -> SkillRunResult:
         domain_knowledge=domain_knowledge,
         decision_trace_checkpoint=checkpoint,
         definition_identity=definition_identity,
-        runtime_binding_source="instruction_derived" if definition_arg else "legacy_meta_compatibility",
+        runtime_binding_source="instruction_derived" if instruction_bound else "legacy_meta_compatibility",
         compact=True,
     )
     kickoff = None

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

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

{xrefkit-0.7.4 → xrefkit-0.7.6}/xrefkit.egg-info/SOURCES.txt

@@ -78,9 +78,12 @@ tests/test_os_family_definition.py
 tests/test_os_knowledge_family_definition.py
 tests/test_os_selected_family.py
 tests/test_ownership.py
+tests/test_package_skill_run.py
+tests/test_packaged_native_governance.py
 tests/test_packmeta.py
 tests/test_plan_markdown.py
 tests/test_plan_observation.py
+tests/test_project_management_materialization.py
 tests/test_project_quality_baseline.py
 tests/test_qa_report_definition.py
 tests/test_reporting_profiles.py