cade-cli 0.20.7__tar.gz → 0.21.0__tar.gz

{cade_cli-0.20.7 → cade_cli-0.21.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: cade-cli
-Version: 0.20.7
+Version: 0.21.0
 Summary: Cade - The CLI Agent from Arcade.dev (install: curl -fsSL https://arcadeagent.dev/install | sh)
 Project-URL: Homepage, https://arcade.dev
 Project-URL: Documentation, https://arcadeagent.dev/docs

{cade_cli-0.20.7 → cade_cli-0.21.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cade-cli"
-version = "0.20.7"
+version = "0.21.0"
 description = "Cade - The CLI Agent from Arcade.dev (install: curl -fsSL https://arcadeagent.dev/install | sh)"
 readme = "README.md"
 requires-python = ">=3.11"

{cade_cli-0.20.7 → cade_cli-0.21.0}/src/cade_mcp_local/_metadata.py

@@ -59,6 +59,18 @@ DELETE_META = _meta(
 )
 """Removes a local resource. Destructive."""
 
+READ_OR_CREATE_META = _meta(
+    operations=[Operation.READ, Operation.CREATE], read_only=False, idempotent=False
+)
+"""Action-dispatching tool whose actions either read or create (e.g. Agent)."""
+
+CRUD_META = _meta(
+    operations=[Operation.CREATE, Operation.READ, Operation.UPDATE, Operation.DELETE],
+    read_only=False,
+    destructive=True,
+)
+"""One tool covering a resource's whole lifecycle via an ``action`` argument (e.g. Task)."""
+
 OPAQUE_META = ToolMetadata(
     classification=Classification(service_domains=None),
     behavior=Behavior(
@@ -76,6 +88,8 @@ OPAQUE_META = ToolMetadata(
 __all__ = (
     "CREATE_META",
     "CREATE_OR_UPDATE_META",
+    "CRUD_META",
+    "READ_OR_CREATE_META",
     "DELETE_META",
     "OPAQUE_META",
     "READ_META",

{cade_cli-0.20.7 → cade_cli-0.21.0}/src/cade_mcp_local/sandbox.py

@@ -68,6 +68,29 @@ def sandbox_available() -> bool:
     return backend_name() is not None
 
 
+def command_sandbox_required() -> bool:
+    """Whether shell commands must run inside an OS sandbox.
+
+    The global path-restrictions kill switch also lifts the command sandbox:
+    it is the existing single "I know what I'm doing" toggle, and holding
+    bash to a tighter boundary than the file tools would only confuse.
+    """
+    from cade_mcp_local.config import path_restrictions_enabled
+
+    if sandbox_disabled_by_env():
+        return False
+    return path_restrictions_enabled()
+
+
+def shell_usable() -> bool:
+    """True when ``Bash`` / ``ScratchBash`` can run on this host at all.
+
+    They refuse (fail closed) when a sandbox is required but no backend is
+    installed; this is the same decision, made without running a command.
+    """
+    return not command_sandbox_required() or sandbox_available()
+
+
 def wrap_command(script: str, spec: SandboxSpec) -> tuple[list[str], str | None]:
     """Return (argv, cleanup_path) running ``script`` inside the OS sandbox.
 
@@ -265,9 +288,11 @@ __all__ = [
     "SANDBOX_DISABLE_ENV",
     "SandboxSpec",
     "backend_name",
+    "command_sandbox_required",
     "describe_backend",
     "prepare_spec",
     "sandbox_available",
     "sandbox_disabled_by_env",
+    "shell_usable",
     "wrap_command",
 ]

{cade_cli-0.20.7 → cade_cli-0.21.0}/src/cade_mcp_local/server.py

@@ -19,9 +19,7 @@ patch_frozen_return_detection()
 
 from cade_mcp_local.resources import register_resources  # noqa: E402
 from cade_mcp_local.tools import (  # noqa: E402
-    agent_list_tool,
-    agent_send_tool,
-    agent_spawn_tool,
+    agent_tool,
     ask_user_question_tool,
     bash_tool,
     edit_tool,
@@ -33,10 +31,7 @@ from cade_mcp_local.tools import (  # noqa: E402
     retrieve_tool_result_tool,
     scratch_bash_tool,
     search_tool,
-    task_create_tool,
-    task_delete_tool,
-    task_list_tool,
-    task_update_tool,
+    task_tool,
     tool_schema_tool,
     web_fetch_tool,
     web_search_tool,
@@ -52,14 +47,14 @@ is running. Use these tools when you need to:
 - Search code in the local project directory
 - Execute shell commands or bash scripts locally
 - Check git status, diff, log, or branches of the local repository
-- File-backed tasks for durable multi-step work (TaskCreate, TaskList,
-  TaskUpdate, TaskDelete) — the host registers them as Local_* names
+- File-backed tasks for durable multi-step work (Task with action
+  create/list/get/update/delete) — the host registers it as Local_Task
 - PushNotification to inject a structured notice into the agent context at the next
   tool boundary
-- AgentSend / AgentList to coordinate with other agents the user has linked to this
-  one (ACL-gated; delivered to the target agent's inbox)
-- AgentSpawn to delegate a self-contained sub-task to a fresh child agent and get
-  back just its result (requires this agent to allow spawning)
+- Agent to coordinate with other agents: send to / list agents the user has
+  linked to this one (ACL-gated; delivered to the target agent's inbox), or
+  spawn a child agent for a self-contained sub-task and get back just its
+  result (requires this agent to allow spawning)
 - AskUserQuestion when you need structured clarification from the user (host:
   Local_AskUserQuestion)
 - WebFetch to read an external URL (Firecrawl via Arcade by default, httpx
@@ -132,19 +127,14 @@ def create_app() -> MCPApp:
     app.add_tool(tool_schema_tool)
 
     # Task coordination (file-backed task store)
-    app.add_tool(task_create_tool)
-    app.add_tool(task_list_tool)
-    app.add_tool(task_update_tool)
-    app.add_tool(task_delete_tool)
+    app.add_tool(task_tool)
 
     # Notifications (inject XML into context at next tool boundary)
     app.add_tool(push_notification_tool)
 
-    # Cross-agent coordination (ACL-gated; delivers to another agent's inbox)
-    app.add_tool(agent_send_tool)
-    app.add_tool(agent_list_tool)
-    # Spawn an ephemeral child task-agent (opt-in via the agent's allow_spawn)
-    app.add_tool(agent_spawn_tool)
+    # Cross-agent coordination: send/list (ACL-gated inbox delivery) and
+    # spawn (ephemeral child task-agent, opt-in via the agent's allow_spawn)
+    app.add_tool(agent_tool)
 
     # Structured clarification question for the user
     app.add_tool(ask_user_question_tool)

{cade_cli-0.20.7 → cade_cli-0.21.0}/src/cade_mcp_local/tools/__init__.py

@@ -6,7 +6,7 @@ commands on the same machine as the running cade process.
 """
 
 from cade_mcp_local.tools.access import request_access_tool
-from cade_mcp_local.tools.agents import agent_list_tool, agent_send_tool, agent_spawn_tool
+from cade_mcp_local.tools.agents import agent_tool
 from cade_mcp_local.tools.filesystem import (
     edit_tool,
     list_files_tool,
@@ -24,12 +24,7 @@ from cade_mcp_local.tools.results import retrieve_tool_result_tool
 from cade_mcp_local.tools.schemas import tool_schema_tool
 from cade_mcp_local.tools.search import search_tool
 from cade_mcp_local.tools.shell import bash_tool, scratch_bash_tool
-from cade_mcp_local.tools.tasks import (
-    task_create_tool,
-    task_delete_tool,
-    task_list_tool,
-    task_update_tool,
-)
+from cade_mcp_local.tools.tasks import task_tool
 from cade_mcp_local.tools.web_fetch import web_fetch_tool
 from cade_mcp_local.tools.web_search import web_search_tool
 
@@ -54,16 +49,11 @@ __all__ = [
     # Tool Schemas
     "tool_schema_tool",
     # Tasks
-    "task_create_tool",
-    "task_list_tool",
-    "task_update_tool",
-    "task_delete_tool",
+    "task_tool",
     # Notifications
     "push_notification_tool",
     # Cross-agent coordination
-    "agent_send_tool",
-    "agent_list_tool",
-    "agent_spawn_tool",
+    "agent_tool",
     # Interactive
     "ask_user_question_tool",
     # Web

{cade_cli-0.20.7 → cade_cli-0.21.0}/src/cade_mcp_local/tools/agents.py

@@ -1,4 +1,10 @@
-"""MCP tools for cross-agent coordination.
+"""MCP tool for cross-agent coordination.
+
+One ``Agent`` tool with an ``action`` (send | list | spawn), replacing the
+former AgentSend / AgentList / AgentSpawn tools; the host's composite tool
+manager rewrites calls to those legacy names, and trims the ``action`` enum
+to the actions this agent can actually use (see
+``cadecoder.tools.manager.surface``).
 
 Lets the model address other agents the user has explicitly linked. Delivery
 rides the durable per-agent inbox (so the message survives until the target
@@ -8,12 +14,13 @@ a shared channel. The default is isolation.
 """
 
 import logging
+from enum import Enum
 from typing import Annotated, Any
 
 from arcade_mcp_server import Context, tool
 from typing_extensions import TypedDict
 
-from cade_mcp_local._metadata import CREATE_META, READ_META
+from cade_mcp_local._metadata import READ_OR_CREATE_META
 from cade_mcp_local.errors import InvalidInputError
 from cadecoder.core import agent as agent_mod
 from cadecoder.core import comms as comms_mod
@@ -23,23 +30,28 @@ from cadecoder.core.paths import get_paths
 log = logging.getLogger(__name__)
 
 
-class AgentSendOutput(TypedDict):
+class AgentAction(str, Enum):
+    """Agent coordination operation."""
+
+    SEND = "send"
+    LIST = "list"
+    SPAWN = "spawn"
+
+
+class AgentOutput(TypedDict, total=False):
+    # send
     delivered: bool
     target: str
     target_id: str
-
-
-class AgentSpawnOutput(TypedDict):
+    # list
+    agents: list[dict[str, Any]]
+    count: int
+    # spawn
     agent: str
     id: str
     result: str
 
 
-class AgentListOutput(TypedDict):
-    agents: list[dict[str, Any]]
-    count: int
-
-
 def _agent_from_request_meta() -> str | None:
     """Per-request acting agent from MCP ``_meta['cade/agent']``, if the host set it.
 
@@ -65,20 +77,36 @@ def _current_agent_name() -> str:
 
 
 @tool(
-    name="AgentSend",
+    name="Agent",
     desc=(
-        "Send a message to another agent's inbox. Only works for agents a user "
-        "has linked to this one (via `cade agent link` or a shared channel); otherwise "
-        "the send is refused. The message is delivered at the target agent's next "
-        "turn. Use AgentList first to see who you can reach."
+        "Coordinate with other agents. send: message an agent a user has linked "
+        "to this one (via `cade agent link` or a shared channel), delivered at its "
+        "next turn. list: agents you can message. spawn: delegate a self-contained "
+        "sub-task to a fresh child agent in its own context and block until it "
+        "returns just the result."
     ),
-    metadata=CREATE_META,
+    metadata=READ_OR_CREATE_META,
 )
-async def agent_send_tool(
+async def agent_tool(
     context: Context,
-    target: Annotated[str, "Target agent name, id, or unique id prefix."],
-    message: Annotated[str, "Message to deliver to the target agent."],
-) -> Annotated[AgentSendOutput, "Delivery result."]:
+    action: Annotated[AgentAction, "Coordination operation."],
+    target: Annotated[str, "[send] Target agent name, id, or unique id prefix."] = "",
+    message: Annotated[str, "[send] Message to deliver to the target agent."] = "",
+    task: Annotated[str, "[spawn] The self-contained sub-task for the child agent."] = "",
+) -> Annotated[AgentOutput, "Coordination result."]:
+    """Dispatch an agent coordination operation."""
+    if action == AgentAction.SEND:
+        return await _send(target, message)
+    if action == AgentAction.LIST:
+        return _list()
+    if action == AgentAction.SPAWN:
+        return await _spawn(task)
+    raise InvalidInputError("action", f"Unknown action: {action}")
+
+
+async def _send(target: str, message: str) -> AgentOutput:
+    if not target.strip():
+        raise InvalidInputError("target", "required for send")
     if not message.strip():
         raise InvalidInputError("message", "cannot be empty")
     sender = _current_agent_name()
@@ -122,45 +150,7 @@ async def agent_send_tool(
     return {"delivered": True, "target": target_agent.name, "target_id": target_agent.id}
 
 
-@tool(
-    name="AgentSpawn",
-    desc=(
-        "Delegate a focused sub-task to a fresh child agent that runs in its own "
-        "process and context, returning just the result (keeps your context "
-        "clean). Only works if this agent was created with --allow-spawn. Blocks "
-        "until the child finishes."
-    ),
-    metadata=CREATE_META,
-)
-async def agent_spawn_tool(
-    context: Context,
-    task: Annotated[str, "The self-contained sub-task for the child agent."],
-) -> Annotated[AgentSpawnOutput, "The child agent and its result."]:
-    from cadecoder.core.spawn import SpawnError, spawn_task_agent
-
-    if not task.strip():
-        raise InvalidInputError("task", "cannot be empty")
-    # Resolve the parent from the per-request agent identity so the child is
-    # attributed to the calling agent, not this subprocess's env/state.
-    parent_name = _agent_from_request_meta()
-    parent = agent_mod.resolve(parent_name) if parent_name else None
-    try:
-        return await spawn_task_agent(task, parent=parent)  # type: ignore[return-value]
-    except SpawnError as e:
-        raise InvalidInputError("task", str(e)) from e
-
-
-@tool(
-    name="AgentList",
-    desc=(
-        "List the agents you can message — i.e. agents a user has linked to this "
-        "one through a shared channel. Returns an empty list when you are isolated."
-    ),
-    metadata=READ_META,
-)
-def agent_list_tool(
-    context: Context,
-) -> Annotated[AgentListOutput, "Reachable agents."]:
+def _list() -> AgentOutput:
     sender = _current_agent_name()
     reachable: list[dict[str, Any]] = []
     for candidate in agent_mod.list_agents():
@@ -175,3 +165,18 @@ def agent_list_tool(
                 }
             )
     return {"agents": reachable, "count": len(reachable)}
+
+
+async def _spawn(task: str) -> AgentOutput:
+    from cadecoder.core.spawn import SpawnError, spawn_task_agent
+
+    if not task.strip():
+        raise InvalidInputError("task", "cannot be empty")
+    # Resolve the parent from the per-request agent identity so the child is
+    # attributed to the calling agent, not this subprocess's env/state.
+    parent_name = _agent_from_request_meta()
+    parent = agent_mod.resolve(parent_name) if parent_name else None
+    try:
+        return await spawn_task_agent(task, parent=parent)  # type: ignore[return-value]
+    except SpawnError as e:
+        raise InvalidInputError("task", str(e)) from e

{cade_cli-0.20.7 → cade_cli-0.21.0}/src/cade_mcp_local/tools/shell.py

@@ -33,7 +33,6 @@ from cade_mcp_local._metadata import OPAQUE_META
 from cade_mcp_local.config import (
     DEFAULT_TIMEOUT,
     get_project_root,
-    path_restrictions_enabled,
 )
 from cade_mcp_local.errors import (
     CommandExecutionError,
@@ -42,10 +41,10 @@ from cade_mcp_local.errors import (
 )
 from cade_mcp_local.grants import current_grant_set, ensure_scratch_dir
 from cade_mcp_local.sandbox import (
+    command_sandbox_required,
     describe_backend,
     prepare_spec,
     sandbox_available,
-    sandbox_disabled_by_env,
     sandbox_tmpdir,
     wrap_command,
 )
@@ -122,17 +121,8 @@ def _check_dangerous(script: str) -> str | None:
 
 
 def _sandboxing_active() -> bool:
-    """Whether per-command OS sandboxing should be applied.
-
-    The global path-restrictions kill switch also lifts the command sandbox:
-    it is the existing single "I know what I'm doing" toggle, and holding
-    bash to a tighter boundary than the file tools would only confuse.
-    """
-    if sandbox_disabled_by_env():
-        return False
-    if not path_restrictions_enabled():
-        return False
-    return True
+    """Whether per-command OS sandboxing should be applied."""
+    return command_sandbox_required()
 
 
 def _scratch_network_enabled() -> bool:

cade_cli-0.21.0/src/cade_mcp_local/tools/tasks.py

@@ -0,0 +1,164 @@
+"""MCP tool for LLM-driven file-based task management.
+
+One ``Task`` tool with an ``action`` (create | list | get | update | delete)
+so the model can coordinate multi-step work via the active context's
+persistent task store. It replaces the former TaskCreate / TaskList /
+TaskUpdate / TaskDelete tools, which shared most of their parameters; the
+host's composite tool manager rewrites calls to those legacy names.
+"""
+
+import logging
+from enum import Enum
+from typing import Annotated, Any
+
+from arcade_mcp_server import Context, tool
+from typing_extensions import TypedDict
+
+from cade_mcp_local._metadata import CRUD_META
+from cade_mcp_local.errors import InvalidInputError
+from cadecoder.tasks import TaskStatus, TaskStore
+
+log = logging.getLogger(__name__)
+
+
+class TaskStatusFilter(str, Enum):
+    """TaskStatus values plus an ANY sentinel for optional status params."""
+
+    ANY = ""
+    PENDING = "pending"
+    IN_PROGRESS = "in_progress"
+    COMPLETED = "completed"
+    FAILED = "failed"
+    BLOCKED = "blocked"
+    CANCELLED = "cancelled"
+
+
+def _status_enum(value: TaskStatusFilter | str) -> TaskStatus:
+    raw = value.value if isinstance(value, TaskStatusFilter) else str(value)
+    try:
+        return TaskStatus(raw)
+    except ValueError as e:
+        valid = ", ".join(s.value for s in TaskStatus)
+        raise InvalidInputError("status", f"must be one of {valid}") from e
+
+
+class TaskAction(str, Enum):
+    """Task operation to perform."""
+
+    CREATE = "create"
+    LIST = "list"
+    GET = "get"
+    UPDATE = "update"
+    DELETE = "delete"
+
+
+class TaskOutput(TypedDict, total=False):
+    task: dict[str, Any]
+    tasks: list[dict[str, Any]]
+    count: int
+    found: bool
+    deleted: bool
+    task_id: str
+
+
+@tool(
+    name="Task",
+    desc=(
+        "Durable task store for multi-step work; progress survives sessions and "
+        "is visible to the user. create | list | get | update | delete. "
+        "Setting status='completed' unblocks dependent tasks."
+    ),
+    metadata=CRUD_META,
+)
+def task_tool(
+    context: Context,
+    action: Annotated[TaskAction, "Task operation."],
+    task_id: Annotated[str, "[get|update|delete] Task ID."] = "",
+    subject: Annotated[str, "[create] Imperative one-line summary, e.g. 'Fix auth race'."] = "",
+    description: Annotated[str, "[create] Optional longer explanation."] = "",
+    active_form: Annotated[
+        str, "[create] Present-continuous phrasing for spinners, e.g. 'Fixing auth race'."
+    ] = "",
+    blocks: Annotated[
+        list[str], "[create] IDs of tasks that cannot start until this completes."
+    ] = [],  # noqa: B006
+    blocked_by: Annotated[
+        list[str], "[create] IDs of tasks that must complete before this can start."
+    ] = [],  # noqa: B006
+    status: Annotated[
+        TaskStatusFilter, "[list] Filter by status. [update] New status. ANY = none."
+    ] = TaskStatusFilter.ANY,
+    owner: Annotated[str, "[list] Filter by owner. [update] New owner/agent label."] = "",
+    result: Annotated[str, "[update] Result summary for completed or failed tasks."] = "",
+    scope: Annotated[str, "Task scope (team/session). Empty = default."] = "",
+) -> Annotated[TaskOutput, "Task operation result."]:
+    """Dispatch a task-store operation."""
+    store = TaskStore(scope=scope or None)
+    if action == TaskAction.CREATE:
+        return _create(store, subject, description, active_form, blocks, blocked_by)
+    if action == TaskAction.LIST:
+        return _list(store, status, owner)
+    if action == TaskAction.GET:
+        task = store.get(_require_id(task_id))
+        if task is None:
+            return {"found": False, "task_id": task_id}
+        return {"found": True, "task": task.model_dump(mode="json")}
+    if action == TaskAction.UPDATE:
+        return _update(store, _require_id(task_id), status, owner, result)
+    if action == TaskAction.DELETE:
+        return {"deleted": store.delete(_require_id(task_id)), "task_id": task_id}
+    raise InvalidInputError("action", f"Unknown action: {action}")
+
+
+def _require_id(task_id: str) -> str:
+    if not task_id.strip():
+        raise InvalidInputError("task_id", "required for this action")
+    return task_id
+
+
+def _create(
+    store: TaskStore,
+    subject: str,
+    description: str,
+    active_form: str,
+    blocks: list[str],
+    blocked_by: list[str],
+) -> TaskOutput:
+    if not subject.strip():
+        raise InvalidInputError("subject", "cannot be empty")
+    task = store.create(
+        subject=subject,
+        description=description,
+        active_form=active_form or None,
+        blocks=list(blocks or []),
+        blocked_by=list(blocked_by or []),
+    )
+    return {"task": task.model_dump(mode="json")}
+
+
+def _list(store: TaskStore, status: TaskStatusFilter | str, owner: str) -> TaskOutput:
+    status_enum = _status_enum(status) if status and status != TaskStatusFilter.ANY else None
+    tasks = store.list_all(status=status_enum, owner=owner or None)
+    return {"tasks": [t.model_dump(mode="json") for t in tasks], "count": len(tasks)}
+
+
+def _update(
+    store: TaskStore,
+    task_id: str,
+    status: TaskStatusFilter | str,
+    owner: str,
+    result: str,
+) -> TaskOutput:
+    updates: dict[str, Any] = {}
+    if status and status != TaskStatusFilter.ANY:
+        updates["status"] = _status_enum(status)
+    if owner:
+        updates["owner"] = owner
+    if result:
+        updates["result"] = result
+    if not updates:
+        raise InvalidInputError("updates", "provide at least one of status/owner/result")
+    task = store.update(task_id, **updates)
+    if task is None:
+        return {"found": False, "task_id": task_id}
+    return {"found": True, "task": task.model_dump(mode="json")}

{cade_cli-0.20.7 → cade_cli-0.21.0}/src/cade_mcp_local/utils.py

@@ -55,17 +55,22 @@ def resolve_path(
         # always-granted scratch dir, and any runtime grants are all legal
         # roots. With no grants file published this reduces to exactly the
         # old single-root check.
-        from cade_mcp_local.grants import current_grant_set
+        from cade_mcp_local.grants import current_grant_set, grants_file_path
 
         grant_set = current_grant_set()
         if not grant_set.contains(resolved):
             from cade_mcp_local.errors import PathSecurityError
 
+            # Runtime grants exist only where a grants file is published (the
+            # daemon); elsewhere Local_RequestAccess is not advertised at all.
+            if grants_file_path() is not None:
+                remedy = "ask via Local_RequestAccess or have the operator run `/grant`"
+            else:
+                remedy = "ask the user to start cade from a directory that contains it"
             raise PathSecurityError(
                 str(path_str),
                 f"path resolves outside the granted filesystem scopes "
-                f"({grant_set.describe()}); ask via Local_RequestAccess or "
-                f"have the operator run `/grant`",
+                f"({grant_set.describe()}); {remedy}",
             )
 
     return resolved

{cade_cli-0.20.7 → cade_cli-0.21.0}/src/cadecoder/ai/prompts.py

@@ -131,7 +131,7 @@ DATA_DIRECTORY: {runtime.context_data_dir}
   └─ Database: {db_path} — do not read or modify directly
   └─ Logs: {log_path} — diagnostic only; do not alter
   └─ Tool-managed writable areas (use only Local_* tools, not ad-hoc file edits):
-      tasks/ — Local_TaskCreate, Local_TaskList, Local_TaskUpdate, Local_TaskDelete
+      tasks/ — Local_Task
 
 CONFIG_DIRECTORY: {runtime.paths.config_dir}
   └─ Contains Cade settings. Secrets are referenced, not stored inline by default.
@@ -201,7 +201,7 @@ Signals: "[TASK_COMPLETE]" | "[CONTINUE]" | "[NEED_USER_INPUT]"
 - Match existing code patterns when editing.
 
 === LOCAL COORDINATION ===
-- Durable work across turns: Local_TaskCreate, Local_TaskList (filter by id for single fetch), Local_TaskUpdate, Local_TaskDelete.
+- Durable work across turns: Local_Task (action=create|list|get|update|delete).
 - User-visible nudge on the next tool boundary: Local_PushNotification.
 
 Tools: