agentengine-sdk-python 0.8.3__py3-none-any.whl → 0.8.4__py3-none-any.whl

ksadk/plugins/composition.py

@@ -102,6 +102,7 @@ class CompositionPolicy:
     context_contributors: Mapping[str, PluginCapabilitySelection] = field(
         default_factory=dict
     )
+    host_capabilities: tuple[PluginCapabilitySelection, ...] = ()
     renderers: tuple[PluginCapabilitySelection, ...] = ()
     default_runtime: str = "codex"
 
@@ -185,6 +186,13 @@ class CompositionCompiler:
             field="policy.sessionStore",
         )
 
+        for selection in self._policy.host_capabilities:
+            self._append_selection(
+                capabilities,
+                selection,
+                field="policy.hostCapabilities",
+            )
+
         if revision.spec.memory.enabled:
             memory = self._policy.memory_providers.get(revision.spec.memory.provider_ref)
             if memory is None:

ksadk/plugins/contracts.py

@@ -5,13 +5,16 @@ Only the models exported through ``__all__`` are public Phase 2 contracts.
 they project DSH/Codex host inventory into the Python composition engine and
 are not a third installable package format or a stable public contract.
 """
+
 from __future__ import annotations
 
 import hashlib
 import json
 import re
 from collections.abc import Mapping
+from pathlib import PurePosixPath
 from typing import Any, Literal
+from urllib.parse import urlsplit
 
 from pydantic import BaseModel, ConfigDict, Field, field_validator, model_validator
 
@@ -98,6 +101,77 @@ class CapabilityOffer(PluginContractModel):
         return value
 
 
+class PluginSourceSnapshot(PluginContractModel):
+    """Credential-free upstream identity retained in an immutable plugin lock.
+
+    Lifecycle hosts (Codex App Server or DSH) remain responsible for resolving
+    and installing packages.  This record only captures the exact source that
+    was admitted so a later build cannot silently follow a mutable marketplace,
+    Git branch, npm tag, or local directory.
+    """
+
+    ecosystem: Literal["ksadk", "codex", "dsh"]
+    type: Literal["builtin", "registry", "local", "git", "npm", "market", "runtime-native"]
+    requested: str = Field(min_length=1, max_length=2048)
+    resolved: str = Field(min_length=1, max_length=2048)
+    integrity: str | None = Field(default=None, max_length=512)
+    marketplace: str | None = Field(default=None, max_length=256)
+    registry: str | None = Field(default=None, max_length=2048)
+
+    @field_validator("requested", "resolved", "integrity", "marketplace", "registry")
+    @classmethod
+    def validate_public_coordinate(cls, value: str | None) -> str | None:
+        if value is None:
+            return None
+        if value != value.strip() or any(ord(character) < 32 for character in value):
+            raise ValueError("plugin source coordinates must be trimmed printable text")
+        # Build artifacts and inventories are routinely shared.  A source URL
+        # therefore cannot retain embedded credentials, query tokens, or URL
+        # fragments.  Authentication remains a host-owned credential concern.
+        if "://" in value:
+            parsed = urlsplit(value)
+            if parsed.username or parsed.password or parsed.query or parsed.fragment:
+                raise ValueError("plugin source coordinates must not contain credentials")
+        return value
+
+
+class LockedPluginComponent(PluginContractModel):
+    """One selected native component and the bytes admitted for a build."""
+
+    id: str = Field(min_length=1, max_length=256)
+    kind: Literal["skill", "mcp", "hook", "app", "client"]
+    digest: str
+    path: str | None = Field(default=None, max_length=512)
+
+    @field_validator("id")
+    @classmethod
+    def validate_component_id(cls, value: str) -> str:
+        if not re.fullmatch(r"[A-Za-z0-9][A-Za-z0-9._:/-]*", value):
+            raise ValueError("plugin component id is invalid")
+        return value
+
+    @field_validator("digest")
+    @classmethod
+    def validate_component_digest(cls, value: str) -> str:
+        return _validate_digest(value)
+
+    @field_validator("path")
+    @classmethod
+    def validate_component_path(cls, value: str | None) -> str | None:
+        if value is None:
+            return None
+        if "\\" in value:
+            raise ValueError("plugin component paths must use POSIX separators")
+        path = PurePosixPath(value)
+        if (
+            path.is_absolute()
+            or not path.parts
+            or any(part in {"", ".", ".."} for part in path.parts)
+        ):
+            raise ValueError("plugin component path must stay relative to the plugin root")
+        return value
+
+
 class CapabilityRequirement(PluginContractModel):
     definition: str
     version: str = Field(min_length=1, max_length=128)
@@ -122,12 +196,26 @@ class PluginProvenance(PluginContractModel):
     digest: str
     signature_ref: str | None = Field(default=None, max_length=512)
     license: str | None = Field(default=None, max_length=128)
+    upstream: PluginSourceSnapshot | None = None
+    components: tuple[LockedPluginComponent, ...] | None = None
 
     @field_validator("digest")
     @classmethod
     def validate_digest(cls, value: str) -> str:
         return _validate_digest(value)
 
+    @field_validator("components")
+    @classmethod
+    def validate_components(
+        cls, value: tuple[LockedPluginComponent, ...] | None
+    ) -> tuple[LockedPluginComponent, ...] | None:
+        if value is None:
+            return None
+        identities = [(item.kind, item.id) for item in value]
+        if len(identities) != len(set(identities)):
+            raise ValueError("plugin components must have unique kind/id identities")
+        return tuple(sorted(value, key=lambda item: (item.kind, item.id, item.digest)))
+
 
 class PluginSpec(PluginContractModel):
     domain: Literal["ksadk-platform", "runtime-native"]
@@ -303,6 +391,8 @@ class PluginLockEntry(PluginContractModel):
     license: str | None = Field(default=None, max_length=128)
     provides: list[LockedCapability] = Field(default_factory=list)
     dependencies: list[PluginDependency] = Field(default_factory=list)
+    upstream: PluginSourceSnapshot | None = None
+    components: tuple[LockedPluginComponent, ...] | None = None
 
     @field_validator("id")
     @classmethod
@@ -321,6 +411,32 @@ class PluginLockEntry(PluginContractModel):
     def validate_digest(cls, value: str) -> str:
         return _validate_digest(value)
 
+    @field_validator("components")
+    @classmethod
+    def validate_components(
+        cls, value: tuple[LockedPluginComponent, ...] | None
+    ) -> tuple[LockedPluginComponent, ...] | None:
+        if value is None:
+            return None
+        identities = [(item.kind, item.id) for item in value]
+        if len(identities) != len(set(identities)):
+            raise ValueError("plugin lock components must have unique kind/id identities")
+        return tuple(sorted(value, key=lambda item: (item.kind, item.id, item.digest)))
+
+    @model_validator(mode="after")
+    def validate_external_snapshot(self) -> "PluginLockEntry":
+        if self.upstream is not None:
+            compatible_sources = {
+                "builtin": {"builtin"},
+                "registry": {"registry", "npm"},
+                "local": {"local", "git", "npm"},
+                "market": {"market", "local", "git", "npm"},
+                "runtime-native": {"runtime-native"},
+            }
+            if self.upstream.type not in compatible_sources[self.source]:
+                raise ValueError("plugin lock source and upstream source type are inconsistent")
+        return self
+
 
 class PluginLock(PluginContractModel):
     """The current Bundle v2 lock shape, now with an exact typed entry form."""
@@ -442,10 +558,12 @@ def plugin_lock_digest(lock: PluginLock) -> str:
 __all__ = [
     "CapabilityDefinition",
     "CompositionProfile",
+    "LockedPluginComponent",
     "PluginLock",
     "PluginLockEntry",
     "PluginInventory",
     "PluginInventoryItem",
+    "PluginSourceSnapshot",
     "canonical_plugin_lock",
     "plugin_lock_digest",
 ]

ksadk/plugins/delivery.py

@@ -0,0 +1,153 @@
+"""Cloud restoration of one frozen Codex marketplace before serving traffic.
+
+The control plane admits immutable artifact references.  The platform init
+container downloads and extracts the selected archive from internal KS3; the
+runtime verifies that materialized tree before it becomes visible to Codex.
+"""
+
+from __future__ import annotations
+
+import errno
+import hashlib
+import json
+import os
+import tempfile
+from pathlib import Path
+from typing import Any, Literal
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from ksadk.builders.managed_runtime_builder import serialize_managed_runtime_manifest
+from ksadk.codex.client import CodexPluginBootstrap
+from ksadk.plugins.artifacts import (
+    PluginArtifactReceipt,
+    restore_materialized_plugin_artifact,
+    restore_plugin_artifact,
+)
+from ksadk.resource_runtime.managed_projection import native_codex_plugin_bindings
+
+
+class PluginDelivery(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+    schema_version: Literal["ksadk.plugin-delivery/v1"] = "ksadk.plugin-delivery/v1"
+    artifact_id: str | None = Field(default=None, pattern=r"^[0-9a-f-]{36}$")
+    artifact_path: str = Field(pattern=r"^ks3://[a-z0-9][a-z0-9.-]*/[^\s]+\.zip$")
+    storage_region: str = Field(min_length=1, max_length=100)
+    receipt: PluginArtifactReceipt
+    build_id: str = Field(pattern=r"^build_[0-9a-f]{8,64}$")
+    manifest_sha256: str = Field(pattern=r"^[0-9a-f]{64}$")
+    marketplace_name: str = Field(min_length=1, max_length=256)
+    plugin_names: list[str] = Field(min_length=1, max_length=128)
+    snapshot_digest: str = Field(pattern=r"^sha256:[0-9a-f]{64}$")
+    bindings: list[dict[str, Any]] = Field(min_length=1, max_length=128)
+
+    def validate_manifest(self, manifest: dict[str, Any]) -> None:
+        digest = hashlib.sha256(serialize_managed_runtime_manifest(manifest)).hexdigest()
+        if digest != self.manifest_sha256:
+            raise ValueError("Plugin delivery belongs to a different manifest")
+        runtime = manifest.get("runtime") or {}
+        if runtime.get("name") != "codex" or runtime.get("version") != self.receipt.runtime_version:
+            raise ValueError("Plugin delivery runtime does not match the manifest")
+        bindings = native_codex_plugin_bindings(manifest)
+        if self.bindings != bindings:
+            raise ValueError("Plugin delivery does not match the selected components")
+
+    def bootstrap(self, path: Path) -> CodexPluginBootstrap:
+        return CodexPluginBootstrap(
+            marketplace_path=str(path.resolve()),
+            marketplace_name=self.marketplace_name,
+            plugin_names=tuple(self.plugin_names),
+            snapshot_digest=self.snapshot_digest,
+        )
+
+
+def restore_delivery(delivery: PluginDelivery, archive: Path, work_dir: Path) -> dict[str, Any]:
+    """Restore into a content-addressed directory; recheck cached bytes on restart."""
+    if (
+        archive.stat().st_size != delivery.receipt.size_bytes
+        or "sha256:" + hashlib.sha256(archive.read_bytes()).hexdigest()
+        != delivery.receipt.artifact_digest
+    ):
+        raise ValueError("Downloaded plugin artifact does not match its receipt")
+    target = work_dir / ".agentkit" / "cloud-plugins" / delivery.receipt.artifact_digest[7:]
+    bootstrap = delivery.bootstrap(target)
+    if not target.exists():
+        target.parent.mkdir(parents=True, exist_ok=True)
+        with tempfile.TemporaryDirectory(prefix=".plugin-publish-", dir=target.parent) as tmp:
+            staged = Path(tmp) / "marketplace"
+            restore_plugin_artifact(archive, delivery.receipt, staged)
+            try:
+                os.rename(staged, target)
+            except OSError as exc:
+                # Concurrent workers can publish the same immutable tree. Only
+                # an existing destination is recoverable; verify its bytes below.
+                if exc.errno not in {errno.EEXIST, errno.ENOTEMPTY} or not target.is_dir():
+                    raise
+    bootstrap.verify()
+    return {
+        "codex_home_key": delivery.build_id,
+        "codex_plugin_bootstrap": {
+            "marketplace_path": str(target.resolve()),
+            "marketplace_name": delivery.marketplace_name,
+            "plugin_names": delivery.plugin_names,
+            "snapshot_digest": delivery.snapshot_digest,
+        },
+    }
+
+
+def restore_materialized_delivery(
+    delivery: PluginDelivery, source: Path, work_dir: Path
+) -> dict[str, Any]:
+    """Install a platform-downloaded tree into the workload-scoped cache."""
+    target = work_dir / ".agentkit" / "cloud-plugins" / delivery.receipt.artifact_digest[7:]
+    bootstrap = delivery.bootstrap(target)
+    if not target.exists():
+        target.parent.mkdir(parents=True, exist_ok=True)
+        with tempfile.TemporaryDirectory(prefix=".plugin-publish-", dir=target.parent) as tmp:
+            staged = Path(tmp) / "marketplace"
+            restore_materialized_plugin_artifact(source, delivery.receipt, staged)
+            try:
+                os.rename(staged, target)
+            except OSError as exc:
+                if exc.errno not in {errno.EEXIST, errno.ENOTEMPTY} or not target.is_dir():
+                    raise
+    bootstrap.verify()
+    return {
+        "codex_home_key": delivery.build_id,
+        "codex_plugin_bootstrap": {
+            "marketplace_path": str(target.resolve()),
+            "marketplace_name": delivery.marketplace_name,
+            "plugin_names": delivery.plugin_names,
+            "snapshot_digest": delivery.snapshot_digest,
+        },
+    }
+
+
+def prepare_cloud_plugins(manifest: dict[str, Any], work_dir: Path) -> dict[str, Any]:
+    """Verify and activate the init-container-materialized plugin artifact."""
+    bindings = native_codex_plugin_bindings(manifest)
+    if not bindings:
+        return {}
+    raw = os.environ.get("AGENTENGINE_PLUGIN_DELIVERY", "")
+    if not raw:
+        raise ValueError("Native plugins require an admitted cloud delivery reference")
+    delivery = PluginDelivery.model_validate_json(raw)
+    delivery.validate_manifest(manifest)
+    source_value = os.environ.get("AGENTENGINE_PLUGIN_ARTIFACT_DIR", "").strip()
+    if not source_value:
+        raise ValueError("Native plugins require a materialized cloud artifact")
+    source = Path(source_value)
+    work_dir.mkdir(parents=True, exist_ok=True)
+    config = restore_materialized_delivery(delivery, source, work_dir)
+    # Only non-secret, verified launch data is persisted. Recreated each startup.
+    path = work_dir / ".agentkit" / "cloud-plugin-launch.json"
+    with tempfile.NamedTemporaryFile(
+        mode="w", dir=path.parent, prefix=".plugin-launch-", delete=False
+    ) as stream:
+        temp = Path(stream.name)
+        json.dump({"manifest_sha256": delivery.manifest_sha256, "config": config}, stream)
+    try:
+        os.replace(temp, path)
+    finally:
+        temp.unlink(missing_ok=True)
+    return config

ksadk/plugins/dsh_installation_digest.py

@@ -0,0 +1,71 @@
+"""Fingerprint the installed DSH dependency tree without importing plugin code."""
+
+from __future__ import annotations
+
+import hashlib
+import os
+import stat
+from pathlib import Path
+
+
+class DshInstallationDigestError(ValueError):
+    pass
+
+
+def installation_digest(
+    root: Path, *, max_files: int = 100000, max_bytes: int = 512 * 1024 * 1024
+) -> str:
+    """Include installed bytes, execute bits and in-tree link targets.
+
+    External links cannot establish a closed Build input and are rejected. The
+    caller holds the profile lifecycle lock; this is not same-user OS isolation.
+    """
+    if type(max_files) is not int or type(max_bytes) is not int or min(max_files, max_bytes) < 1:
+        raise DshInstallationDigestError("DSH digest limits must be positive integers")
+    if root.is_symlink() or not root.is_dir():
+        raise DshInstallationDigestError("DSH installation root must be a real directory")
+    root = root.resolve()
+    digest = hashlib.sha256()
+    count = total = 0
+
+    def failed_walk(error: OSError) -> None:
+        raise DshInstallationDigestError("DSH installed tree cannot be read") from error
+
+    for directory, dirs, files in os.walk(root, followlinks=False, onerror=failed_walk):
+        dirs.sort()
+        files.sort()
+        for name in sorted(dirs + files):
+            path = Path(directory) / name
+            count += 1
+            if count > max_files:
+                raise DshInstallationDigestError("DSH installation exceeds entry limit")
+            relative = path.relative_to(root).as_posix()
+            info = path.lstat()
+            mode = stat.S_IFMT(info.st_mode)
+            digest.update(relative.encode() + b"\0")
+            if mode == stat.S_IFLNK:
+                try:
+                    target = path.resolve(strict=True).relative_to(root).as_posix()
+                except (OSError, ValueError, RuntimeError):
+                    raise DshInstallationDigestError(
+                        "DSH dependency link escapes the installed tree"
+                    ) from None
+                digest.update(b"link\0" + target.encode() + b"\0")
+            elif mode == stat.S_IFDIR:
+                digest.update(b"dir\0")
+            elif mode == stat.S_IFREG:
+                digest.update(b"file\0" + str(info.st_mode & 0o111).encode() + b"\0")
+                content_digest = hashlib.sha256()
+                descriptor = os.open(path, os.O_RDONLY | os.O_NOFOLLOW | os.O_NONBLOCK)
+                with os.fdopen(descriptor, "rb") as stream:
+                    if not stat.S_ISREG(os.fstat(stream.fileno()).st_mode):
+                        raise DshInstallationDigestError("DSH dependency is not a regular file")
+                    while chunk := stream.read(65536):
+                        total += len(chunk)
+                        if total > max_bytes:
+                            raise DshInstallationDigestError("DSH installation exceeds byte limit")
+                        content_digest.update(chunk)
+                digest.update(content_digest.digest())
+            else:
+                raise DshInstallationDigestError("DSH installation contains a special file")
+    return "sha256:" + digest.hexdigest()

ksadk/plugins/dsh_toolchain.py

@@ -32,11 +32,27 @@ from ksadk.plugins.bridges.dsh import (
 )
 
 DSH_PACKAGE = "@deepseek-ai/dsh"
-DSH_VERSION = "0.1.1-rc.2"
+DSH_VERSION = "0.1.2-rc.1"
 DSH_PACKAGE_SPEC = f"{DSH_PACKAGE}@{DSH_VERSION}"
-CORDIS_VERSION_RANGE = "^4.0.1"
+DSH_GITHUB_TAG = "dsh-v0.1.2-rc.1"
+DSH_GITHUB_COMMIT = "a66e4702047846cdaa10c66c9d3df3951f5ea70d"
+CORDIS_VERSION_RANGE = "^4.0.2"
 PNPM_VERSION = "11.7.0"
 
+# The managed package is a complete Core DSH distribution.  Keep these
+# packages explicit so a registry/dist-tag mistake cannot silently degrade the
+# installation into the old capability-only mini host.
+DSH_CORE_PACKAGES = (
+    "@deepseek-ai/dsh-base",
+    "@deepseek-ai/dsh-web-app",
+    "@deepseek-ai/dsh-cordis-client-runner",
+    "@deepseek-ai/dsh-client-ui-cordis",
+    "@deepseek-ai/dsh-app-boot",
+    "@deepseek-ai/dsh-headless",
+    "@deepseek-ai/dsh-sdk-app",
+    "@deepseek-ai/dsh-mcp-client",
+)
+
 TOOLCHAIN_HOME_ENV = "AGENTENGINE_PLUGIN_TOOLCHAIN_HOME"
 PNPM_BIN_ENV = "AGENTENGINE_PNPM_BIN"
 
@@ -65,7 +81,7 @@ class _ToolchainModel(BaseModel):
 
 class DshToolchainStatus(_ToolchainModel):
     package: Literal["@deepseek-ai/dsh"] = DSH_PACKAGE
-    expected_version: Literal["0.1.1-rc.2"] = DSH_VERSION
+    expected_version: Literal["0.1.2-rc.1"] = DSH_VERSION
     installed: bool
     usable: bool
     root: str
@@ -128,9 +144,16 @@ class DshPluginSourceError(DshToolchainError):
 
 
 class DshPluginValidationError(DshToolchainError):
-    def __init__(self, stage: str, message: str = "DSH plugin validation failed") -> None:
+    def __init__(
+        self,
+        stage: str,
+        message: str = "DSH plugin validation failed",
+        *,
+        diagnostic: str | None = None,
+    ) -> None:
         super().__init__(message)
         self.stage = stage
+        self.diagnostic = diagnostic
 
 
 class DshPluginPackError(DshToolchainError):
@@ -244,6 +267,16 @@ class DshToolchainManager:
                 actual_version=actual,
                 problem="version_mismatch",
             )
+        if not self._core_package_graph_is_complete():
+            return self._status(
+                installed=True,
+                usable=False,
+                pnpm_path=pnpm_path,
+                pnpm_version=pnpm_version,
+                executable=str(executable),
+                actual_version=actual,
+                problem="core_packages_missing_or_mismatched",
+            )
         return self._status(
             installed=True,
             usable=True,
@@ -307,6 +340,10 @@ class DshToolchainManager:
                     raise DshToolchainVersionMismatchError(
                         f"expected DSH {DSH_VERSION}, got {actual}"
                     )
+                if not self._core_package_graph_is_complete(staging):
+                    raise DshToolchainInstallError(
+                        "installed DSH package does not contain the pinned Core runtime graph"
+                    )
                 self._write_receipt(staging, actual)
                 if self._root.exists():
                     backup = parent / f".{DSH_VERSION}.backup-{uuid.uuid4().hex}"
@@ -342,7 +379,9 @@ class DshToolchainManager:
 
         if explicit is not None and str(explicit).strip():
             executable = self._resolve_program(str(explicit))
-            actual = self._command_version((executable,), cwd=self._root)
+            # An explicit installation does not require the managed default root
+            # to exist (for example in a fresh Studio HOME).
+            actual = self._command_version((executable,), cwd=Path(executable).parent)
             if actual != DSH_VERSION:
                 raise DshToolchainVersionMismatchError(
                     f"expected DSH {DSH_VERSION}, got {actual}"
@@ -405,11 +444,22 @@ class DshToolchainManager:
 
     def require_pnpm(self) -> tuple[str, ...]:
         command = self._resolve_pnpm_command()
-        result = self._runner(
-            (*command, "--version"),
-            self._pnpm_probe_cwd(),
-            self._pnpm_environment(),
-        )
+        if self._root.exists():
+            result = self._runner(
+                (*command, "--version"),
+                self._root,
+                self._pnpm_environment(),
+            )
+        else:
+            # pnpm walks parent directories looking for packageManager.  A
+            # first install under a home directory must not inherit an
+            # unrelated Yarn/npm project from one of those parents.
+            with tempfile.TemporaryDirectory(prefix="ksadk-pnpm-probe-") as directory:
+                result = self._runner(
+                    (*command, "--version"),
+                    Path(directory),
+                    self._pnpm_environment(),
+                )
         match = _VERSION.search(result.stdout or result.stderr)
         if match is None:
             raise DshToolchainUnavailableError("pnpm did not report a parseable version")
@@ -472,15 +522,6 @@ class DshToolchainManager:
         executable = self._resolve_program(command[0])
         return (executable, *command[1:])
 
-    def _pnpm_probe_cwd(self) -> Path:
-        # require_pnpm() must also work before the managed toolchain root
-        # exists (first install), so the version probe cannot unconditionally
-        # use self._root as cwd.
-        if self._root.exists():
-            return self._root
-        self._base_dir.mkdir(parents=True, exist_ok=True, mode=0o700)
-        return self._base_dir
-
     def _manifest_is_pinned(self, path: Path | None = None) -> bool:
         manifest_path = path or self._root / "package.json"
         try:
@@ -505,6 +546,34 @@ class DshToolchainManager:
             return False
         return DSH_PACKAGE in value and DSH_VERSION in value
 
+    def _core_package_graph_is_complete(self, root: Path | None = None) -> bool:
+        install_root = root or self._root
+        dsh_manifest = install_root / "node_modules" / DSH_PACKAGE / "package.json"
+        try:
+            resolved_manifest = dsh_manifest.resolve(strict=True)
+            payload = json.loads(resolved_manifest.read_text(encoding="utf-8"))
+        except (FileNotFoundError, OSError, UnicodeError, json.JSONDecodeError):
+            return False
+        dependencies = payload.get("dependencies") if isinstance(payload, dict) else None
+        if not isinstance(dependencies, dict):
+            return False
+        for package in DSH_CORE_PACKAGES:
+            requirement = dependencies.get(package)
+            # pnpm keeps transitive dependencies beside the real dsh package
+            # inside its virtual store, not necessarily at the project root.
+            manifest = (
+                resolved_manifest.parent.parent.parent
+                / Path(*package.split("/"))
+                / "package.json"
+            )
+            if (
+                not isinstance(requirement, str)
+                or DSH_VERSION not in requirement
+                or not manifest.is_file()
+            ):
+                return False
+        return True
+
     def _command_version(self, command: Sequence[str], *, cwd: Path) -> str:
         result = self._invoke((*command, "--version"), cwd=cwd)
         match = _VERSION.search(result.stdout or result.stderr)
@@ -556,6 +625,10 @@ class DshToolchainManager:
                 "package": DSH_PACKAGE,
                 "requestedVersion": DSH_VERSION,
                 "actualVersion": actual,
+                "githubTag": DSH_GITHUB_TAG,
+                "githubCommit": DSH_GITHUB_COMMIT,
+                "distribution": "core",
+                "corePackages": list(DSH_CORE_PACKAGES),
                 "packageManager": f"pnpm@{PNPM_VERSION}",
             },
         )
@@ -791,10 +864,23 @@ class DshPluginDeveloper:
                     )
             except DshToolchainError:
                 raise
+            except ValueError as error:
+                if stage == "install":
+                    raise DshPluginSourceError(str(error)) from error
+                raise DshPluginValidationError(
+                    stage,
+                    diagnostic=_redact_diagnostic(str(error)),
+                ) from error
             except DshBridgeError as error:
-                raise DshPluginValidationError(stage) from error
+                raise DshPluginValidationError(
+                    stage,
+                    diagnostic=_redact_diagnostic(str(error)),
+                ) from error
             except Exception as error:
-                raise DshPluginValidationError(stage) from error
+                raise DshPluginValidationError(
+                    stage,
+                    diagnostic=_redact_diagnostic(str(error)),
+                ) from error
 
     def pack(
         self,
@@ -902,6 +988,9 @@ class DshPluginDeveloper:
 
 __all__ = [
     "CORDIS_VERSION_RANGE",
+    "DSH_CORE_PACKAGES",
+    "DSH_GITHUB_COMMIT",
+    "DSH_GITHUB_TAG",
     "DSH_PACKAGE",
     "DSH_PACKAGE_SPEC",
     "DSH_VERSION",

ksadk/plugins/ecosystem_probe.py

@@ -13,6 +13,7 @@ import json
 from pathlib import Path
 from typing import Any
 
+from ksadk.plugins.codex_manifest import CodexPluginManifestError, load_codex_plugin_manifest
 from ksadk.plugins.ecosystem_bridge import (
     BridgeProbeExchange,
     BridgeProbeRequest,
@@ -111,9 +112,10 @@ def probe_ecosystem_manifests(
     codex_path = root / ".codex-plugin" / "plugin.json"
     if codex_path.exists():
         raw = _read_manifest(codex_path, root=root)
-        payload = _json_object(raw, name=".codex-plugin/plugin.json")
-        if not isinstance(payload.get("name"), str) or not payload["name"]:
-            raise EcosystemProbeError("Codex plugin manifest requires a non-empty name")
+        try:
+            load_codex_plugin_manifest(root)
+        except CodexPluginManifestError as exc:
+            raise EcosystemProbeError(str(exc)) from exc
         candidates.append(
             _candidate(
                 ecosystem="codex",
@@ -176,9 +178,7 @@ def probe_ecosystem_manifests(
             raise EcosystemProbeError("selected manifest was not detected in the source directory")
         selection_required = len(candidates) > 1 and selected_manifest_ref is None
         selected = (
-            None
-            if selection_required
-            else selected_manifest_ref or candidates[0].manifest_ref
+            None if selection_required else selected_manifest_ref or candidates[0].manifest_ref
         )
         result = BridgeProbeResult(
             candidates=tuple(candidates),