code-puppy-core-plugins 0.0.52__tar.gz → 0.0.54__tar.gz

{code_puppy_core_plugins-0.0.52 → code_puppy_core_plugins-0.0.54}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: code-puppy-core-plugins
-Version: 0.0.52
+Version: 0.0.54
 Summary: Official plugin bundle for Code Puppy
 Project-URL: Repository, https://github.com/mpfaffenberger/code_puppy_core_plugins
 Project-URL: Homepage, https://github.com/mpfaffenberger/code_puppy_core_plugins

{code_puppy_core_plugins-0.0.52 → code_puppy_core_plugins-0.0.54}/code_puppy_core_plugins/background_agents/register_callbacks.py

@@ -3,6 +3,7 @@
 import asyncio
 import inspect
 import json
+import time
 from uuid import uuid4
 
 from pydantic_ai import RunContext
@@ -13,6 +14,26 @@ _tasks: dict[str, asyncio.Task] = {}
 _sessions: set[str] = set()
 
 
+async def _publish_boundary(agent_name, prompt, result, started_at):
+    """Publish the tool-equivalent completion signal for a detached run.
+
+    ``_invoke_agent_impl`` is called directly here (not via pydantic-ai's tool
+    wrapper), so nobody fires ``post_tool_call`` for the sub-agent itself.
+    The subagent_panel relies on that event to retire the live row at the
+    run's own boundary -- without it a background row would sit on its last
+    streamed status forever (it now outlives the main turn). Mirrors /fork.
+    """
+    from code_puppy.callbacks import on_post_tool_call
+
+    await on_post_tool_call(
+        "invoke_agent",
+        {"agent_name": agent_name, "prompt": prompt},
+        result,
+        (time.monotonic() - started_at) * 1000,
+        {"detached": True},
+    )
+
+
 async def _run(task_id, owner, context, agent_name, prompt, session_id):
     from code_puppy.agent_completion_inbox import deliver_completion
     from code_puppy.tools.subagent_invocation import _invoke_agent_impl
@@ -24,6 +45,8 @@ async def _run(task_id, owner, context, agent_name, prompt, session_id):
     if "background" in inspect.signature(_invoke_agent_impl).parameters:
         extra["background"] = True
 
+    started_at = time.monotonic()
+    result = None
     try:
         result = await _invoke_agent_impl(
             context=context,
@@ -41,6 +64,12 @@ async def _run(task_id, owner, context, agent_name, prompt, session_id):
     finally:
         _tasks.pop(task_id, None)
 
+    if result is not None:
+        try:
+            await _publish_boundary(agent_name, prompt, result, started_at)
+        except Exception:
+            pass  # a panel hiccup must never eat the completion report
+
     # A fixed prefix keeps output out of the REPL's command routing. JSON
     # separates provenance from untrusted child output; no attachment expansion.
     deliver_completion(

code_puppy_core_plugins-0.0.54/code_puppy_core_plugins/mcp_binding_prompt/README.md

@@ -0,0 +1,32 @@
+# mcp_binding_prompt
+
+Three MCP-install affordances layered over core at `startup`, no core edits:
+
+1. **Synchronous post-install binding prompt.** Core's installers call
+   `mcp_binding_menu.prompt_bind_after_install_sync(server_name)` inside a
+   `try/except ImportError` -- without this plugin the call silently no-ops.
+   `register_callbacks.py` provides that function: it runs the existing
+   `build_post_install_menu` inline in the installer's foreground (inside
+   `menu_session()`, with `set_awaiting_user_input` toggled) instead of
+   scheduling a competing UI task.
+2. **`/mcp install` is custom-JSON only** (`custom_install.py`). The bundled
+   marketplace is gone: `InstallCommand.execute` opens the custom server form
+   directly, `SearchCommand.execute` explains the removal, `HelpCommand.execute`
+   prints the trimmed help, and `MCPCompleter` stops advertising `search`.
+3. **HTTP form fields** (`http_form.py`). When the custom form's type is
+   `http`, `run_form_flow`'s `menu_factory` is swapped for `HTTPMenu`, which
+   exposes URL / auth (none, OAuth, headers) / headers as proper fields on
+   top of the raw JSON blob. Saving validates the URL (scheme, host, no
+   embedded credentials or whitespace), the headers (string keys/values, no
+   CRLF), and runs the config through core's `http_auth` transport policy.
+   Malformed advanced JSON falls back to the core menu so it stays editable.
+   Switching type to `http` with an untouched example seeds a minimal config.
+
+All strings go through `code_puppy.i18n` (`mcp.custom_install.*`,
+`mcp.http_form.*`); the keys live in core's `en-US` catalog.
+
+## Notes
+
+- Every patch is idempotent (`_custom_json_install` / `_http_fields` markers).
+- `HelpCommand.execute` is fully replaced, so new core `/mcp` subcommands must
+  also be added to the `mcp.custom_install.help` catalog string.

code_puppy_core_plugins-0.0.54/code_puppy_core_plugins/mcp_binding_prompt/__init__.py

@@ -0,0 +1 @@
+"""Restore the synchronous post-install MCP binding prompt."""

code_puppy_core_plugins-0.0.54/code_puppy_core_plugins/mcp_binding_prompt/custom_install.py

@@ -0,0 +1,58 @@
+"""Custom JSON replaces the bundled MCP marketplace at the command boundary."""
+
+import logging
+from functools import wraps
+
+from code_puppy.i18n import t
+from code_puppy.messaging import emit_error, emit_info
+
+logger = logging.getLogger(__name__)
+
+
+def install_custom(command, args, group_id=None):
+    """Keep the existing form's save, cancel, and binding semantics."""
+    from code_puppy.command_line.mcp.custom_server_form import run_custom_server_form
+
+    try:
+        run_custom_server_form(command.manager)
+    except (KeyboardInterrupt, EOFError):
+        return
+    except Exception as exc:
+        logger.exception("Custom MCP installation failed")
+        emit_error(
+            t("mcp.custom_install.failed", error=str(exc)), message_group=group_id
+        )
+
+
+def marketplace_removed(command, args, group_id=None):
+    emit_info(t("mcp.custom_install.no_marketplace"), message_group=group_id)
+
+
+def custom_help(command, args, group_id=None):
+    emit_info(t("mcp.custom_install.help"), message_group=group_id)
+
+
+def install_routes():
+    # Known slash commands do not reach custom_command. Install the override
+    # at startup, leaving core command_line files and existing instances intact.
+    from code_puppy.command_line.mcp.install_command import InstallCommand
+    from code_puppy.command_line.mcp.search_command import SearchCommand
+    from code_puppy.command_line.mcp.help_command import HelpCommand
+    from code_puppy.command_line.mcp_completion import MCPCompleter
+
+    original = MCPCompleter.__init__
+    if getattr(original, "_custom_json_install", False):
+        return  # already routed -- never double-wrap the completer
+    InstallCommand.execute = install_custom
+    SearchCommand.execute = marketplace_removed
+    HelpCommand.execute = custom_help
+
+    @wraps(original)
+    def initialize(completer, *args, **kwargs):
+        original(completer, *args, **kwargs)
+        for commands in (completer.general_subcommands, completer.all_subcommands):
+            commands.pop("search", None)
+            commands["install"] = t("mcp.custom_install.description")
+
+    initialize._custom_json_install = True
+    MCPCompleter.__init__ = initialize

code_puppy_core_plugins-0.0.54/code_puppy_core_plugins/mcp_binding_prompt/http_form.py

@@ -0,0 +1,223 @@
+"""HTTP fields layered over the existing custom form and persistence loop."""
+
+import json
+from urllib.parse import urlsplit
+
+from code_puppy.i18n import t
+
+
+def read_config(form):
+    config = json.loads(form.json_config)
+    if not isinstance(config, dict):
+        raise ValueError(t("mcp.http_form.object_required"))
+    return config
+
+
+def validate_headers(headers):
+    """Non-empty string keys, string values, no CRLF (header injection)."""
+    if not isinstance(headers, dict) or any(
+        not isinstance(key, str)
+        or not isinstance(value, str)
+        or not key
+        or any(char in key + value for char in "\r\n")
+        for key, value in headers.items()
+    ):
+        raise ValueError(t("mcp.http_form.invalid_headers"))
+
+
+def validate_config(config):
+    url = config.get("url", "")
+    if not isinstance(url, str):
+        raise ValueError(t("mcp.http_form.invalid_url"))
+    parsed = urlsplit(url)
+    if (
+        parsed.scheme not in ("https", "http")
+        or not parsed.hostname
+        or parsed.username is not None
+        or parsed.password is not None
+        or any(char.isspace() for char in url)
+    ):
+        raise ValueError(t("mcp.http_form.invalid_url"))
+    headers = config.get("headers", {})
+    validate_headers(headers)
+    from code_puppy.mcp_.http_auth import http_auth
+
+    # Reuse transport security policy; constructing OAuth does not start login.
+    http_auth(config, url, headers)
+
+
+def save_config(form, config):
+    form.json_config = json.dumps(config, indent=2)
+
+
+def input_text(title, initial):
+    from termflow.tui import TextInputBuilder
+    from code_puppy.command_line.tui_style import menu_style
+
+    builder = TextInputBuilder(title).initial(initial).alt_screen(False)
+    style = menu_style()
+    if style is not None:
+        builder.style(style)
+    result = builder.build().run()
+    return None if result.cancelled else result.value
+
+
+def choose_auth(config):
+    from termflow.tui import MenuBuilder, MenuItem
+    from code_puppy.command_line.tui_style import themed
+
+    result = (
+        themed(
+            MenuBuilder(t("mcp.http_form.auth"))
+            .items(
+                [
+                    MenuItem(t("mcp.http_form.none"), value="none"),
+                    MenuItem(t("mcp.http_form.oauth"), value="oauth"),
+                    MenuItem(t("mcp.http_form.headers_auth"), value="headers"),
+                ]
+            )
+            .alt_screen(False)
+        )
+        .build()
+        .run()
+    )
+    if result.cancelled or result.item is None:
+        return False
+    if result.item.value == "oauth":
+        config["auth"] = "oauth"
+        # New OAuth selections need time for a human to finish browser login.
+        if config.get("timeout", 30) == 30:
+            config["timeout"] = 330
+    else:
+        config.pop("auth", None)
+    if result.item.value == "none":
+        headers = config.get("headers", {})
+        config["headers"] = {
+            key: val for key, val in headers.items() if key.lower() != "authorization"
+        }
+    if result.item.value == "headers":
+        return edit_headers(config)
+    return True
+
+
+def edit_headers(config):
+    value = input_text(
+        t("mcp.http_form.headers_prompt"), json.dumps(config.get("headers", {}))
+    )
+    if value is None:
+        return False
+    try:
+        headers = json.loads(value or "{}")
+    except ValueError:
+        # A JSONDecodeError message is noise in the footer; say what we mean.
+        raise ValueError(t("mcp.http_form.invalid_headers")) from None
+    validate_headers(headers)
+    if headers:
+        config["headers"] = headers
+    else:
+        config.pop("headers", None)
+    return True
+
+
+class HTTPMenu:
+    def __init__(self, form, original, overrides):
+        self.form = form
+        self.original = original
+        self.overrides = overrides
+
+    def run(self):
+        from termflow.tui import MenuBuilder, MenuItem
+        from code_puppy.command_line.tui_style import themed
+
+        form = self.form
+        while True:
+            try:
+                config = read_config(form)
+            except (ValueError, TypeError):
+                # Advanced malformed JSON remains editable, never discarded.
+                return self.original(form, **self.overrides).run()
+            auth = (
+                "oauth"
+                if config.get("auth") == "oauth"
+                else (
+                    "headers_auth"
+                    if any(
+                        key.lower() == "authorization"
+                        for key in config.get("headers", {})
+                    )
+                    else "none"
+                )
+            )
+            items = [
+                MenuItem(t("mcp.http_form.name", name=form.server_name), value="name"),
+                MenuItem(t("mcp.http_form.type"), value="type"),
+                MenuItem(t("mcp.http_form.url"), value="http_url"),
+                MenuItem(
+                    t("mcp.http_form.auth_value", auth=t("mcp.http_form." + auth)),
+                    value="http_auth",
+                ),
+                MenuItem(t("mcp.http_form.headers"), value="http_headers"),
+                MenuItem(t("mcp.http_form.advanced"), value="json"),
+                MenuItem(t("mcp.http_form.save"), value="save"),
+                MenuItem(t("mcp.http_form.cancel"), value="cancel"),
+            ]
+            # Do not echo credentials, header values, or URL query secrets.
+            builder = themed(
+                MenuBuilder(t("mcp.http_form.title")).items(items).alt_screen(False)
+            )
+            if form.validation_error:
+                builder.footer_hint(form.validation_error)
+            result = builder.build().run()
+            if result.cancelled or result.item is None:
+                return result
+            field = result.item.value
+            try:
+                if field == "http_url":
+                    value = input_text(t("mcp.http_form.url"), config.get("url", ""))
+                    if value is not None:
+                        config["url"] = value.strip()
+                        save_config(form, config)
+                elif field == "http_auth":
+                    if choose_auth(config):
+                        save_config(form, config)
+                elif field == "http_headers":
+                    if edit_headers(config):
+                        save_config(form, config)
+                elif field == "save":
+                    validate_config(config)
+                    return result
+                else:
+                    return result
+                form.validation_error = None
+            except (ValueError, TypeError) as exc:
+                form.validation_error = str(exc)
+
+
+def install_http_form():
+    from code_puppy.command_line.mcp import custom_server_form as core
+
+    original = core.run_form_flow
+    if getattr(original, "_http_fields", False):
+        return
+
+    def menu(form, **overrides):
+        if form._get_current_type() == "http":
+            return HTTPMenu(form, core.build_form_menu, overrides)
+        return core.build_form_menu(form, **overrides)
+
+    def type_menu(form):
+        old_type = form._get_current_type()
+        untouched = (
+            form.json_config.strip() == core.CUSTOM_SERVER_EXAMPLES[old_type].strip()
+        )
+        core.run_type_menu(form)
+        if old_type != "http" and form._get_current_type() == "http" and untouched:
+            save_config(form, {"type": "http", "url": "", "timeout": 30})
+
+    def run(form, **kwargs):
+        kwargs.setdefault("menu_factory", menu)
+        kwargs.setdefault("type_menu", type_menu)
+        return original(form, **kwargs)
+
+    run._http_fields = True
+    core.run_form_flow = run

code_puppy_core_plugins-0.0.54/code_puppy_core_plugins/mcp_binding_prompt/register_callbacks.py

@@ -0,0 +1,48 @@
+"""Bridge synchronous installers to the existing binding menu via startup."""
+
+import logging
+
+from code_puppy.callbacks import register_callback
+
+logger = logging.getLogger(__name__)
+
+
+def prompt_bind_after_install_sync(server_name: str) -> None:
+    """Run in the installer's foreground, never schedule a competing UI task."""
+    from code_puppy.agents import get_available_agents
+    from code_puppy.command_line.mcp_binding_menu import (
+        build_post_install_menu,
+        menu_session,
+        set_awaiting_user_input,
+    )
+
+    agents = sorted(get_available_agents(), key=str.lower)
+    if not agents:
+        return
+    set_awaiting_user_input(True)
+    try:
+        with menu_session():
+            build_post_install_menu(server_name, agents, alt_screen=False).run()
+    finally:
+        set_awaiting_user_input(False)
+
+
+def _install() -> None:
+    try:
+        from code_puppy.command_line import mcp_binding_menu
+
+        if not hasattr(mcp_binding_menu, "prompt_bind_after_install_sync"):
+            mcp_binding_menu.prompt_bind_after_install_sync = (
+                prompt_bind_after_install_sync
+            )
+        from .custom_install import install_routes
+
+        install_routes()
+        from .http_form import install_http_form
+
+        install_http_form()
+    except Exception:
+        logger.exception("Could not install MCP binding prompt compatibility bridge")
+
+
+register_callback("startup", _install)

{code_puppy_core_plugins-0.0.52 → code_puppy_core_plugins-0.0.54}/code_puppy_core_plugins/plugin_list/plugins_menu.py

@@ -82,8 +82,6 @@ class PluginsMenu:
         self.plugins: List[_PluginEntry] = []
         self.disabled: set[str] = set()
         self.project_dir: Optional[str] = None
-        self.lock_builtin: bool = False
-        self.hidden_builtin_count: int = 0
 
         # The trust modal disables list bindings while open, keeping accept-word
         # typing from triggering shortcuts; focus remains on its input.
@@ -131,27 +129,19 @@ class PluginsMenu:
             get_project_plugins_directory,
         )
         from code_puppy.plugins.config import get_disabled_plugins
-        from code_puppy.plugins.config import (
-            get_lock_builtin_plugins,
-        )
 
         loaded = get_loaded_plugins()
         self.disabled = get_disabled_plugins()
-        self.lock_builtin = get_lock_builtin_plugins()
 
         project_dir = get_project_plugins_directory()
         self.project_dir = project_dir.as_posix() if project_dir else None
 
-        entries: List[_PluginEntry] = []
-        self.hidden_builtin_count = 0
-        for tier in ("builtin", "user", "project"):
-            for name in sorted(loaded.get(tier, [])):
-                # When locked, builtins are managed/protected — hide them so
-                # they can't be toggled (the config layer refuses anyway).
-                if self.lock_builtin and tier == "builtin":
-                    self.hidden_builtin_count += 1
-                    continue
-                entries.append(_PluginEntry(name, tier))
+        # Every tier is listed and toggleable -- builtins included.
+        entries: List[_PluginEntry] = [
+            _PluginEntry(name, tier)
+            for tier in ("builtin", "user", "project")
+            for name in sorted(loaded.get(tier, []))
+        ]
 
         # Project plugins held back by the trust gate — shown so Enter can
         # open the ceremony popup on them.

{code_puppy_core_plugins-0.0.52 → code_puppy_core_plugins-0.0.54}/code_puppy_core_plugins/plugin_list/plugins_menu_render.py

@@ -72,21 +72,8 @@ def render_list(menu: "PluginsMenu") -> Fragments:
     lines.append(("bold", " Plugins"))
     lines.append(("", "\n\n"))
 
-    if menu.lock_builtin and menu.hidden_builtin_count:
-        lines.append(
-            (
-                "class:tui.muted",
-                f"  {menu.hidden_builtin_count} builtin plugins are "
-                f"managed and hidden.",
-            )
-        )
-        lines.append(("", "\n\n"))
-
     if not menu.plugins:
-        if menu.lock_builtin and menu.hidden_builtin_count:
-            lines.append(("class:tui.warning", "  No user or project plugins loaded."))
-        else:
-            lines.append(("class:tui.warning", "  No plugins loaded."))
+        lines.append(("class:tui.warning", "  No plugins loaded."))
         lines.append(("", "\n"))
         _render_hints(lines)
         return lines

{code_puppy_core_plugins-0.0.52 → code_puppy_core_plugins-0.0.54}/code_puppy_core_plugins/subagent_panel/README.md

@@ -56,6 +56,13 @@ Milo is thinking... (  o  )
   (The redundant core "<check> <name> completed successfully" line is suppressed.)
   Nested agents get a compact one-liner frozen record instead of the full block:
   `<elbow> name  (check) mm:ss  completed  model`.
+- **Detached rows outlive the turn.** `FORK` and `BACKGROUND` runs are their own
+  asyncio tasks, so when the main agent's turn ends only the *foreground* swarm
+  is retired from the panel -- a still-running fork/background row keeps
+  ticking at the idle prompt until it finishes at its own boundary (the
+  launcher publishes a `post_tool_call` with `{"detached": True}`; `/fork`'s
+  older `{"detached_fork": True}` spelling is honoured too). Ctrl+C still
+  clears everything, because the cancel sweep takes detached runs down as well.
 
 ## How it works (3 monkeypatches, 1 callback -- no core edits)
 

{code_puppy_core_plugins-0.0.52 → code_puppy_core_plugins-0.0.54}/code_puppy_core_plugins/subagent_panel/register_callbacks.py

@@ -21,6 +21,9 @@ Install strategy (startup monkeypatches of seams with no hook + callbacks):
      but KEPT in the live tree (shown 'completed') so it never vanishes
      mid-run; the whole subtree flushes to the transcript parent-first only
      when its ROOT finishes, then is removed from the live tree.
+     DETACHED trees (/fork, background=True) outlive the main turn: end-of-
+     turn cleanup only retires the foreground swarm, so a detached row keeps
+     ticking at the idle prompt until its own ``post_tool_call`` boundary.
   4. subagent_invocation.emit_success -> suppress the redundant
      "<check> <name> completed successfully" line (it comes from the separate
      message_queue system, NOT the bus, so it must be dropped at its source).
@@ -225,25 +228,35 @@ def _handle_frozen(console, session_id):
 
 
 def _maybe_flush_group(console):
-    """Flush the WHOLE live panel to scrollback as one group (parent-first DFS),
-    then clear it -- but ONLY when no agent is still active. While any agent is
-    running, completed agents stay grouped in the live panel (shown 'completed'),
-    so the panel remains a single cohesive block pinned above the spinner.
+    """Flush the settled panel rows to scrollback as one group (parent-first
+    DFS) -- but ONLY when the foreground swarm is idle. While any foreground
+    agent is running, completed agents stay grouped in the live panel (shown
+    'completed'), so the panel remains a single cohesive block.
+
+    Detached trees (/fork, background) whose root is still running are NOT
+    part of the group: they keep their live rows and flush at their own
+    boundary, exactly like the rest of their lifecycle.
     """
-    rows = state.snapshot()
-    if not rows:
-        return
-    if any(not e.get("done") for e in rows):
+    state.snapshot()  # idle-prune before deciding
+    if state.foreground_busy():
         return  # swarm still busy -- keep the panel grouped + live
     if console is None:
         return
-    ordered = _ordered_tree(rows)
+    settled = state.pop_settled()
+    if not settled:
+        return
     console.print()  # breathing room between the transcript and the group
-    for line in _row_lines(ordered, frame=None):
+    for line in _row_lines(_ordered_tree(settled), frame=None):
         console.print(line)
-    state.clear()
-    _stop_ticker()  # last agent flushed — nothing left to clock
-    _push_panel(force=True)  # collapse the panel rows
+    _retire_ticker_if_idle()
+    _push_panel(force=True)  # collapse the flushed rows
+
+
+def _retire_ticker_if_idle() -> None:
+    """Stop the clock only once nothing is left to clock -- a live detached
+    row still needs its mm:ss advancing after the foreground flushes."""
+    if not state.has_active():
+        _stop_ticker()
 
 
 # Monkeypatch installers
@@ -442,11 +455,16 @@ async def _on_agent_run_end(
     response_text=None,
     metadata=None,
 ):
-    """When the TOP-LEVEL turn ends, wipe all tracked sub-agents so a root that
+    """When the TOP-LEVEL turn ends, retire the foreground swarm so a root that
     errored or was cancelled (never flushed) can't leak its 'completed' children
-    into the next prompt's live block. Only fires for the main agent -- sub-agent
-    runs go through temp_agent.run(), not _runtime, and is_subagent() guards the
-    rest.
+    into the next prompt's live block.
+
+    Detached trees (/fork, background) that are still running SURVIVE: their
+    task outlives the turn, so their live row does too -- the panel keeps
+    ticking at the idle prompt until they finish at their own boundary.
+
+    Only fires for the main agent -- sub-agent runs go through
+    temp_agent.run(), not _runtime, and is_subagent() guards the rest.
     """
     if not _runtime_enabled():
         return
@@ -458,10 +476,10 @@ async def _on_agent_run_end(
     except Exception:
         pass
     try:
-        state.clear()
+        state.pop_settled()  # discard foreground leftovers; detached rows stay
     except Exception:
         pass
-    _stop_ticker()  # run over — never leave an orphan clock task
+    _retire_ticker_if_idle()  # never leave an orphan clock task
     _push_panel(force=True)
 
 
@@ -483,6 +501,15 @@ async def _on_agent_run_cancel(group_id=None):
     _push_panel(force=True)
 
 
+def _is_detached_context(context) -> bool:
+    """Did a detached launcher (/fork or background_agents) publish this
+    ``post_tool_call``? Both keys mean the same thing; ``detached_fork`` is
+    the older spelling kept so an older /fork plugin still retires its row."""
+    if not isinstance(context, dict):
+        return False
+    return bool(context.get("detached") or context.get("detached_fork"))
+
+
 async def _on_post_tool_call(tool_name, tool_args, result, duration_ms, context=None):
     """Authoritative completion **state** signal for sub-agent invocations.
 
@@ -525,9 +552,10 @@ async def _on_post_tool_call(tool_name, tool_args, result, duration_ms, context=
     if not sid:
         return
     try:
-        # Keep ordinary calls until their foreground root flushes; detached forks
-        # have no root, so finish them at their own boundary.
-        if isinstance(context, dict) and context.get("detached_fork"):
+        # Keep ordinary calls until their foreground root flushes; detached
+        # runs (/fork, background) have no foreground root, so finish them at
+        # their own boundary. ``detached_fork`` is the legacy key /fork sends.
+        if _is_detached_context(context):
             state.finish(sid)
         else:
             err = getattr(result, "error", None)