ouroboros-ai 0.43.4.dev2__tar.gz → 0.44.1.dev1__tar.gz

{ouroboros_ai-0.43.4.dev2 → ouroboros_ai-0.44.1.dev1}/.claude-plugin/marketplace.json

@@ -10,7 +10,7 @@
     {
       "name": "ouroboros",
       "description": "Transform vague ideas into validated seed specifications through Socratic questioning and ontological analysis",
-      "version": "0.43.4",
+      "version": "0.44.1",
       "author": {
         "name": "Q00",
         "email": "jqyu.lee@gmail.com"

{ouroboros_ai-0.43.4.dev2 → ouroboros_ai-0.44.1.dev1}/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "ouroboros",
-  "version": "0.43.4",
+  "version": "0.44.1",
   "description": "Self-improving AI workflow system. Crystallize requirements before execution with Socratic interview, ambiguity scoring, and 3-stage evaluation.",
   "author": {
     "name": "Q00",

{ouroboros_ai-0.43.4.dev2 → ouroboros_ai-0.44.1.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ouroboros-ai
-Version: 0.43.4.dev2
+Version: 0.44.1.dev1
 Summary: Specification-first workflow engine for AI coding agents. Works with Claude Code and Codex CLI.
 Author-email: Q00 <jqyu.lee@gmail.com>
 License-File: LICENSE

{ouroboros_ai-0.43.4.dev2 → ouroboros_ai-0.44.1.dev1}/docs/runtime-guides/skill-capability-guides.md

@@ -33,8 +33,10 @@ its rendered guide or a documented fallback.
 | Runtime | Generated artifact surface | Status |
 | --- | --- | --- |
 | Codex | Managed rule under `~/.codex/rules/ouroboros.md` | Installed during Codex setup/update via the generated guide renderer. |
+| Codex_MCP | Reuses the Codex CLI setup-owned rule surface | Leader-driven worker runtime over `codex mcp-server`; uses the Codex capability guide and is not a separate LLM/interview backend. |
 | Hermes | `~/.hermes/skills/autonomous-ai-agents/ouroboros/SKILL_CAPABILITY_GUIDE.md` | Installed with the Hermes skill bundle. |
 | Claude | `.claude-plugin/SKILL_CAPABILITY_GUIDE.md` | Shipped with the Claude plugin package and checked against the renderer. |
+| Claude_MCP | Reuses the Claude CLI/plugin instruction surface | Leader-driven worker runtime over `claude -p --resume`; runtime-only provider-neutral worker path, not a separate LLM/interview backend. |
 | OpenCode | Global `AGENTS.md` in the active OpenCode config directory | Installed by OpenCode setup for plugin and subprocess modes. |
 | Gemini | `~/.gemini/GEMINI.md` | Installed by Gemini setup as a managed section in the global Gemini memory file. |
 | Kiro | `~/.kiro/steering/ouroboros-skill-capability-guide.md` | Installed by Kiro setup as a global steering file. |

{ouroboros_ai-0.43.4.dev2 → ouroboros_ai-0.44.1.dev1}/skills/setup/SKILL.md

@@ -282,7 +282,7 @@ A backup will be created: CLAUDE.md.bak
 **If "Preview first", show:**
 ````markdown
 <!-- ooo:START -->
-<!-- ooo:VERSION:0.43.4 -->
+<!-- ooo:VERSION:0.44.1 -->
 # Ouroboros — Specification-First AI Development
 
 > Before telling AI what to build, define what should be built.

{ouroboros_ai-0.43.4.dev2 → ouroboros_ai-0.44.1.dev1}/src/ouroboros/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.43.4.dev2'
-__version_tuple__ = version_tuple = (0, 43, 4, 'dev2')
+__version__ = version = '0.44.1.dev1'
+__version_tuple__ = version_tuple = (0, 44, 1, 'dev1')
 
 __commit_id__ = commit_id = None

{ouroboros_ai-0.43.4.dev2 → ouroboros_ai-0.44.1.dev1}/src/ouroboros/backends/capabilities.py

@@ -378,6 +378,27 @@ _CAPABILITIES: tuple[BackendCapability, ...] = (
         prohibited_subagent_spawn_tool_names=("multi_agent_v1.spawn_agent",),
         tool_discovery_mechanism=ToolDiscoveryMechanism.NATIVE_RUNTIME_DISCOVERY,
     ),
+    # Leader-driven worker runtime over ``codex mcp-server`` (codex/codex-reply).
+    # Same codex binary, runtime-only (not an LLM/interview backend); declares
+    # EXTERNAL_LEADER_DRIVEN at the runtime layer. See orchestrator.codex_mcp_runtime.
+    BackendCapability(
+        name="codex_mcp",
+        aliases=("codex_mcp_server",),
+        supports_runtime=True,
+        cli_name="codex",
+        cli_config_key="codex_cli_path",
+        skill_execution_capabilities=_CODEX_SKILL_EXECUTION_CAPABILITIES,
+    ),
+    # Leader-driven worker runtime over ``claude -p --resume`` (stream-json).
+    # Same claude binary, runtime-only; declares EXTERNAL_LEADER_DRIVEN. Proves
+    # the worker pool is provider-neutral. See orchestrator.claude_worker_runtime.
+    BackendCapability(
+        name="claude_mcp",
+        aliases=("claude_worker",),
+        supports_runtime=True,
+        cli_name="claude",
+        cli_config_key="cli_path",
+    ),
     BackendCapability(
         name="copilot",
         aliases=("copilot_cli",),

{ouroboros_ai-0.43.4.dev2 → ouroboros_ai-0.44.1.dev1}/src/ouroboros/config/__init__.py

@@ -54,6 +54,7 @@ from ouroboros.config.loader import (
     get_llm_permission_mode,
     get_max_parallel_workers,
     get_mechanical_detector_model,
+    get_native_session_index_enabled,
     get_ontology_analysis_model,
     get_opencode_cli_path,
     get_opencode_mode,
@@ -128,6 +129,7 @@ __all__ = [
     "config_exists",
     "credentials_file_secure",
     "get_agent_runtime_backend",
+    "get_native_session_index_enabled",
     "get_agent_permission_mode",
     "get_agent_reasoning_effort",
     "get_assertion_extraction_model",

{ouroboros_ai-0.43.4.dev2 → ouroboros_ai-0.44.1.dev1}/src/ouroboros/config/loader.py

@@ -733,6 +733,23 @@ def get_runtime() -> str:
     return get_agent_runtime_backend()
 
 
+def get_native_session_index_enabled() -> bool:
+    """Whether to register worker sessions in the host tool's native session list.
+
+    OFF by default: the web dashboard is the primary, non-flooding worker view
+    (it groups every worker under one run). Opt in with
+    ``OUROBOROS_NATIVE_SESSION_INDEX=1|true|on|yes`` to ALSO dump each worker into
+    the Codex app's conversation list (one ``ooo:`` entry per worker) so you can
+    open it natively — at the cost of a busier app list.
+    """
+    return os.environ.get("OUROBOROS_NATIVE_SESSION_INDEX", "").strip().lower() in (
+        "1",
+        "true",
+        "on",
+        "yes",
+    )
+
+
 def _uses_opencode_backend(backend: str | None) -> bool:
     """Return True when a backend name resolves to an OpenCode runtime."""
     return (backend or "").strip().lower() in _OPENCODE_BACKENDS

{ouroboros_ai-0.43.4.dev2 → ouroboros_ai-0.44.1.dev1}/src/ouroboros/mcp/client/adapter.py

@@ -538,10 +538,12 @@ class MCPClientAdapter:
             elif hasattr(item, "uri"):
                 content_items.append(MCPContentItem(type=ContentType.RESOURCE, uri=item.uri))
 
+        structured = getattr(result, "structuredContent", None)
         return MCPToolResult(
             content=tuple(content_items),
             is_error=getattr(result, "isError", False),
             meta=getattr(result, "meta", {}) or {},
+            structured_content=structured if isinstance(structured, dict) else None,
         )
 
     async def list_resources(self) -> Result[Sequence[MCPResourceDefinition], MCPClientError]:

ouroboros_ai-0.44.1.dev1/src/ouroboros/mcp/tools/assignment.py

@@ -0,0 +1,94 @@
+"""Typed self-contained subagent assignment contract.
+
+Subagent prompts have historically been free-form f-strings: each builder
+concatenates ``## Your Task`` / ``## Seed Specification`` / notes ad hoc, so what
+the child is *told to do* and what the harness later *validates* can silently
+drift. This module introduces a small, frozen ``AssignmentMessage`` that frames
+a dispatch as the four things a self-contained worker needs:
+
+- **TASK** — what to do.
+- **DELIVERABLE** — the concrete artifact / outcome that counts as "done".
+- **SCOPE** — boundaries: which files, session, limits, and constraints apply.
+- **VERIFY** — the evidence the child must produce before reporting completion.
+
+Rendering wraps the contract in an explicit ``<assignment>`` authority delimiter
+so the child treats it as binding direction rather than reference prose — the
+same fencing rationale as the Codex ``<system-directive>`` block.
+
+The dataclass is intentionally provider-neutral and additive: builders adopt it
+where it strengthens the contract, and the ``VERIFY`` lines are the natural seam
+to later generate from ``evidence_schema`` so the prompt's required-evidence and
+the harness's ``validate_evidence`` gate stay in lockstep.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True, slots=True)
+class AssignmentMessage:
+    """A self-contained TASK / DELIVERABLE / SCOPE / VERIFY work order.
+
+    Attributes:
+        task: One or two sentences stating what the child must do.
+        deliverable: The artifact or end-state that constitutes completion.
+        scope: Ordered boundary lines (session id, limits, working dir, files,
+            constraints). Empty entries are dropped.
+        verify: Ordered evidence lines the child must satisfy before claiming
+            done (e.g. "All acceptance criteria pass", "Tests run green").
+            Empty entries are dropped.
+        body: Optional trailing free-form block (e.g. the seed specification or
+            a recursion guard) appended verbatim after the contract. Kept
+            outside the four labelled sections so large payloads do not dilute
+            the directive.
+    """
+
+    task: str
+    deliverable: str
+    scope: tuple[str, ...] = ()
+    verify: tuple[str, ...] = ()
+    body: str | None = None
+
+    def __post_init__(self) -> None:
+        if not self.task.strip():
+            raise ValueError("AssignmentMessage.task must not be empty")
+        if not self.deliverable.strip():
+            raise ValueError("AssignmentMessage.deliverable must not be empty")
+
+    @staticmethod
+    def _bullets(lines: tuple[str, ...]) -> str:
+        return "\n".join(f"- {line.strip()}" for line in lines if line.strip())
+
+    def render(self) -> str:
+        """Render the assignment as an authority-delimited prompt block."""
+        sections: list[str] = [
+            "## Task",
+            self.task.strip(),
+            "",
+            "## Deliverable",
+            self.deliverable.strip(),
+        ]
+
+        scope_bullets = self._bullets(self.scope)
+        if scope_bullets:
+            sections.extend(["", "## Scope", scope_bullets])
+
+        verify_bullets = self._bullets(self.verify)
+        if verify_bullets:
+            sections.extend(
+                [
+                    "",
+                    "## Verify (produce this evidence before reporting done)",
+                    verify_bullets,
+                ]
+            )
+
+        block = "<assignment>\n" + "\n".join(sections) + "\n</assignment>"
+
+        if self.body and self.body.strip():
+            return f"{block}\n\n{self.body.strip()}"
+        return block
+
+
+__all__ = ["AssignmentMessage"]

{ouroboros_ai-0.43.4.dev2 → ouroboros_ai-0.44.1.dev1}/src/ouroboros/mcp/tools/subagent.py

@@ -49,6 +49,7 @@ from ouroboros.backends.capabilities import (
 )
 from ouroboros.core.seed_contract_prompt import render_auto_recursion_guard
 from ouroboros.core.types import Result
+from ouroboros.mcp.tools.assignment import AssignmentMessage
 from ouroboros.mcp.types import (
     ContentType,
     MCPContentItem,
@@ -776,6 +777,11 @@ def should_dispatch_via_plugin(
     truth. New code should prefer :func:`resolve_subagent_dispatch` to also
     distinguish ``HOST_DRIVEN`` from ``SEQUENTIAL``.
 
+    The envelope path is specifically the host-bridge/passive-plugin mode: a
+    host plugin spawns the child out-of-band. Leader-driven worker-pool runtimes
+    do not emit a passive plugin envelope; they are routed through
+    ``HOST_DRIVEN`` by the resolver instead.
+
     Args:
         runtime_backend: Resolved agent runtime backend name.
         opencode_mode: Configured ``orchestrator.opencode_mode`` value.
@@ -1552,45 +1558,55 @@ def build_execute_subagent(
     model_tier: str | None = "medium",
     max_parallel_workers: int | None = None,
 ) -> SubagentPayload:
-    """Build subagent payload for seed execution."""
-    seed_path_note = ""
-    if seed_path:
-        seed_path_note = f"\n## Seed File Path\n{seed_path}\n"
+    """Build subagent payload for seed execution.
 
-    cwd_note = ""
+    The child receives a typed ``AssignmentMessage`` (TASK / DELIVERABLE / SCOPE
+    / VERIFY) so the work order is a self-contained contract rather than free
+    prose: SCOPE carries the session, limits, working dir and worker cap; VERIFY
+    states the evidence that gates completion (acceptance criteria + QA). The
+    seed specification and recursion guard travel in the assignment body.
+    """
+    scope_lines: list[str] = [
+        f"Session ID: {session_id or 'new'}",
+        f"Max Iterations: {max_iterations}",
+    ]
+    if seed_path:
+        scope_lines.append(f"Seed File Path: {seed_path}")
     if cwd:
-        cwd_note = f"\n## Working Directory\n{cwd}\n"
+        scope_lines.append(f"Working Directory: {cwd}")
+    if max_parallel_workers is not None:
+        scope_lines.append(f"Max Parallel Workers: {max_parallel_workers}")
 
-    qa_note = ""
     if skip_qa:
-        qa_note = "\n## QA\nSkip QA after execution.\n"
+        qa_verify = "QA is skipped for this run — still confirm every acceptance criterion is met."
     else:
-        qa_note = "\n## QA\nRun QA evaluation after execution completes.\n"
-
-    workers_note = ""
-    if max_parallel_workers is not None:
-        workers_note = f"\n## Max Parallel Workers\n{max_parallel_workers}\n"
-
-    prompt = f"""## Your Task
-
-Execute the following seed specification. Implement all requirements defined
-in the seed, respecting constraints and acceptance criteria.
-
-## Session ID
-{session_id or "new"}
-
-## Max Iterations
-{max_iterations}
-{seed_path_note}{cwd_note}{qa_note}{workers_note}
-## Seed Specification
-```yaml
-{seed_content}
-```
-
-{render_auto_recursion_guard()}
+        qa_verify = "Run QA evaluation after execution completes and confirm it passes."
+
+    seed_body = (
+        "## Seed Specification\n"
+        "```yaml\n"
+        f"{seed_content}\n"
+        "```\n\n"
+        f"{render_auto_recursion_guard()}\n\n"
+        "Work iteratively, testing as you go. Stop when all acceptance criteria "
+        "are met or max iterations reached."
+    )
 
-Implement the seed requirements. Work iteratively, testing as you go.
-Stop when all acceptance criteria are met or max iterations reached."""
+    prompt = AssignmentMessage(
+        task=(
+            "Execute the seed specification below. Implement every requirement, "
+            "respecting all constraints and acceptance criteria."
+        ),
+        deliverable=(
+            "A working implementation in which every acceptance criterion in the seed is satisfied."
+        ),
+        scope=tuple(scope_lines),
+        verify=(
+            "Every acceptance criterion in the seed is satisfied.",
+            qa_verify,
+        ),
+        body=seed_body,
+    ).render()
 
     context: dict[str, Any] = {
         "seed_content": seed_content,

{ouroboros_ai-0.43.4.dev2 → ouroboros_ai-0.44.1.dev1}/src/ouroboros/mcp/types.py

@@ -335,11 +335,18 @@ class MCPToolResult:
         content: List of content items from the tool.
         is_error: Whether the tool execution resulted in an error.
         meta: Optional metadata from the tool.
+        structured_content: Optional machine-readable structured payload from the
+            tool's ``structuredContent`` field (MCP spec). Carries values that
+            do not fit the text/image/resource content items — e.g. a
+            ``codex mcp-server`` ``codex`` call returns ``{"threadId": ...}``
+            here, which a leader-driven worker runtime needs to address the
+            spawned session. ``None`` when the tool returned no structured payload.
     """
 
     content: tuple[MCPContentItem, ...] = field(default_factory=tuple)
     is_error: bool = False
     meta: dict[str, Any] = field(default_factory=dict)
+    structured_content: dict[str, Any] | None = None
 
     @property
     def text_content(self) -> str:

{ouroboros_ai-0.43.4.dev2 → ouroboros_ai-0.44.1.dev1}/src/ouroboros/orchestrator/adapter.py

@@ -39,6 +39,9 @@ from ouroboros.orchestrator.rate_limit import (
     SharedRateLimitBucket,
     estimate_runtime_request_tokens,
 )
+from ouroboros.providers.retry import (
+    TRANSIENT_ERROR_PATTERNS as _SHARED_TRANSIENT_ERROR_PATTERNS,
+)
 from ouroboros.router.types import Resolved
 
 if TYPE_CHECKING:
@@ -245,8 +248,10 @@ def _clone_runtime_handle_data(value: object) -> Any:
 _RUNTIME_HANDLE_BACKEND_ALIASES = {
     "claude": "claude",
     "claude_code": "claude",
+    "claude_mcp": "claude_mcp",
     "codex": "codex_cli",
     "codex_cli": "codex_cli",
+    "codex_mcp": "codex_mcp",
     "opencode": "opencode",
     "opencode_cli": "opencode",
     "hermes": "hermes_cli",
@@ -718,6 +723,105 @@ class ParamSupport(StrEnum):
     IGNORED = "ignored"
 
 
+class SubagentOrchestration(StrEnum):
+    """How (and whether) the orchestrator can fan work out to sub-agents.
+
+    This is a property of the (runtime × backend) PAIR, declared per
+    ``AgentRuntime`` instance via ``RuntimeCapabilities`` — NOT of the backend
+    name alone. The same backend can present different modes under different
+    runtimes: ``codex`` driven by ``codex exec`` is INTERNAL, but the same
+    ``codex`` driven as ``codex mcp-server`` (``codex``/``codex-reply`` →
+    addressable threads) is EXTERNAL_LEADER_DRIVEN.
+
+    The two EXTERNAL modes are distinguished by *who drives the child*, because
+    that determines the dispatch mechanism and is the seam that generalizes
+    across providers:
+
+    Values:
+        NONE: No sub-agent mechanism the orchestrator can use. Work runs
+            in-process (ouroboros's own ``anyio`` parallel AC executor). Default.
+        INTERNAL: The backend self-parallelizes *inside its own session* but
+            exposes no child-orchestration surface to an external driver.
+            Verified for ``codex exec`` / ``codex mcp-server``: the native
+            ``multi_agent_v1`` / ``codex_app`` team tools live only inside the
+            interactive session, so a delegated call may spin up its own helpers
+            but ouroboros cannot drive those children. In-process fan-out; may
+            *nudge* internal parallelism via developer-instructions.
+        EXTERNAL_HOST_BRIDGE: A host bridge spawns native sub-agents on the
+            orchestrator's behalf, driven OUT-OF-BAND via the ``_subagent``
+            envelope — ouroboros emits a payload and the host (the OpenCode
+            plugin) spawns a child session. ouroboros does NOT call the child
+            directly. Feeds ``should_dispatch_via_plugin``; eligible only when
+            the per-deployment bridge is enabled (``opencode_mode=plugin``).
+        EXTERNAL_LEADER_DRIVEN: ouroboros IS the leader and drives addressable
+            worker sessions DIRECTLY through the runtime's own resumable-session
+            surface — it spawns N sessions, holds their handles, and continues
+            each. This is the provider-NEUTRAL worker-pool mode: any runtime that
+            yields a resumable, addressable session qualifies. Verified surfaces:
+            Codex (``codex``→threadId→``codex-reply`` via ``codex mcp-server``);
+            Claude (``claude --resume <id>`` / ``claude mcp serve`` /
+            ``--print --output-format stream-json``); future Gemini etc. The
+            worker pool reads this mode via :func:`is_leader_driven_worker` and
+            drives the runtime through the ``AgentRuntime`` seam + the threaded
+            ``RuntimeHandle.native_session_id`` — NO ``_subagent`` envelope, so
+            it must NEVER reach ``should_dispatch_via_plugin``.
+    """
+
+    NONE = "none"
+    INTERNAL = "internal"
+    EXTERNAL_HOST_BRIDGE = "external_host_bridge"
+    EXTERNAL_LEADER_DRIVEN = "external_leader_driven"
+
+
+# Canonical backend → sub-agent-orchestration mapping. Single source of truth so
+# the per-runtime ``capabilities`` declarations and the static dispatch gate
+# (``should_dispatch_via_plugin``) can never drift. This map is the COARSE
+# backend-name fallback; the authoritative value is each runtime's declared
+# ``capabilities.subagent_orchestration`` (which can be finer — e.g. a
+# ``codex mcp-server`` worker runtime declares EXTERNAL_LEADER_DRIVEN even though
+# the backend name ``codex`` maps to INTERNAL here). Backends absent default to
+# NONE. Leader-driven worker runtimes deliberately stay ABSENT (→ NONE) so they
+# never trip the host-bridge plugin gate; they are recognized at the runtime
+# layer via :func:`is_leader_driven_worker`.
+_OPENCODE_BACKENDS: frozenset[str] = frozenset({"opencode", "opencode_cli"})
+_CODEX_BACKENDS: frozenset[str] = frozenset({"codex", "codex_cli"})
+
+
+def subagent_orchestration_for_backend(backend: str | None) -> SubagentOrchestration:
+    """Return the coarse backend-name :class:`SubagentOrchestration` fallback.
+
+    Prefer a runtime's declared ``capabilities.subagent_orchestration`` where a
+    runtime instance is available; this name-keyed map cannot distinguish
+    ``codex exec`` from ``codex mcp-server`` and is only the static fallback for
+    the envelope dispatch gate.
+    """
+    normalized = (backend or "").strip().lower()
+    if normalized in _OPENCODE_BACKENDS:
+        return SubagentOrchestration.EXTERNAL_HOST_BRIDGE
+    if normalized in _CODEX_BACKENDS:
+        return SubagentOrchestration.INTERNAL
+    return SubagentOrchestration.NONE
+
+
+def is_leader_driven_worker(capabilities: RuntimeCapabilities) -> bool:
+    """Return whether ouroboros can drive this runtime as a direct worker-pool member.
+
+    Provider-neutral seam: any runtime declaring
+    ``SubagentOrchestration.EXTERNAL_LEADER_DRIVEN`` is eligible to be spawned and
+    addressed directly by the leader (via ``execute_task`` + a resumable
+    ``RuntimeHandle``), regardless of backend name. This is what a future
+    worker-pool scheduler reads — NOT a backend-name check — so adding Claude,
+    Gemini, or a codex-mcp runtime is "declare the mode + supply a thin
+    transport", never a bespoke dispatch path.
+    """
+    return capabilities.subagent_orchestration is SubagentOrchestration.EXTERNAL_LEADER_DRIVEN
+
+
+def is_host_bridge_dispatch(capabilities: RuntimeCapabilities) -> bool:
+    """Return whether this runtime dispatches sub-agents via the host-bridge envelope."""
+    return capabilities.subagent_orchestration is SubagentOrchestration.EXTERNAL_HOST_BRIDGE
+
+
 @dataclass(frozen=True, slots=True)
 class RuntimeCapabilities:
     """Declarative feature contract surfaced by an ``AgentRuntime``.
@@ -767,6 +871,11 @@ class RuntimeCapabilities:
     # enforced — keeping the proof's enforced rows truthful. ``None`` means "no
     # per-level restriction" (any level is enforced when support is NATIVE).
     enforceable_reasoning_efforts: frozenset[str] | None = None
+    # How the orchestrator may fan work out to sub-agents on this backend (see
+    # :class:`SubagentOrchestration`). Defaults to NONE so a backend opts in to
+    # INTERNAL/EXTERNAL only when its surface demonstrably supports it — this is
+    # the capability the sub-agent dispatch gate reads instead of a backend name.
+    subagent_orchestration: SubagentOrchestration = SubagentOrchestration.NONE
 
 
 # Default capability profile for first-class backends (Claude, Codex).
@@ -873,17 +982,16 @@ MAX_RETRIES: int = 3
 RETRY_WAIT_INITIAL: float = 1.0  # seconds
 RETRY_WAIT_MAX: float = 10.0  # seconds
 
-# Error patterns that indicate transient failures worth retrying
+# Error patterns that indicate transient failures worth retrying.
+#
+# Derived from the canonical transient core in ``providers.retry`` plus the one
+# execution-specific signal (``"exit code 1"`` — the SDK CLI process failing).
+# Adopting the shared core fixes a real divergence: this adapter previously did
+# NOT retry on ``"overloaded"`` (Anthropic 529), the most common transient error
+# under load, even though the completion adapters did. The shared tuple closes
+# that gap without dropping any pattern this adapter already matched.
 TRANSIENT_ERROR_PATTERNS: tuple[str, ...] = (
-    "concurrency",
-    "rate limit",
-    "429",
-    "500",
-    "502",
-    "503",
-    "504",
-    "timeout",
-    "connection",
+    *_SHARED_TRANSIENT_ERROR_PATTERNS,
     "exit code 1",  # SDK CLI process failed
 )
 
@@ -1761,7 +1869,11 @@ __all__ = [
     "RuntimeCapabilities",
     "RuntimeHandle",
     "SkillDispatchHandler",
+    "SubagentOrchestration",
     "TaskResult",
+    "is_host_bridge_dispatch",
+    "is_leader_driven_worker",
+    "subagent_orchestration_for_backend",
     "runtime_handle_tool_catalog",
     "runtime_handle_capability_graph",
     "runtime_handle_control_plane",