langchain-agentx-python 2.2.9__tar.gz → 2.3.1__tar.gz

{langchain-agentx-python-2.2.9/langchain_agentx_python.egg-info → langchain-agentx-python-2.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: langchain-agentx-python
-Version: 2.2.9
+Version: 2.3.1
 Summary: LangChain/LangGraph-based agent utilities for CodeBaseX.
 Author-email: GoodMood2008 <GoodMood2008@users.noreply.github.com>
 License:                                  Apache License

{langchain-agentx-python-2.2.9 → langchain-agentx-python-2.3.1}/langchain_agentx/__init__.py

@@ -11,7 +11,7 @@ from langchain_agentx import create_loop_agent
 ```
 """
 
-__version__ = "2.2.9"
+__version__ = "2.3.1"
 
 from .loop import (  # noqa: F401
     create_loop_agent,

{langchain-agentx-python-2.2.9 → langchain-agentx-python-2.3.1}/langchain_agentx/loop/graph/factory.py

@@ -756,8 +756,17 @@ class LoopGraphBuilder:
                 include_agent=not user_has_agent_tool,
             )
             for tool in self._services.loader.registry.list():
-                if tool.name not in self._loop_loader.registry._tools:
-                    self._loop_loader.register(tool)
+                if tool.name in self._loop_loader.registry._tools:
+                    existing = self._loop_loader.registry.get(tool.name)
+                    if existing is not tool:
+                        logger.warning(
+                            "Host loader tool %r not merged into loop; "
+                            "register_default_tools already registered %r (S-4)",
+                            tool.name,
+                            tool.name,
+                        )
+                    continue
+                self._loop_loader.register(tool)
             self._runtime_tools = self._loop_loader.registry.list()
             from ...loop.prompt.tool_aware_sections import collect_enabled_tool_names
 

{langchain-agentx-python-2.2.9 → langchain-agentx-python-2.3.1}/langchain_agentx/tool_runtime/inner_permission_chain.py

@@ -209,12 +209,13 @@ class InnerPermissionChain:
             command = data.get("command")
             if not isinstance(command, str) or not command.strip():
                 return None
-            deny_result = matcher.match_deny(tool_name, command)
-            if deny_result is not None:
-                return deny_result
-            ask_result = matcher.match_ask(tool_name, command)
-            if ask_result is not None:
-                return ask_result
+            from langchain_agentx.tools.bash.bash_registry_content import (
+                evaluate_bash_inner_content_rules,
+            )
+
+            content_decision = evaluate_bash_inner_content_rules(command, registry)
+            if content_decision is not None:
+                return content_decision
             return None
 
         path = self._engine._extract_path(data)

{langchain-agentx-python-2.2.9 → langchain-agentx-python-2.3.1}/langchain_agentx/tool_runtime/loader.py

@@ -155,6 +155,7 @@ class ToolRuntimeLoader:
         目的：为 subagent 组装“过滤后的工具池”而不丢失权限/管控语义。
         """
         child = ToolRuntimeLoader(
+            policy_config=self._process.policy_config,
             policy_engine=self._process.policy,
             headless=self._process.headless if headless is None else headless,
             prompt_handler=self._process.prompt_handler,

{langchain-agentx-python-2.2.9 → langchain-agentx-python-2.3.1}/langchain_agentx/tool_runtime/loop_loader.py

@@ -107,6 +107,7 @@ class LoopLoader:
             agent_home_segment=self._agent_home,
             session_cwd=effective_cwd,
         )
+        self._merge_skill_read_roots_policy(cfg)
         self._inject_project_memory_policy(cfg)
         plugin_ex = PluginCacheGlobExclusions(
             cache_root=str(cfg.plugin_cache_dir.resolve()),
@@ -210,11 +211,21 @@ class LoopLoader:
                 setter(patterns)
         return patterns
 
+    def _merge_skill_read_roots_policy(self, workspace_cfg: Any) -> None:
+        """G-2：skill 发现目录并入 read_roots（在 project_memory 注入之前）。"""
+        from langchain_agentx.tools.skill.source_paths import resolve_skill_read_roots
+
+        roots = resolve_skill_read_roots(workspace_cfg)
+        if not roots:
+            return
+        base = self._process.effective_policy_config()
+        self._process.apply_policy_config(base.with_merged_read_roots(roots))
+
     def _inject_project_memory_policy(self, workspace_cfg: Any) -> None:
         """Per-loop 注入 CC projects 树读写根与 path_safety layout。"""
         layout = workspace_cfg.project_memory_layout
         workspace_root = str(Path(self._workspace_root).resolve())
-        base = self._process.policy_config or ToolPolicyConfig()
+        base = self._process.effective_policy_config()
         if not base.read_roots:
             base = replace(base, read_roots=[workspace_root])
         if not base.write_roots:

{langchain-agentx-python-2.2.9 → langchain-agentx-python-2.3.1}/langchain_agentx/tool_runtime/permission_rules.py

@@ -127,6 +127,15 @@ def _content_rule_matches_target(
             target=target,
             rule_content=rule_content,
         )
+    if tool_name == "Skill":
+        from langchain_agentx.tools.skill.registry_permission import (
+            skill_rule_content_matches,
+        )
+
+        return skill_rule_content_matches(
+            skill_name=target,
+            rule_content=rule_content,
+        )
     return fnmatch.fnmatch(target, rule_content)
 
 

{langchain-agentx-python-2.2.9 → langchain-agentx-python-2.3.1}/langchain_agentx/tool_runtime/policy.py

@@ -45,9 +45,11 @@ from __future__ import annotations
 import fnmatch
 import os
 import sys
+from pathlib import Path
 import warnings
 from abc import ABC, abstractmethod
 from dataclasses import dataclass, field, replace
+from collections.abc import Iterable
 from typing import TYPE_CHECKING, Any
 
 from .models import AuthorizationDecision, ToolExecutionContext
@@ -123,6 +125,20 @@ class ToolPolicyConfig:
             normalize_tool_name_set(self.cli_allow_tools),
         )
 
+    def with_merged_read_roots(
+        self,
+        extra: Iterable[str | os.PathLike[str]],
+    ) -> "ToolPolicyConfig":
+        """Union ``read_roots``；保留 cliArg / rules 等字段（Phase 2 skill 发现根）。"""
+        merged: list[str] = []
+        seen: set[str] = set()
+        for raw in (*self.read_roots, *(str(Path(p).expanduser().resolve()) for p in extra)):
+            if not raw or raw in seen:
+                continue
+            seen.add(raw)
+            merged.append(raw)
+        return replace(self, read_roots=merged)
+
     def with_project_memory_layout(
         self,
         layout: "ProjectMemoryLayout",
@@ -313,11 +329,16 @@ class DefaultPolicyEngine(PolicyEngine):
             config: 策略配置
             auto_mode_hook: Auto Mode 授权 Hook（可选，Phase 1 集成）
         """
+        self._auto_mode_hook = auto_mode_hook
+        self._internal_paths = InternalPathEvaluator()
+        self._agent_home_bypass = AgentHomeSessionBypassEvaluator()
+        self.replace_policy_config(config)
+
+    def replace_policy_config(self, config: ToolPolicyConfig) -> None:
+        """原地更新 config 与派生 roots/authorizer（loop project memory 注入）。"""
         self._config = config
         self._read_roots = [os.path.realpath(r) for r in config.read_roots]
         self._write_roots = [os.path.realpath(r) for r in config.write_roots]
-        self._auto_mode_hook = auto_mode_hook
-        self._internal_paths = InternalPathEvaluator()
         self._path_safety: PathSafetyEvaluator | None = None
         if config.enable_path_safety and config.path_safety is not None:
             self._path_safety = PathSafetyEvaluator(
@@ -341,7 +362,6 @@ class DefaultPolicyEngine(PolicyEngine):
                 self._within_root(real_path, r) for r in self._read_roots
             ),
         )
-        self._agent_home_bypass = AgentHomeSessionBypassEvaluator()
 
     def authorize(
         self,

{langchain-agentx-python-2.2.9 → langchain-agentx-python-2.3.1}/langchain_agentx/tool_runtime/process_loader.py

@@ -50,14 +50,21 @@ class ProcessLoader:
             permission_resolver=permission_resolver,
         )
         self._adapter = LangChainAdapter()
-        self._policy_config = policy_config
         if policy_engine is not None:
             self._policy: PolicyEngine | None = policy_engine
+            if policy_config is not None:
+                self._policy_config = policy_config
+            elif isinstance(policy_engine, DefaultPolicyEngine):
+                self._policy_config = policy_engine._config
+            else:
+                self._policy_config = None
         elif policy_config is not None:
+            self._policy_config = policy_config
             self._policy = DefaultPolicyEngine(policy_config)
         else:
-            self._policy = DefaultPolicyEngine(ToolPolicyConfig())
-            self._policy_config = ToolPolicyConfig()
+            empty = ToolPolicyConfig()
+            self._policy_config = empty
+            self._policy = DefaultPolicyEngine(empty)
 
     def set_permission_resolver(
         self,
@@ -141,12 +148,22 @@ class ProcessLoader:
     def permission_resolver(self) -> PermissionResolver | None:
         return self._permission_resolver
 
+    def effective_policy_config(self) -> ToolPolicyConfig:
+        """policy_config → DefaultPolicyEngine._config → 空配置（loop 注入 SSOT）。"""
+        if self._policy_config is not None:
+            return self._policy_config
+        policy = self._policy
+        if isinstance(policy, DefaultPolicyEngine):
+            return policy._config
+        return ToolPolicyConfig()
+
     def apply_policy_config(self, policy_config: ToolPolicyConfig) -> None:
-        """替换策略配置并重建 DefaultPolicyEngine（保留 auto_mode hook）。"""
-        auto_hook = None
-        if isinstance(self._policy, DefaultPolicyEngine):
-            auto_hook = self._policy._auto_mode_hook
+        """替换策略配置；DefaultPolicyEngine 原地 rebind，保留 engine 实例 id。"""
         self._policy_config = policy_config
+        if isinstance(self._policy, DefaultPolicyEngine):
+            self._policy.replace_policy_config(policy_config)
+            return
+        auto_hook = None
         self._policy = DefaultPolicyEngine(policy_config, auto_mode_hook=auto_hook)
 
     def sync_permission_rules_from_disk(

langchain-agentx-python-2.3.1/langchain_agentx/tools/bash/bash_registry_content.py

@@ -0,0 +1,106 @@
+"""
+tools/bash/bash_registry_content.py — Bash cliArg 内容 deny/ask（compound 段级 · Phase D）
+
+职责：
+    Inner 段 1 对 Bash 按 AST permission_segments 评估内容级 deny/ask（对齐 CC compound 子命令优先 deny）。
+
+链路位置：
+    InnerPermissionChain._segment_1_2_global（Bash 分支）。
+"""
+
+from __future__ import annotations
+
+from langchain_agentx.tool_runtime.models import AuthorizationDecision
+from langchain_agentx.tool_runtime.permission_rule_matcher import (
+    RegistryPermissionMatcher,
+    _decision_from_legacy_glob,
+    _decision_from_rule,
+)
+from langchain_agentx.tool_runtime.permission_rules import (
+    PermissionRuleBehavior,
+    PermissionRuleRegistry,
+)
+from langchain_agentx.tools.bash.shell_rule_matching import match_shell_permission_rule
+
+
+def bash_permission_segments(command: str) -> list[str]:
+    from langchain_agentx.tools.bash.ast_security import BashAstAnalyzer
+
+    analysis = BashAstAnalyzer().analyze(command)
+    segments = [s.strip() for s in analysis.permission_segments if s and s.strip()]
+    return segments or [command.strip()]
+
+
+def _segment_content_decision(
+    segment: str,
+    registry: PermissionRuleRegistry,
+    behavior: PermissionRuleBehavior,
+) -> AuthorizationDecision | None:
+    matcher = RegistryPermissionMatcher(registry)
+    if behavior is PermissionRuleBehavior.DENY:
+        direct = matcher.match_deny("Bash", segment)
+    else:
+        direct = matcher.match_ask("Bash", segment)
+    if direct is not None:
+        return direct
+
+    legacy = registry.find_legacy_glob_match(segment, behavior)
+    if legacy is not None:
+        return _decision_from_legacy_glob(legacy, behavior=behavior.value)
+
+    for rule in registry.iter_rules(behavior):
+        if rule.tool_name != "Bash" or not rule.rule_content:
+            continue
+        if match_shell_permission_rule(rule.rule_content, segment, match_mode="prefix"):
+            return _decision_from_rule(rule, behavior=behavior.value)
+    return None
+
+
+def evaluate_bash_inner_content_rules(
+    command: str,
+    registry: PermissionRuleRegistry,
+) -> AuthorizationDecision | None:
+    """CC compound：段级 deny 优先 → full deny/ask → 段级 ask。"""
+    cmd = command.strip()
+    if not cmd:
+        return None
+
+    matcher = RegistryPermissionMatcher(registry)
+    full_deny = matcher.match_deny("Bash", cmd)
+    if full_deny is not None:
+        return full_deny
+
+    segments = bash_permission_segments(cmd)
+    if len(segments) > 1:
+        for segment in segments:
+            seg_deny = _segment_content_decision(
+                segment, registry, PermissionRuleBehavior.DENY
+            )
+            if seg_deny is not None:
+                return seg_deny
+
+    full_ask = matcher.match_ask("Bash", cmd)
+    if full_ask is not None:
+        return full_ask
+
+    if len(segments) > 1:
+        first_ask: AuthorizationDecision | None = None
+        for segment in segments:
+            seg_ask = _segment_content_decision(
+                segment, registry, PermissionRuleBehavior.ASK
+            )
+            if seg_ask is not None and first_ask is None:
+                first_ask = seg_ask
+        if first_ask is not None:
+            return first_ask
+
+    if len(segments) == 1:
+        return _segment_content_decision(
+            segments[0], registry, PermissionRuleBehavior.DENY
+        ) or _segment_content_decision(
+            segments[0], registry, PermissionRuleBehavior.ASK
+        )
+    return None
+
+
+__all__ = ["bash_permission_segments", "evaluate_bash_inner_content_rules"]

{langchain-agentx-python-2.2.9 → langchain-agentx-python-2.3.1}/langchain_agentx/tools/bash/command_allow_rules.py

@@ -10,9 +10,10 @@ tools/bash/command_allow_rules.py — Bash 内容级 allow 匹配（slash comman
 
 from __future__ import annotations
 
-import fnmatch
 from typing import TYPE_CHECKING
 
+from langchain_agentx.tools.bash.shell_rule_matching import match_shell_permission_rule
+
 from langchain_agentx.tool_runtime.models import AuthorizationDecision, ToolExecutionContext
 from langchain_agentx.tool_runtime.permission_context import get_command_bash_allow_rules
 from langchain_agentx.tool_runtime.permission_rule_matcher import RegistryPermissionMatcher
@@ -23,27 +24,24 @@ from langchain_agentx.tool_runtime.permission_rules import (
 )
 from langchain_agentx.tools.bash.read_only_validation import BashReadOnlyClassifier
 
+from langchain_agentx.tool_runtime.policy import PolicyEngine, resolve_default_policy_engine
+
 if TYPE_CHECKING:
     from langchain_agentx.tool_runtime.policy import DefaultPolicyEngine
 
 
 def bash_command_matches_allow_rule(command: str, rule_content: str) -> bool:
-    """CC prefix:* 与简单 fnmatch 子集。"""
+    """CC shellRuleMatching（prefix / wildcard / exact）。"""
     cmd = command.strip()
     pattern = rule_content.strip()
     if not cmd or not pattern:
         return False
-
-    if pattern.endswith(":*"):
-        prefix = pattern[:-2].rstrip()
-        if not prefix:
-            return False
-        return cmd == prefix or cmd.startswith(f"{prefix} ")
-
-    if "*" in pattern or "?" in pattern or "[" in pattern:
-        return fnmatch.fnmatch(cmd, pattern)
-
-    return cmd == pattern or cmd.startswith(f"{pattern} ")
+    return match_shell_permission_rule(
+        pattern,
+        cmd,
+        match_mode="prefix",
+        is_compound=False,
+    )
 
 
 def try_command_allow_decision(
@@ -84,13 +82,14 @@ def cliarg_bash_has_content_allow_without_bare_tool(
 def try_registry_bash_content_allow_decision(
     command: str,
     ctx: ToolExecutionContext,
-    policy_engine: DefaultPolicyEngine | None,
+    policy_engine: PolicyEngine | None,
 ) -> AuthorizationDecision | None:
     """cliArg/settings 等内容级 Bash allow（CC bashPermissions prefix allow，path 通过后）。"""
-    if policy_engine is None:
+    engine = resolve_default_policy_engine(policy_engine)
+    if engine is None:
         return None
     registry = build_permission_rule_registry(
-        policy_config=policy_engine._config,
+        policy_config=engine._config,
         session_store=ctx.session_store,
         workspace_root=ctx.workspace_root,
         agent_home_segment=ctx.agent_home_segment,
@@ -99,18 +98,65 @@ def try_registry_bash_content_allow_decision(
     return matcher.match_allow("Bash", command.strip())
 
 
+def registry_has_cliarg_bash_allow(registry: PermissionRuleRegistry) -> bool:
+    for rule in registry.iter_rules(PermissionRuleBehavior.ALLOW):
+        if rule.source_name == "cliArg" and rule.tool_name == "Bash":
+            return True
+    return False
+
+
+def promote_unscoped_bash_passthrough_to_ask(
+    decision: AuthorizationDecision,
+    *,
+    command: str,
+    ctx: ToolExecutionContext,
+    policy_engine: PolicyEngine | None,
+) -> AuthorizationDecision:
+    """无 cliArg Bash allow 时，write_roots 静默 allow → ask（对齐 CC passthrough）。"""
+    engine = resolve_default_policy_engine(policy_engine)
+    if engine is None or decision.behavior != "allow":
+        return decision
+    if _READ_ONLY_CLASSIFIER.classify(
+        command.strip(),
+        shell_ops_already_resolved=True,
+    ).is_read_only:
+        return decision
+    if decision.policy_id != "write_roots":
+        return decision
+    registry = build_permission_rule_registry(
+        policy_config=engine._config,
+        session_store=ctx.session_store,
+        workspace_root=ctx.workspace_root,
+        agent_home_segment=ctx.agent_home_segment,
+    )
+    if registry_has_cliarg_bash_allow(registry):
+        return decision
+    if cliarg_bash_has_content_allow_without_bare_tool(registry):
+        return decision
+    return AuthorizationDecision(
+        behavior="ask",
+        message=decision.message,
+        policy_id="bash_passthrough",
+        ask_prompt=(
+            decision.ask_prompt
+            or f"Allow Bash command?\n{command.strip()}"
+        ),
+    )
+
+
 def promote_unmatched_cliarg_content_only_allow_to_ask(
     decision: AuthorizationDecision,
     *,
     command: str,
     ctx: ToolExecutionContext,
-    policy_engine: DefaultPolicyEngine | None,
+    policy_engine: PolicyEngine | None,
 ) -> AuthorizationDecision:
     """roots 内 silent allow → ask（仅 cliArg 有 Bash(pattern) 且无裸 Bash 时）。"""
-    if policy_engine is None or decision.behavior != "allow" or decision.policy_id:
+    engine = resolve_default_policy_engine(policy_engine)
+    if engine is None or decision.behavior != "allow" or decision.policy_id:
         return decision
     registry = build_permission_rule_registry(
-        policy_config=policy_engine._config,
+        policy_config=engine._config,
         session_store=ctx.session_store,
         workspace_root=ctx.workspace_root,
         agent_home_segment=ctx.agent_home_segment,

langchain-agentx-python-2.3.1/langchain_agentx/tools/bash/shell_rule_matching.py

@@ -0,0 +1,143 @@
+"""
+tools/bash/shell_rule_matching.py — CC shellRuleMatching.ts 对齐（Phase D）
+
+职责：
+    prefix :*、wildcard（含 \\* / \\\\ 转义）、``git *`` 尾 wildcard 可选参数语义。
+
+链路位置：
+    command_allow_rules.bash_command_matches_permission_rule。
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from typing import Literal
+
+_ESCAPED_STAR = "\x00ESCAPED_STAR\x00"
+_ESCAPED_BACKSLASH = "\x00ESCAPED_BACKSLASH\x00"
+
+
+def permission_rule_extract_prefix(permission_rule: str) -> str | None:
+    m = re.match(r"^(.+):\*$", permission_rule.strip())
+    return m.group(1) if m else None
+
+
+def has_wildcards(pattern: str) -> bool:
+    text = pattern.strip()
+    if text.endswith(":*"):
+        return False
+    i = 0
+    while i < len(text):
+        if text[i] == "*":
+            backslashes = 0
+            j = i - 1
+            while j >= 0 and text[j] == "\\":
+                backslashes += 1
+                j -= 1
+            if backslashes % 2 == 0:
+                return True
+        i += 1
+    return False
+
+
+def match_wildcard_pattern(
+    pattern: str,
+    command: str,
+    *,
+    case_insensitive: bool = False,
+) -> bool:
+    """对齐 CC ``matchWildcardPattern``（含 trailing `` *`` → optional args）。"""
+    trimmed = pattern.strip()
+    processed = ""
+    i = 0
+    while i < len(trimmed):
+        ch = trimmed[i]
+        if ch == "\\" and i + 1 < len(trimmed):
+            nxt = trimmed[i + 1]
+            if nxt == "*":
+                processed += _ESCAPED_STAR
+                i += 2
+                continue
+            if nxt == "\\":
+                processed += _ESCAPED_BACKSLASH
+                i += 2
+                continue
+        processed += ch
+        i += 1
+
+    escaped = re.sub(r"[.+?^${}()|\[\]\\'\"]", r"\\\g<0>", processed)
+    with_wildcards = escaped.replace("*", ".*")
+    regex_body = with_wildcards.replace(_ESCAPED_STAR, r"\*").replace(
+        _ESCAPED_BACKSLASH, r"\\"
+    )
+
+    unescaped_stars = processed.count("*")
+    if regex_body.endswith(" .*") and unescaped_stars == 1:
+        regex_body = regex_body[:-3] + "( .*)?"
+
+    flags = re.DOTALL
+    if case_insensitive:
+        flags |= re.IGNORECASE
+    return re.fullmatch(f"^{regex_body}$", command, flags=flags) is not None
+
+
+@dataclass(frozen=True)
+class ShellPermissionRule:
+    kind: Literal["exact", "prefix", "wildcard"]
+    value: str
+
+
+def parse_permission_rule(rule_content: str) -> ShellPermissionRule:
+    text = rule_content.strip()
+    prefix = permission_rule_extract_prefix(text)
+    if prefix is not None:
+        return ShellPermissionRule(kind="prefix", value=prefix)
+    if has_wildcards(text):
+        return ShellPermissionRule(kind="wildcard", value=text)
+    return ShellPermissionRule(kind="exact", value=text)
+
+
+def match_shell_permission_rule(
+    rule_content: str,
+    command: str,
+    *,
+    match_mode: Literal["exact", "prefix"] = "prefix",
+    is_compound: bool = False,
+) -> bool:
+    """单条 Bash 内容规则对单段 command 的匹配（CC ``bashPermissionRule`` 分支）。"""
+    cmd = command.strip()
+    if not cmd:
+        return False
+    parsed = parse_permission_rule(rule_content)
+
+    if parsed.kind == "exact":
+        return parsed.value == cmd
+
+    if parsed.kind == "prefix":
+        if match_mode == "exact":
+            return parsed.value == cmd
+        if is_compound:
+            return False
+        prefix = parsed.value
+        if cmd == prefix:
+            return True
+        if cmd.startswith(prefix + " "):
+            return True
+        xargs_prefix = "xargs " + prefix
+        if cmd == xargs_prefix or cmd.startswith(xargs_prefix + " "):
+            return True
+        return False
+
+    if match_mode == "exact":
+        return False
+    if is_compound:
+        return False
+    return match_wildcard_pattern(parsed.value, cmd)
+
+
+__all__ = [
+    "match_shell_permission_rule",
+    "match_wildcard_pattern",
+    "parse_permission_rule",
+]

{langchain-agentx-python-2.2.9 → langchain-agentx-python-2.3.1}/langchain_agentx/tools/bash/tool.py

@@ -1034,7 +1034,17 @@ class BashRuntimeTool(RuntimeTool):
             return decision
 
         final = self._authorize_sed_segment(command=command, ctx=ctx, cwd=cwd) or decision
-        return promote_unmatched_cliarg_content_only_allow_to_ask(
+        final = promote_unmatched_cliarg_content_only_allow_to_ask(
+            final,
+            command=command,
+            ctx=ctx,
+            policy_engine=self._policy,
+        )
+        from langchain_agentx.tools.bash.command_allow_rules import (
+            promote_unscoped_bash_passthrough_to_ask,
+        )
+
+        return promote_unscoped_bash_passthrough_to_ask(
             final,
             command=command,
             ctx=ctx,