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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: code-puppy-core-plugins
-Version: 0.0.52
+Version: 0.0.53
 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.53}/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.52 → code_puppy_core_plugins-0.0.53}/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.53}/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)

{code_puppy_core_plugins-0.0.52 → code_puppy_core_plugins-0.0.53}/code_puppy_core_plugins/subagent_panel/state.py

@@ -112,13 +112,71 @@ def mark_failed(session_id: Optional[str]) -> None:
 
 
 def clear() -> None:
-    """Drop ALL tracked sub-agents. Called when the top-level turn ends so a
-    root that errored/was cancelled (and thus never flushed) can't leak its
-    'completed' children into the next prompt's live block."""
+    """Drop ALL tracked sub-agents -- detached ones included. Reserved for the
+    cancel path (Ctrl+C takes forks/background agents down too) and for the
+    runtime off-switch; ordinary end-of-turn cleanup is ``pop_settled``."""
     with _LOCK:
         _AGENTS.clear()
 
 
+# Detached trees (/fork + background) outlive the turn that started them
+def is_detached(entry: Dict[str, Any]) -> bool:
+    """A ``/fork`` or ``background=True`` launch: its lifetime is its own task,
+    not the main agent's turn, so end-of-turn cleanup must leave it alone."""
+    return bool(entry.get("is_fork") or entry.get("background"))
+
+
+def _root_id(agents: Dict[str, Dict[str, Any]], session_id: str) -> str:
+    """Walk the parent chain to the tree root. A parent that isn't registered
+    (the main agent, or None) makes the row a root. Cycle-safe."""
+    seen = set()
+    while True:
+        parent = agents[session_id].get("parent")
+        if not parent or parent not in agents or parent in seen:
+            return session_id
+        seen.add(session_id)
+        session_id = parent
+
+
+def _live_detached_ids(agents: Dict[str, Dict[str, Any]]) -> set:
+    """Session ids of every row (root + descendants) in a detached tree whose
+    root is still running."""
+    live = set()
+    for sid in agents:
+        root = agents[_root_id(agents, sid)]
+        if is_detached(root) and not root.get("done"):
+            live.add(sid)
+    return live
+
+
+def foreground_busy() -> bool:
+    """True while anything OUTSIDE a live detached tree is still running --
+    i.e. the foreground swarm hasn't gone idle yet, so nothing may flush."""
+    with _LOCK:
+        live = _live_detached_ids(_AGENTS)
+        return any(
+            not entry.get("done") for sid, entry in _AGENTS.items() if sid not in live
+        )
+
+
+def pop_settled() -> List[Dict[str, Any]]:
+    """Remove and return every row NOT in a live detached tree (oldest first).
+
+    Live detached trees stay registered: a fork or background agent keeps
+    its live row across turn boundaries until it finishes at its own
+    boundary (``finish`` / ``mark_done``). Everything else -- the foreground
+    swarm, plus detached trees that already completed -- is handed back to
+    the caller to flush as frozen records (or discard at end of turn, when a
+    root that errored/was cancelled never flushed).
+    """
+    with _LOCK:
+        live = _live_detached_ids(_AGENTS)
+        settled = [entry for sid, entry in _AGENTS.items() if sid not in live]
+        for entry in settled:
+            _AGENTS.pop(entry["session_id"], None)
+        return sorted(settled, key=lambda e: e["start"])
+
+
 # Live status (stream_event updates only)
 def record_event(session_id: Optional[str], event_type: str, event_data: Any) -> None:
     if not session_id:

{code_puppy_core_plugins-0.0.52 → code_puppy_core_plugins-0.0.53}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "code-puppy-core-plugins"
-version = "0.0.52"
+version = "0.0.53"
 description = "Official plugin bundle for Code Puppy"
 readme = "README.md"
 requires-python = ">=3.11,<3.15"