code-puppy 0.0.950__tar.gz → 0.0.951__tar.gz

{code_puppy-0.0.950 → code_puppy-0.0.951}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: code-puppy
-Version: 0.0.950
+Version: 0.0.951
 Summary: Code generation agent
 Project-URL: repository, https://github.com/mpfaffenberger/code_puppy
 Project-URL: HomePage, https://github.com/mpfaffenberger/code_puppy

{code_puppy-0.0.950 → code_puppy-0.0.951}/code_puppy/agents/_builder.py

@@ -311,11 +311,16 @@ def _build_gpt_5_6_invoke_agent_guard_text() -> str:
     limit = get_subagent_recursion_limit_gpt_5_6()
     return (
         "\n\n## Sub-Agent Delegation (GPT-5.6)\n"
-        "Use `invoke_agent` only for focused work that benefits from separate "
-        "context or specialized tools. Handle work directly when you can. "
+        "Use `invoke_agent` for focused work that benefits from separate "
+        "context or specialized tools; handle small work directly. When a task "
+        "has independent, tightly scoped pieces, invoke them as multiple "
+        "sub-agents concurrently in one batch (several `invoke_agent` calls in "
+        "the same response) rather than one at a time. Each must be a direct "
+        "child told not to delegate further. Wait for the batch, then "
+        "synthesize the results yourself; "
+        "do not start recursive or repeated follow-up delegation chains. "
         "Never invoke `planning-agent`. "
-        f"Hard cap: as a GPT-5.6 caller you may only invoke a sub-agent while "
-        f"the resulting chain depth stays at or below {limit} "
+        f"Hard cap: the resulting chain depth must stay at or below {limit} "
         f"(main agent = depth 0). Do not attempt deeper chains.\n"
     )
 

{code_puppy-0.0.950 → code_puppy-0.0.951}/code_puppy/tools/subagent_invocation.py

@@ -166,18 +166,17 @@ def _subagent_identity_prompt(agent_name: str) -> str:
     depth = get_subagent_depth() + 1
     limit = get_subagent_recursion_limit()
     chain = " -> ".join(("main agent", *get_subagent_chain(), agent_name))
-    remaining = max(limit - depth, 0)
     return f"""## Sub-agent execution context (mandatory)
 
 You are the sub-agent `{agent_name}`, not the main agent. Your nesting depth is
-{depth} (main agent = 0). Invocation chain: {chain}. The configured maximum
-sub-agent depth is {limit}; {remaining} deeper level(s) remain.
+{depth} (main agent = 0). Invocation chain: {chain}.
 
-Complete your assigned task directly. Prefer doing the work yourself over
-spawning more agents, but delegation is permitted -- including invoking an agent
-whose name matches your own -- as long as it serves the task. The recursion guard
-above enforces the depth cap automatically, so nesting beyond it is refused
-rather than forbidden by convention."""
+Complete your assigned task directly and return the result to your caller. Do
+not delegate further unless your caller explicitly asks you to; if you do, use
+one concurrent batch of direct children, synthesize their results yourself, and
+do not chain follow-up sub-agent calls. The runtime depth guard (max {limit})
+rejects deeper calls. Remaining depth capacity alone is not a reason to
+delegate."""
 
 
 def _contains_cancellation(exc: BaseException) -> bool:
@@ -798,9 +797,13 @@ def register_invoke_agent(agent):
     ) -> AgentInvokeOutput | dict:
         """Invoke a specific sub-agent using its configured model.
 
-        Prefer doing the work directly, but delegation is allowed -- including
-        to an agent whose name matches the caller's. Nesting is capped by the
-        recursion guard rather than by convention.
+        Prefer handling small work directly. When a task has independent,
+        tightly scoped pieces, invoke them as multiple sub-agents concurrently
+        in one batch (several invoke_agent calls in the same response) rather
+        than one at a time. Invoke direct children only and tell each child to
+        complete its task without delegating further. After the batch returns,
+        synthesize the results yourself instead of starting follow-up chains of
+        sub-agent calls. The runtime recursion guard remains the depth backstop.
 
         Args:
             agent_name: Name of the sub-agent to invoke.
@@ -808,6 +811,8 @@ def register_invoke_agent(agent):
             session_id: Optional kebab-case session id for continuing memory.
             background: Return immediately and deliver completion automatically
                 to the main agent, even after its turn ends. Defaults to False.
+                Not needed for parallel calls; use it only when you do not need
+                the result this turn.
 
         Returns:
             AgentInvokeOutput: Contains response, agent_name, session_id,
@@ -859,9 +864,14 @@ def register_invoke_agent_with_model(agent):
 
         Use this only when a model override is intentionally required. For
         normal delegation, use invoke_agent so the sub-agent's configured model
-        is respected. Prefer doing the work directly, but delegation is allowed
-        -- including to an agent whose name matches the caller's. Nesting is
-        capped by the recursion guard rather than by convention.
+        is respected. Prefer handling small work directly. When a task has
+        independent, tightly scoped pieces, invoke them as multiple sub-agents
+        concurrently in one batch (several invoke_agent calls in the same
+        response) rather than one at a time. Invoke direct children only and
+        tell each child to complete its task without delegating further. After
+        the batch returns, synthesize the results yourself instead of starting
+        follow-up chains of sub-agent calls. The runtime recursion guard remains
+        the depth backstop.
 
         Args:
             agent_name: Name of the sub-agent to invoke.

{code_puppy-0.0.950 → code_puppy-0.0.951}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "code-puppy"
-version = "0.0.950"
+version = "0.0.951"
 description = "Code generation agent"
 readme = "README.md"
 requires-python = ">=3.11,<3.15"