agentengine-sdk-python 0.8.5__py3-none-any.whl → 0.8.6__py3-none-any.whl

ksadk/plugins/providers/_process_group.py

@@ -0,0 +1,50 @@
+"""Conservative Linux process-group liveness after a successful killpg probe."""
+
+import os
+from pathlib import Path
+
+
+def linux_group_has_live_members(process_group: int, *, proc_root: Path = Path("/proc")) -> bool:
+    """Ignore only a proven zombie/dead-only group in a complete proc view.
+
+    Linux keeps orphan zombies in their process group until their new parent
+    reaps them. killpg(pgid, 0) still succeeds, although no signal can stop a
+    zombie. Unknown visibility or a racing empty snapshot stays conservative.
+    """
+    try:
+        mounts = (proc_root / "self" / "mountinfo").read_text().splitlines()
+        candidates = [line.split() for line in mounts if line.split()[4] == "/proc"]
+        if len(candidates) != 1:
+            return True  # An overmount can hide members from the older view.
+        proc_mount = candidates[0]
+        separator = proc_mount.index("-")
+        if proc_mount[separator + 1] != "proc":
+            return True
+        options = (proc_mount[5] + "," + proc_mount[separator + 3]).split(",")
+        if any(option.startswith("hidepid=") and option != "hidepid=0" for option in options):
+            return True
+        own = (proc_root / "self" / "stat").read_text()
+        own_fields = own.rsplit(")", 1)[1].split()
+        if int(own.split(" ", 1)[0]) != os.getpid() or int(own_fields[2]) != os.getpgrp():
+            return True  # An ancestor PID namespace can use different IDs.
+        status = (proc_root / "self" / "status").read_text().splitlines()
+        namespace_pids = next(line for line in status if line.startswith("NSpid:")).split()[1:]
+        if namespace_pids != [str(os.getpid())]:
+            return True  # Matching numbers alone cannot prove namespace identity.
+        matched = False
+        for entry in proc_root.iterdir():
+            if not entry.name.isdecimal():
+                continue
+            try:
+                # comm is parenthesized and can contain spaces and ')'.
+                stat = (entry / "stat").read_text().rsplit(")", 1)[1].split()
+                group = int(stat[2])
+            except FileNotFoundError:
+                continue  # This process was reaped during the snapshot.
+            if group == process_group:
+                matched = True
+                if stat[0] not in {"Z", "X", "x"}:
+                    return True
+        return not matched
+    except (OSError, ValueError, IndexError, StopIteration):
+        return True

ksadk/plugins/providers/bundles/dsh-knowledge/index.mjs

@@ -1,6 +1,18 @@
 export const name = 'dsh-knowledge'
 export const inject = ['tools', 'platformResources']
 
+// The platform retrieval service may prefix a chunk with its internal object
+// storage key (for example ``upload_files/<numeric-id>/<uuid>.md,``).  That
+// value is neither useful evidence nor safe user-facing content.  Long numeric
+// object keys also look like payment-card numbers to the Harness DLP policy,
+// which forces an otherwise harmless knowledge result into an unreadable
+// sensitive artifact.  Strip only this well-known transport prefix and retain
+// the document title and every byte of authored content that follows it.
+export function sanitizeKnowledgeContent(value) {
+  if (typeof value !== 'string') return value
+  return value.replace(/^upload_files\/[^,\r\n]+,/, '')
+}
+
 export function apply(ctx) {
   ctx.effect(() => ctx.platformResources.registerTool('search_knowledge_base', 'search_knowledge_base'))
   ctx.tools.register({
@@ -46,8 +58,18 @@ export function apply(ctx) {
       },
     },
     isConcurrencySafe: () => true,
-    execute(args, execution) {
-      return ctx.platformResources.call('search_knowledge_base', args, { signal: execution.signal })
+    async execute(args, execution) {
+      const result = await ctx.platformResources.call(
+        'search_knowledge_base', args, { signal: execution.signal },
+      )
+      if (!result || !Array.isArray(result.items)) return result
+      return {
+        ...result,
+        items: result.items.map(item => ({
+          ...item,
+          content: sanitizeKnowledgeContent(item.content),
+        })),
+      }
     },
   })
 }

ksadk/plugins/providers/bundles/dsh-knowledge/package.json

@@ -9,7 +9,7 @@
   "engines": {"node": ">=22.19.0"},
   "peerDependencies": {
     "@deepseek-ai/cordis": "^4.0.1",
-    "@deepseek-ai/dsh-tools": "0.1.5-rc.1",
+    "@deepseek-ai/dsh-tools": "0.1.7-rc.1",
     "@kingsoftcloud/dsh-platform-resources": "0.1.0"
   },
   "dsh": {"bundle": {"patch": "./cordis.patch.yml"}}

ksadk/plugins/providers/bundles/dsh-memory/package.json

@@ -9,7 +9,7 @@
   "engines": {"node": ">=22.19.0"},
   "peerDependencies": {
     "@deepseek-ai/cordis": "^4.0.1",
-    "@deepseek-ai/dsh-tools": "0.1.5-rc.1",
+    "@deepseek-ai/dsh-tools": "0.1.7-rc.1",
     "@kingsoftcloud/dsh-platform-resources": "0.1.0"
   },
   "dsh": {"bundle": {"patch": "./cordis.patch.yml"}}

ksadk/plugins/providers/bundles/dsh-skill-center/package.json

@@ -9,7 +9,7 @@
   "engines": {"node": ">=22.19.0"},
   "peerDependencies": {
     "@deepseek-ai/cordis": "^4.0.1",
-    "@deepseek-ai/dsh-tools": "0.1.5-rc.1",
+    "@deepseek-ai/dsh-tools": "0.1.7-rc.1",
     "@kingsoftcloud/dsh-platform-resources": "0.1.0"
   },
   "dsh": {"bundle": {"patch": "./cordis.patch.yml"}}

ksadk/plugins/providers/bundles/dsh-teams-tools/package.json

@@ -19,7 +19,7 @@
   "peerDependencies": {
     "@deepseek-ai/cordis": "^4.0.1",
     "@kingsoftcloud/dsh-teams-router": "0.1.0",
-    "@deepseek-ai/dsh-tools": "0.1.5-rc.1"
+    "@deepseek-ai/dsh-tools": "0.1.7-rc.1"
   },
   "dsh": {
     "bundle": {

ksadk/plugins/providers/bundles/ksadk-dsh-capability-host/package.json

@@ -16,7 +16,7 @@
   },
   "peerDependencies": {
     "@deepseek-ai/cordis": "^4.0.2",
-    "@deepseek-ai/dsh-tools": "0.1.5-rc.1"
+    "@deepseek-ai/dsh-tools": "0.1.7-rc.1"
   },
   "dsh": {
     "bundle": {

ksadk/plugins/providers/codex.py

@@ -35,6 +35,8 @@ from ksadk.runtime.conversation_execution import invoke_runtime_conversation_onc
 from ksadk.sessions import create_session_service
 from ksadk.sessions.base import BaseSessionService
 
+from ksadk.plugins.providers.codex_skills import _resolve_skills
+
 
 @dataclass(frozen=True)
 class CodexProviderInventory:
@@ -194,6 +196,7 @@ class CodexAgentProviderRuntime:
         runtime_state_root: Path | None = None,
         local_launch_resolver: Callable[..., RuntimeLaunchContext | None] | None = None,
         runtime_executor: RuntimeExecutor | None = None,
+        managed_a2a_bootstrap: Any = None,
     ) -> None:
         self._plugin_id = plugin_id
         self._session_service = session_service
@@ -202,6 +205,7 @@ class CodexAgentProviderRuntime:
         self._runtime_state_root = runtime_state_root
         self._local_launch_resolver = local_launch_resolver
         self._runtime_executor = runtime_executor
+        self._managed_a2a_bootstrap = managed_a2a_bootstrap
         self._ready = False
         self._disposed = False
         self._last_activation: CodexAgentActivation | None = None
@@ -266,6 +270,7 @@ class CodexAgentProviderRuntime:
                 codex_client_factory=self._client_factory,
                 mcp_projection=projection,
                 runtime_executor=self._runtime_executor,
+                managed_a2a_bootstrap=self._managed_a2a_bootstrap,
             )
         except BaseException:
             await projection.aclose()
@@ -323,6 +328,7 @@ class CodexAgentProviderFactory:
             runtime_state_root=runtime_state_root,
             local_launch_resolver=services.get("codex_local_launch_resolver"),
             runtime_executor=runtime_executor,
+            managed_a2a_bootstrap=services.get("managed_a2a_bootstrap"),
         )
         return self.runtime
 
@@ -337,6 +343,7 @@ class CodexAgentActivation:
         codex_client_factory: Callable[..., Any] | None,
         mcp_projection: MCPProjectionLease,
         runtime_executor: RuntimeExecutor | None = None,
+        managed_a2a_bootstrap: Any = None,
     ) -> None:
         self._bundle = bundle
         self._config = config
@@ -347,7 +354,8 @@ class CodexAgentActivation:
             runtime_type="codex",
             project_dir=config.project_dir,
             config=config.launch_config,
-            services=RuntimeServices(codex_client_factory=codex_client_factory),
+            services=RuntimeServices(codex_client_factory=codex_client_factory,
+                                     managed_a2a_bootstrap=managed_a2a_bootstrap),
         )
         self._ready = False
         self._disposed = False
@@ -564,6 +572,30 @@ def _reject_external_execution(
         )
 
 
+def _bundle_a2a_experts(spec):
+    """Only frozen Bundle bindings may declare fixed experts."""
+    if "remoteAgents" in spec and "remote_agents" in spec:
+        raise PluginHostError("a2a_binding_invalid", "Duplicate A2A binding fields")
+    raw = spec.get("remoteAgents", spec.get("remote_agents", []))
+    # ResolvedPluginBundle freezes JSON arrays into tuples.
+    if not isinstance(raw, (list, tuple)):
+        raise PluginHostError("a2a_binding_invalid", "A2A bindings must be a list")
+    if not raw:
+        return []
+    from ksadk.studio.contracts import RemoteAgentBinding
+    from ksadk.a2a.invocation_types import RemoteAgentSpec
+    from ksadk.a2a.codex import compile_codex_experts
+
+    bindings = [RemoteAgentBinding.model_validate(value) for value in raw]
+    specs = [RemoteAgentSpec(
+        local_name=b.local_name, binding_id=b.binding_id, space_id=b.space_id,
+        target_agent_id=b.target_agent_id, expected_version_id=b.expected_version_id,
+        exposure=b.exposure, policy_ref=b.policy_ref,
+    ) for b in bindings]
+    compile_codex_experts(specs)
+    return [value.model_dump(mode="json") for value in specs]
+
+
 def _resolve_bundle_config(
     bundle: ResolvedPluginBundle,
     *,
@@ -573,6 +605,10 @@ def _resolve_bundle_config(
     local_launch: RuntimeLaunchContext | None = None,
 ) -> _CodexBundleConfig:
     spec = bundle.resolved_agent_spec
+    a2a_experts = _bundle_a2a_experts(spec)
+    if local_launch is not None and "a2a_experts" in local_launch.config:
+        if local_launch.config["a2a_experts"] != a2a_experts:
+            raise PluginHostError("a2a_binding_drift", "Local experts differ from immutable Bundle")
     raw_model = spec.get("model")
     if not isinstance(raw_model, Mapping):
         raise PluginHostError(
@@ -666,6 +702,11 @@ def _resolve_bundle_config(
     # Local launch compatibility never replaces immutable Bundle Skill bytes.
     launch_config["skills"] = skills
     launch_config["enforce_bound_skills"] = True
+    # Local launch configuration cannot add, remove, or retarget experts.
+    if a2a_experts:
+        launch_config["a2a_experts"] = a2a_experts
+    else:
+        launch_config.pop("a2a_experts", None)
     return _CodexBundleConfig(
         model=model,
         allowed_models=allowed_models,
@@ -833,43 +874,6 @@ def _resolve_allowed_models(
     return models
 
 
-def _resolve_skills(root: Path, value: Any) -> list[dict[str, str]]:
-    if value is None:
-        return []
-    if not isinstance(value, Sequence) or isinstance(value, (str, bytes)):
-        raise PluginHostError("codex_skill_invalid", "Bundle Skills must be a list")
-    resolved: list[dict[str, str]] = []
-    seen: set[str] = set()
-    for index, item in enumerate(value):
-        if not isinstance(item, Mapping):
-            raise PluginHostError(
-                "codex_skill_invalid", f"Bundle Skills[{index}] must be an object"
-            )
-        name = str(item.get("name") or "").strip()
-        relative = PurePosixPath(str(item.get("bundlePath") or item.get("bundle_path") or ""))
-        if not name or not relative.parts or relative.is_absolute() or ".." in relative.parts:
-            raise PluginHostError(
-                "codex_skill_invalid", f"Bundle Skills[{index}] has an invalid native path"
-            )
-        path = (root / Path(*relative.parts)).resolve()
-        try:
-            path.relative_to(root)
-        except ValueError as error:
-            raise PluginHostError(
-                "codex_skill_invalid", f"Bundle Skill {name!r} escapes the Bundle root"
-            ) from error
-        if not (path / "SKILL.md").is_file():
-            raise PluginHostError("codex_skill_missing", f"Bundle Skill {name!r} has no SKILL.md")
-        if name in seen:
-            raise PluginHostError("codex_skill_invalid", f"duplicate Bundle Skill {name!r}")
-        seen.add(name)
-        # Codex's native SkillInput expects the concrete SKILL.md source, not
-        # its containing directory.  A directory is accepted by the Python
-        # model but silently omitted by the real App Server turn projection.
-        resolved.append({"name": name, "path": str(path / "SKILL.md")})
-    return resolved
-
-
 def _resolve_mcp(
     value: Any,
     *,

ksadk/plugins/providers/codex_native.py

@@ -167,11 +167,29 @@ def _codex_home_key(
     return value
 
 
+def _codex_a2a_experts(config, bootstrap):
+    """Validate immutable fixed targets before client or home creation."""
+    raw = config.get("a2a_experts", [])
+    if not isinstance(raw, list):
+        raise ValueError("A2A_CODEX_EXPERT_CONFIG_INVALID")
+    if not raw:
+        return ()
+    from ksadk.a2a.codex import compile_codex_experts
+    from ksadk.a2a.invocation_types import RemoteAgentSpec
+
+    specs = tuple(RemoteAgentSpec.model_validate(value) for value in raw)
+    compile_codex_experts(specs)
+    if bootstrap is None or not bootstrap.outbound_enabled:
+        raise ValueError("A2A_MANAGED_BOOTSTRAP_REQUIRED")
+    return specs
+
+
 def create_codex_adapter(context: RuntimeLaunchContext) -> RuntimeAdapter:
     from ksadk.codex.runtime import CodexRuntimeAdapter
 
     client_factory = context.services.codex_client_factory or AsyncCodexClient
     config = dict(context.config)
+    a2a_specs = _codex_a2a_experts(config, context.services.managed_a2a_bootstrap)
     plugin_bootstrap = _codex_plugin_bootstrap(config)
     codex_home_key = _codex_home_key(config, plugin_bootstrap)
     bound_skill_paths: dict[str, str] = {}
@@ -241,6 +259,8 @@ def create_codex_adapter(context: RuntimeLaunchContext) -> RuntimeAdapter:
             enforce_bound_skills=bool(config.get("enforce_bound_skills")),
         ),
         plugin_bootstrap=plugin_bootstrap,
+        a2a_experts=a2a_specs,
+        managed_a2a_bootstrap=context.services.managed_a2a_bootstrap,
     )
 
 

ksadk/plugins/providers/codex_skills.py

@@ -0,0 +1,46 @@
+"""Resolve pinned Codex bundle Skill inputs without escaping the bundle root."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping, Sequence
+from pathlib import Path, PurePosixPath
+from typing import Any
+
+from ksadk.plugins.host import PluginHostError
+
+
+def _resolve_skills(root: Path, value: Any) -> list[dict[str, str]]:
+    if value is None:
+        return []
+    if not isinstance(value, Sequence) or isinstance(value, (str, bytes)):
+        raise PluginHostError("codex_skill_invalid", "Bundle Skills must be a list")
+    resolved: list[dict[str, str]] = []
+    seen: set[str] = set()
+    for index, item in enumerate(value):
+        if not isinstance(item, Mapping):
+            raise PluginHostError(
+                "codex_skill_invalid", f"Bundle Skills[{index}] must be an object"
+            )
+        name = str(item.get("name") or "").strip()
+        relative = PurePosixPath(str(item.get("bundlePath") or item.get("bundle_path") or ""))
+        if not name or not relative.parts or relative.is_absolute() or ".." in relative.parts:
+            raise PluginHostError(
+                "codex_skill_invalid", f"Bundle Skills[{index}] has an invalid native path"
+            )
+        path = (root / Path(*relative.parts)).resolve()
+        try:
+            path.relative_to(root)
+        except ValueError as error:
+            raise PluginHostError(
+                "codex_skill_invalid", f"Bundle Skill {name!r} escapes the Bundle root"
+            ) from error
+        if not (path / "SKILL.md").is_file():
+            raise PluginHostError("codex_skill_missing", f"Bundle Skill {name!r} has no SKILL.md")
+        if name in seen:
+            raise PluginHostError("codex_skill_invalid", f"duplicate Bundle Skill {name!r}")
+        seen.add(name)
+        # Codex's native SkillInput expects the concrete SKILL.md source, not
+        # its containing directory.  A directory is accepted by the Python
+        # model but silently omitted by the real App Server turn projection.
+        resolved.append({"name": name, "path": str(path / "SKILL.md")})
+    return resolved

ksadk/plugins/providers/dsh_capabilities.py

@@ -10,19 +10,18 @@ Streamable HTTP MCP lease.  Tool discovery and execution stay inside the real
 from __future__ import annotations
 
 import asyncio
-import base64
 import hashlib
-import hmac
 import json
 import math
 import os
 import re
-import secrets
+import secrets as secrets  # Public-module injection seam for scoped token tests.
 import shutil
 import signal
 import struct
+import sys
 import tempfile
-import time
+import time as time  # Shared clock seam remains available at the original module.
 from collections import deque
 from collections.abc import Mapping, Sequence
 from dataclasses import dataclass, field
@@ -37,6 +36,7 @@ from ksadk.plugins.bridges.dsh import DshProfileProjection, dsh_subprocess_envir
 from ksadk.plugins.contracts import PluginContractModel
 from ksadk.plugins.host import PluginHostError
 from ksadk.plugins.providers.dsh import DshCircuitBreaker, DshCircuitSnapshot
+from ksadk.plugins.providers.dsh_connector_lease import _TOOL_NAME, DshConnectorLeaseTokens
 
 DSH_CAPABILITY_HOST_PROTOCOL = "ksadk.dsh-capability-host/v1"
 DSH_CAPABILITY_HOST_VERSION = "1.0.0"
@@ -49,7 +49,6 @@ DSH_CAPABILITY_MIN_NODE_VERSION = (22, 19, 0)
 _DIGEST = re.compile(r"^sha256:[0-9a-f]{64}$")
 _SEMVER = re.compile(r"^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$")
 _PROFILE = re.compile(r"^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$")
-_TOOL_NAME = re.compile(r"^[A-Za-z0-9_.:-]+$")
 _ENV_NAME = re.compile(r"^[A-Za-z_][A-Za-z0-9_]*$")
 _NODE_VERSION = re.compile(r"^v?(\d+)\.(\d+)\.(\d+)(?:[-+].*)?$")
 _SECRET_ENV = re.compile(
@@ -316,7 +315,7 @@ class DshProfileCapabilityDescriptor(PluginContractModel):
 
 
 @dataclass(frozen=True)
-class DshMcpConnectorLease:
+class DshMcpConnectorLease(DshConnectorLeaseTokens):
     """Ephemeral connection material for one running ``mcp.connector/v1``."""
 
     endpoint: str = field(repr=False)
@@ -330,169 +329,9 @@ class DshMcpConnectorLease:
     transport: Literal["streamable-http"] = "streamable-http"
     protocol_version: Literal["2025-06-18"] = "2025-06-18"
 
-    def headers(self) -> dict[str, str]:
-        """Return fresh request headers without storing them in descriptors/logs."""
-
-        return {"Authorization": f"Bearer {self._bearer_token}"}
-
-    def companion_bearer_token(
-        self, *, plugin_id: str, generation_id: str, handle: str,
-        tool_name: str, call_id: str, ttl_seconds: int = 60,
-    ) -> str:
-        """Sign only an opaque Python grant and one exact native tool call."""
-        if (not re.fullmatch(r"[A-Za-z0-9_.-]{1,128}", plugin_id)
-            or not re.fullmatch(r"dshgen_[A-Za-z0-9_-]{24,96}", generation_id)
-            or not re.fullmatch(r"[A-Za-z0-9_-]{32,256}", handle)
-            or not _TOOL_NAME.fullmatch(tool_name)
-            or not re.fullmatch(r"[A-Za-z0-9_.:-]{1,128}", call_id)
-            or not 1 <= ttl_seconds <= 120):
-            raise ValueError("invalid companion invocation scope")
-        payload = {
-            "v": 3, "profileDigest": self.profile_digest,
-            "pluginId": plugin_id, "generationId": generation_id,
-            "handle": handle, "callId": call_id,
-            "aliases": {tool_name: tool_name},
-            "exp": int(time.time()) + ttl_seconds,
-            "jti": secrets.token_urlsafe(24),
-        }
-        raw = json.dumps(payload, sort_keys=True, separators=(",", ":")).encode()
-        encoded = base64.urlsafe_b64encode(raw).rstrip(b"=").decode()
-        message = f"ks3.{encoded}"
-        signature = base64.urlsafe_b64encode(
-            hmac.new(self._bearer_token.encode(), message.encode(), hashlib.sha256).digest()
-        ).rstrip(b"=").decode()
-        return f"{message}.{signature}"
-
-    def resource_bearer_token(self, tool_aliases: Mapping[str, str], resource_leases) -> str:
-        """Mint scope v2 from host-issued, activation-bound resource leases."""
-        from ksadk.resource_runtime.leases import ResourceLease
-
-        leases = tuple(resource_leases)
-        if not leases or any(not isinstance(lease, ResourceLease) for lease in leases):
-            raise ValueError("Resource scope requires host-issued leases")
-        first = leases[0].scope
-        if first.profile_digest != self.profile_digest:
-            raise ValueError("Resource scope belongs to another profile")
-        aliases = dict(tool_aliases)
-        if not 1 <= len(aliases) <= 32 or any(
-            not isinstance(alias, str)
-            or not isinstance(source, str)
-            or not re.fullmatch(r"[A-Za-z0-9_-]{1,64}", alias)
-            or not _TOOL_NAME.fullmatch(source)
-            for alias, source in aliases.items()
-        ):
-            raise ValueError("Resource scope requires explicit valid tool aliases")
-        resources = {}
-        lifetime = 600
-        for lease in leases:
-            scope = lease.scope
-            if (
-                scope.generation_id != first.generation_id
-                or scope.activation_id != first.activation_id
-                or scope.build_digest != first.build_digest
-                or scope.binding_snapshot_digest != first.binding_snapshot_digest
-                or scope.identity != first.identity
-                or scope.profile_digest != first.profile_digest
-            ):
-                raise ValueError("Resource scope cannot mix activations")
-            lifetime = min(lifetime, math.floor(lease.expires_at - time.monotonic()))
-            for operation in scope.allowed_operations:
-                if operation not in aliases.values():
-                    continue
-                if operation in resources:
-                    raise ValueError("Resource operation has ambiguous bindings")
-                resources[operation] = {
-                    "handle": lease.handle,
-                    "bindingId": scope.binding_id,
-                    "operation": operation,
-                }
-        if lifetime < 1 or not resources:
-            raise ValueError("Resource scope has no live operations")
-        issued = int(time.time())
-        payload = {
-            "v": 2,
-            "profileDigest": self.profile_digest,
-            "generationId": first.generation_id,
-            "activationId": first.activation_id,
-            "buildDigest": first.build_digest,
-            "bindingSnapshotDigest": first.binding_snapshot_digest,
-            "identity": first.identity.model_dump(by_alias=True, mode="json"),
-            "aliases": aliases,
-            "resources": resources,
-            "issuedAt": issued,
-            "expiresAt": issued + lifetime,
-            "jti": secrets.token_urlsafe(24),
-        }
-        raw = json.dumps(
-            payload, ensure_ascii=False, sort_keys=True, separators=(",", ":"), allow_nan=False
-        ).encode()
-        encoded = base64.urlsafe_b64encode(raw).rstrip(b"=").decode()
-        message = f"ks2.{encoded}"
-        signature = (
-            base64.urlsafe_b64encode(
-                hmac.new(self._bearer_token.encode(), message.encode(), hashlib.sha256).digest()
-            )
-            .rstrip(b"=")
-            .decode()
-        )
-        token = f"{message}.{signature}"
-        if len(token) > 12 * 1024:
-            raise ValueError("Resource scope exceeds header size limit")
-        return token
-
-    def browser_url(self) -> str:
-        """Return the one-time full Core DSH browser handoff URL."""
-
-        if self.web_route_count < 1 or not self._browser_token:
-            raise PluginHostError(
-                "dsh_core_web_unavailable",
-                "The selected DSH Profile does not expose the Core Web application",
-            )
-        parsed = urlsplit(self.endpoint)
-        return f"http://127.0.0.1:{parsed.port}/?token={self._browser_token}"
-
-    def bearer_token_for_runtime(self, tool_aliases: Mapping[str, str]) -> str:
-        """Mint a generation-bound token limited to explicit tool names."""
-
-        aliases = {
-            str(alias).strip(): str(source).strip() for alias, source in tool_aliases.items()
-        }
-        if (
-            not aliases
-            or len(aliases) != len(tool_aliases)
-            or len(aliases) > 32
-            or any(
-                not re.fullmatch(r"[A-Za-z0-9_-]{1,64}", alias) or not _TOOL_NAME.fullmatch(source)
-                for alias, source in aliases.items()
-            )
-        ):
-            raise PluginHostError(
-                "dsh_capability_scope_invalid",
-                "DSH capability tokens require an explicit valid tool scope",
-            )
-        payload = json.dumps(
-            {
-                "v": 1,
-                "profileDigest": self.profile_digest,
-                "exp": int(time.time()) + _SCOPED_TOKEN_LIFETIME_SECONDS,
-                "jti": secrets.token_urlsafe(16),
-                "aliases": dict(sorted(aliases.items())),
-            },
-            allow_nan=False,
-            ensure_ascii=False,
-            sort_keys=True,
-            separators=(",", ":"),
-        ).encode("utf-8")
-        encoded = base64.urlsafe_b64encode(payload).rstrip(b"=")
-        signature = hmac.new(self._bearer_token.encode("utf-8"), encoded, hashlib.sha256).digest()
-        encoded_signature = base64.urlsafe_b64encode(signature).rstrip(b"=")
-        token = f"ks1.{encoded.decode('ascii')}.{encoded_signature.decode('ascii')}"
-        if len(token) > 12 * 1024:
-            raise PluginHostError(
-                "dsh_capability_scope_too_large",
-                "DSH capability token scope exceeds the HTTP header budget",
-            )
-        return token
+    def _runtime_token_lifetime(self) -> int:
+        # Preserve the host module's dynamic policy/monkeypatch seam.
+        return _SCOPED_TOKEN_LIFETIME_SECONDS
 
 
 class DshProfileCapabilityInventory(PluginContractModel):
@@ -1324,8 +1163,10 @@ class DshProfileCapabilityHost:
                 if remaining <= 0:
                     break
                 await asyncio.sleep(min(0.05, remaining))
-            if self._process_group_exists(process.pid):
-                self._signal_process_group(process.pid, signal.SIGKILL)
+            # Always seal the owned group after the liveness snapshot. A
+            # descendant can fork between /proc enumeration and becoming a
+            # zombie; the new child must not escape a zombie-only fast exit.
+            self._signal_process_group(process.pid, signal.SIGKILL)
         elif process.returncode is None:
             process.kill()
 
@@ -1347,6 +1188,10 @@ class DshProfileCapabilityHost:
             return False
         except PermissionError:
             return True
+        if sys.platform == "linux":
+            from ksadk.plugins.providers._process_group import linux_group_has_live_members
+
+            return linux_group_has_live_members(process_group)
         return True
 
     def _record_process_failure(self) -> None: