ouroboros-ai 0.43.2.dev2__tar.gz → 0.43.3.dev2__tar.gz

{ouroboros_ai-0.43.2.dev2 → ouroboros_ai-0.43.3.dev2}/.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.2",
+      "version": "0.43.3",
       "author": {
         "name": "Q00",
         "email": "jqyu.lee@gmail.com"

{ouroboros_ai-0.43.2.dev2 → ouroboros_ai-0.43.3.dev2}/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "ouroboros",
-  "version": "0.43.2",
+  "version": "0.43.3",
   "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.2.dev2 → ouroboros_ai-0.43.3.dev2}/.claude-plugin/skills/interview/SKILL.md

@@ -171,10 +171,13 @@ MCP (question generator) ←→ You (answerer + router) ←→ User (human judgm
    it must not hide, replace, or delay the question itself.
 
    Run the advisory lanes in parallel using your host's native subagent
-   primitive. In Claude Code that primitive is the **Task/Agent tool** — spawn
-   one subagent per lane in a single batch so they run concurrently. Only fall
-   back to the request's `sequential_fallback` semantics when the host has no
-   subagent primitive at all. The standard lanes are:
+   mechanism. In Claude Code that mechanism is the **Task/Agent tool** — spawn
+   one subagent per lane in a single batch so they run concurrently. In Codex,
+   explicitly start a native subagent workflow in natural language: spawn one
+   Codex subagent per lane, pass that lane's payload prompt, wait for all
+   agents, then synthesize. Only fall back to the request's
+   `sequential_fallback` semantics when the host has no subagent mechanism at
+   all. The standard lanes are:
    - `code_context` — inspect repo-local facts and reuse
      `meta.code_investigation_request` when present.
    - `web_context` — browse/search only when current external facts genuinely
@@ -193,9 +196,11 @@ MCP (question generator) ←→ You (answerer + router) ←→ User (human judgm
    When `meta.question_advisory_subagents` is present you MUST fan out: treat
    each entry as a spawn-ready advisory payload with `title`, `agent`, `prompt`,
    and `context`, and dispatch every payload through your host's native subagent
-   primitive (Claude Code → one Task/Agent call per payload, all in one parallel
-   batch) instead of reconstructing prompts from prose. This is required
-   regardless of dispatch mode: the payloads themselves are the spawn signal.
+   mechanism (Claude Code → one Task/Agent call per payload in one parallel
+   batch; Codex → explicitly spawn one Codex subagent per payload, wait for all
+   results, then synthesize) instead of reconstructing prompts from prose. This
+   is required regardless of dispatch mode: the payloads themselves are the
+   spawn signal.
    Treat `meta.question_advisory_host_action=spawn_subagents`, when present, as
    a reinforcing cue for host-driven runtimes such as Codex or Claude Code, not
    as a prerequisite. The only time you skip spawning is when the host has no

{ouroboros_ai-0.43.2.dev2 → ouroboros_ai-0.43.3.dev2}/.claude-plugin/skills/unstuck/SKILL.md

@@ -151,7 +151,9 @@ Driving fan-out from this dispatch block — instead of from the joined human-di
 
 1. Locate the dispatch block at the end of the MCP response's `content` text — the substring between `<!-- ouroboros-lateral-inline-dispatch-v1 base64\n` and `\n-->`. Base64-decode the captured body, then `JSON.parse` to get `{dispatch_mode, persona_count, payloads}`. If the block is missing (older handler that pre-dates the v1 sentinel), fall through to the constrained-runtime path below — *do not* split the joined text.
 2. Surface a short "what the lateral toolkit suggests" header to the user, with the markdown above the dispatch block, so the MCP call is visible as a real product surface, not silent.
-3. In a **single message**, emit N parallel `Task` calls (`general-purpose` subagent) — one per entry in `payloads`. Each Task receives the payload's `prompt` verbatim plus the payload's `context` so the persona is grounded. Strict isolation per Task. The user sees "Running N agents…".
+3. Spawn N persona subagents in parallel — one per entry in `payloads` — using your host's native subagent mechanism. Each child receives the payload's `prompt` verbatim plus the payload's `context` so the persona is grounded, with strict isolation per child. The user sees "Running N agents…".
+   - **Claude Code** → emit N `Task` calls (`general-purpose` subagent) in a **single message** so they run concurrently.
+   - **Codex** → Codex subagents are triggered by explicit natural-language delegation, not a callable tool name (do NOT call `multi_agent_v1.spawn_agent` — it does not exist). In one turn, explicitly spawn one Codex subagent per payload, hand each child its payload `prompt` + `context`, wait for all children, then continue.
 4. Wait for all N to return.
 5. (Optional) **Round 2 cross-attack** — only if Round 1 answers diverge meaningfully. Dispatch a second N-fan-out where each persona receives short summaries of the other answers and is asked: "Identify one weakness in each. ≤200 words." Skip if Round 1 already converges.
 6. Synthesize per the **Synthesize** block below.
@@ -226,8 +228,9 @@ with 2 tables, you haven't found the core feature yet.
                   followed by hidden <!-- ouroboros-lateral-inline-dispatch-v1 base64
                   <base64 body> --> sentinel block]
 [Extract via the sentinel; base64-decode then JSON.parse → payloads[]]
-[Single message: 5 parallel Task calls — one per payloads[] entry,
- each Task receives payload.prompt + payload.context verbatim;
+[Spawn 5 parallel persona subagents — one per payloads[] entry — via the
+ host's native mechanism (Claude: Task calls; Codex: explicit NL delegation);
+ each child receives payload.prompt + payload.context verbatim;
  the visible markdown is shown to the user as the lateral scaffold]
 [User sees "Running 5 agents…"]
 [Round 1 returns]

{ouroboros_ai-0.43.2.dev2 → ouroboros_ai-0.43.3.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ouroboros-ai
-Version: 0.43.2.dev2
+Version: 0.43.3.dev2
 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.2.dev2 → ouroboros_ai-0.43.3.dev2}/skills/interview/SKILL.md

@@ -171,10 +171,13 @@ MCP (question generator) ←→ You (answerer + router) ←→ User (human judgm
    it must not hide, replace, or delay the question itself.
 
    Run the advisory lanes in parallel using your host's native subagent
-   primitive. In Claude Code that primitive is the **Task/Agent tool** — spawn
-   one subagent per lane in a single batch so they run concurrently. Only fall
-   back to the request's `sequential_fallback` semantics when the host has no
-   subagent primitive at all. The standard lanes are:
+   mechanism. In Claude Code that mechanism is the **Task/Agent tool** — spawn
+   one subagent per lane in a single batch so they run concurrently. In Codex,
+   explicitly start a native subagent workflow in natural language: spawn one
+   Codex subagent per lane, pass that lane's payload prompt, wait for all
+   agents, then synthesize. Only fall back to the request's
+   `sequential_fallback` semantics when the host has no subagent mechanism at
+   all. The standard lanes are:
    - `code_context` — inspect repo-local facts and reuse
      `meta.code_investigation_request` when present.
    - `web_context` — browse/search only when current external facts genuinely
@@ -193,9 +196,11 @@ MCP (question generator) ←→ You (answerer + router) ←→ User (human judgm
    When `meta.question_advisory_subagents` is present you MUST fan out: treat
    each entry as a spawn-ready advisory payload with `title`, `agent`, `prompt`,
    and `context`, and dispatch every payload through your host's native subagent
-   primitive (Claude Code → one Task/Agent call per payload, all in one parallel
-   batch) instead of reconstructing prompts from prose. This is required
-   regardless of dispatch mode: the payloads themselves are the spawn signal.
+   mechanism (Claude Code → one Task/Agent call per payload in one parallel
+   batch; Codex → explicitly spawn one Codex subagent per payload, wait for all
+   results, then synthesize) instead of reconstructing prompts from prose. This
+   is required regardless of dispatch mode: the payloads themselves are the
+   spawn signal.
    Treat `meta.question_advisory_host_action=spawn_subagents`, when present, as
    a reinforcing cue for host-driven runtimes such as Codex or Claude Code, not
    as a prerequisite. The only time you skip spawning is when the host has no

{ouroboros_ai-0.43.2.dev2 → ouroboros_ai-0.43.3.dev2}/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.2 -->
+<!-- ooo:VERSION:0.43.3 -->
 # Ouroboros — Specification-First AI Development
 
 > Before telling AI what to build, define what should be built.

{ouroboros_ai-0.43.2.dev2 → ouroboros_ai-0.43.3.dev2}/skills/unstuck/SKILL.md

@@ -151,7 +151,9 @@ Driving fan-out from this dispatch block — instead of from the joined human-di
 
 1. Locate the dispatch block at the end of the MCP response's `content` text — the substring between `<!-- ouroboros-lateral-inline-dispatch-v1 base64\n` and `\n-->`. Base64-decode the captured body, then `JSON.parse` to get `{dispatch_mode, persona_count, payloads}`. If the block is missing (older handler that pre-dates the v1 sentinel), fall through to the constrained-runtime path below — *do not* split the joined text.
 2. Surface a short "what the lateral toolkit suggests" header to the user, with the markdown above the dispatch block, so the MCP call is visible as a real product surface, not silent.
-3. In a **single message**, emit N parallel `Task` calls (`general-purpose` subagent) — one per entry in `payloads`. Each Task receives the payload's `prompt` verbatim plus the payload's `context` so the persona is grounded. Strict isolation per Task. The user sees "Running N agents…".
+3. Spawn N persona subagents in parallel — one per entry in `payloads` — using your host's native subagent mechanism. Each child receives the payload's `prompt` verbatim plus the payload's `context` so the persona is grounded, with strict isolation per child. The user sees "Running N agents…".
+   - **Claude Code** → emit N `Task` calls (`general-purpose` subagent) in a **single message** so they run concurrently.
+   - **Codex** → Codex subagents are triggered by explicit natural-language delegation, not a callable tool name (do NOT call `multi_agent_v1.spawn_agent` — it does not exist). In one turn, explicitly spawn one Codex subagent per payload, hand each child its payload `prompt` + `context`, wait for all children, then continue.
 4. Wait for all N to return.
 5. (Optional) **Round 2 cross-attack** — only if Round 1 answers diverge meaningfully. Dispatch a second N-fan-out where each persona receives short summaries of the other answers and is asked: "Identify one weakness in each. ≤200 words." Skip if Round 1 already converges.
 6. Synthesize per the **Synthesize** block below.
@@ -226,8 +228,9 @@ with 2 tables, you haven't found the core feature yet.
                   followed by hidden <!-- ouroboros-lateral-inline-dispatch-v1 base64
                   <base64 body> --> sentinel block]
 [Extract via the sentinel; base64-decode then JSON.parse → payloads[]]
-[Single message: 5 parallel Task calls — one per payloads[] entry,
- each Task receives payload.prompt + payload.context verbatim;
+[Spawn 5 parallel persona subagents — one per payloads[] entry — via the
+ host's native mechanism (Claude: Task calls; Codex: explicit NL delegation);
+ each child receives payload.prompt + payload.context verbatim;
  the visible markdown is shown to the user as the lateral scaffold]
 [User sees "Running 5 agents…"]
 [Round 1 returns]

{ouroboros_ai-0.43.2.dev2 → ouroboros_ai-0.43.3.dev2}/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.2.dev2'
-__version_tuple__ = version_tuple = (0, 43, 2, 'dev2')
+__version__ = version = '0.43.3.dev2'
+__version_tuple__ = version_tuple = (0, 43, 3, 'dev2')
 
 __commit_id__ = commit_id = None

{ouroboros_ai-0.43.2.dev2 → ouroboros_ai-0.43.3.dev2}/src/ouroboros/backends/__init__.py

@@ -5,6 +5,7 @@ from ouroboros.backends.capabilities import (
     RuntimeSubagentOrchestrationContract,
     SkillExecutionCapability,
     SubagentDispatchMode,
+    SubagentSpawnTriggerMechanism,
     backend_supports_tool_envelope,
     build_runtime_subagent_orchestration_contract,
     get_backend_capability,
@@ -25,6 +26,7 @@ __all__ = [
     "RuntimeSubagentOrchestrationContract",
     "SkillExecutionCapability",
     "SubagentDispatchMode",
+    "SubagentSpawnTriggerMechanism",
     "backend_supports_tool_envelope",
     "build_runtime_subagent_orchestration_contract",
     "get_backend_capability",

{ouroboros_ai-0.43.2.dev2 → ouroboros_ai-0.43.3.dev2}/src/ouroboros/backends/capabilities.py

@@ -43,6 +43,10 @@ class BackendCapability:
     # backend can have the latter without the former. Do NOT conflate them.
     supports_native_parallel_subagents: bool = False
     supports_host_driven_subagents: bool = False
+    host_driven_subagent_mechanism: SubagentSpawnTriggerMechanism | None = None
+    host_driven_subagent_requires_explicit_request: bool = False
+    host_driven_callable_spawn_tool_name: str | None = None
+    prohibited_subagent_spawn_tool_names: tuple[str, ...] = ()
     skill_execution_capabilities: tuple[SkillExecutionCapability, ...] = ()
 
     @property
@@ -73,6 +77,15 @@ class SubagentDispatchMode(StrEnum):
     SEQUENTIAL = "sequential"
 
 
+class SubagentSpawnTriggerMechanism(StrEnum):
+    """Concrete runtime mechanism used after dispatch mode is resolved."""
+
+    PASSIVE_BRIDGE_ENVELOPE = "passive_bridge_envelope"
+    CODEX_NATURAL_LANGUAGE_DELEGATION = "codex_natural_language_delegation"
+    CLAUDE_TASK_AGENT_TOOL = "claude_task_agent_tool"
+    SEQUENTIAL_FALLBACK = "sequential_fallback"
+
+
 @dataclass(frozen=True, slots=True)
 class RuntimeSubagentOrchestrationContract:
     """Runtime handling contract for MCP subagent directive metadata."""
@@ -80,6 +93,10 @@ class RuntimeSubagentOrchestrationContract:
     backend_name: str
     supports_native_parallel_subagents: bool
     dispatch_mode: str
+    spawn_trigger_mechanism: str
+    requires_explicit_spawn_request: bool
+    callable_spawn_tool_name: str | None
+    prohibited_spawn_tool_names: tuple[str, ...]
     mcp_directive_keys: tuple[str, ...]
     sequential_fallback: Mapping[str, Any]
     runtime_instruction_handling: str
@@ -91,6 +108,10 @@ class RuntimeSubagentOrchestrationContract:
             "backend_name": self.backend_name,
             "supports_native_parallel_subagents": self.supports_native_parallel_subagents,
             "dispatch_mode": self.dispatch_mode,
+            "spawn_trigger_mechanism": self.spawn_trigger_mechanism,
+            "requires_explicit_spawn_request": self.requires_explicit_spawn_request,
+            "callable_spawn_tool_name": self.callable_spawn_tool_name,
+            "prohibited_spawn_tool_names": list(self.prohibited_spawn_tool_names),
             "mcp_directive_keys": list(self.mcp_directive_keys),
             "sequential_fallback": dict(self.sequential_fallback),
             "runtime_instruction_handling": self.runtime_instruction_handling,
@@ -186,9 +207,12 @@ _CODEX_SKILL_EXECUTION_CAPABILITIES: tuple[SkillExecutionCapability, ...] = (
             "`question_advisory_dispatch_mode=host_driven` in the result `meta`, or "
             "the `ouroboros-lateral-inline-dispatch-v1` content block), do NOT just "
             "read the inline text: spawn one subagent per entry in the payload array "
-            "(`payloads` or `question_advisory_subagents`) using your native "
-            "multi-agent spawn primitive (`multi_agent_v1.spawn_agent`), passing "
-            "each payload's `prompt`. Correlate every child result by the "
+            "(`payloads` or `question_advisory_subagents`) using Codex's native "
+            "subagent workflow. Codex subagents are triggered by an explicit "
+            "natural-language delegation, not by a callable tool name: explicitly "
+            "spawn one Codex subagent per payload, give each child the payload's "
+            "`prompt`, wait for all children, then summarize the results. Correlate "
+            "every child result by the "
             "payload-specific key named in the result `meta` "
             "(`result_correlation_key`): lateral payloads use `context.persona`, "
             "interview advisory payloads use `context.lane_id` (their `persona` is "
@@ -293,6 +317,9 @@ _CAPABILITIES: tuple[BackendCapability, ...] = (
         cli_config_key="cli_path",
         skill_execution_capabilities=_CLAUDE_SKILL_EXECUTION_CAPABILITIES,
         supports_host_driven_subagents=True,
+        host_driven_subagent_mechanism=SubagentSpawnTriggerMechanism.CLAUDE_TASK_AGENT_TOOL,
+        host_driven_subagent_requires_explicit_request=True,
+        host_driven_callable_spawn_tool_name="Task/Agent",
     ),
     BackendCapability(
         name="codex",
@@ -305,6 +332,12 @@ _CAPABILITIES: tuple[BackendCapability, ...] = (
         cli_config_key="codex_cli_path",
         skill_execution_capabilities=_CODEX_SKILL_EXECUTION_CAPABILITIES,
         supports_host_driven_subagents=True,
+        host_driven_subagent_mechanism=(
+            SubagentSpawnTriggerMechanism.CODEX_NATURAL_LANGUAGE_DELEGATION
+        ),
+        host_driven_subagent_requires_explicit_request=True,
+        host_driven_callable_spawn_tool_name=None,
+        prohibited_subagent_spawn_tool_names=("multi_agent_v1.spawn_agent",),
     ),
     BackendCapability(
         name="copilot",
@@ -478,6 +511,10 @@ def build_runtime_subagent_orchestration_contract(
     dispatch_mode = mode.value
 
     if mode is SubagentDispatchMode.PLUGIN_PASSIVE:
+        spawn_trigger_mechanism = SubagentSpawnTriggerMechanism.PASSIVE_BRIDGE_ENVELOPE
+        requires_explicit_spawn_request = False
+        callable_spawn_tool_name = None
+        prohibited_spawn_tool_names: tuple[str, ...] = ()
         runtime_instruction_handling = (
             "Consume MCP `_subagent` or `_subagents` directive payloads with the "
             "runtime's native parallel subagent primitive. For OpenCode this "
@@ -486,6 +523,13 @@ def build_runtime_subagent_orchestration_contract(
             "surfaces."
         )
     elif mode is SubagentDispatchMode.HOST_DRIVEN:
+        spawn_trigger_mechanism = (
+            capability.host_driven_subagent_mechanism
+            or SubagentSpawnTriggerMechanism.SEQUENTIAL_FALLBACK
+        )
+        requires_explicit_spawn_request = capability.host_driven_subagent_requires_explicit_request
+        callable_spawn_tool_name = capability.host_driven_callable_spawn_tool_name
+        prohibited_spawn_tool_names = capability.prohibited_subagent_spawn_tool_names
         runtime_instruction_handling = (
             "This runtime has a native subagent primitive but no passive "
             "Ouroboros bridge. Consume the inline `host_driven` dispatch payloads "
@@ -496,6 +540,10 @@ def build_runtime_subagent_orchestration_contract(
             "parallel primitive is available."
         )
     else:
+        spawn_trigger_mechanism = SubagentSpawnTriggerMechanism.SEQUENTIAL_FALLBACK
+        requires_explicit_spawn_request = False
+        callable_spawn_tool_name = None
+        prohibited_spawn_tool_names = ()
         runtime_instruction_handling = (
             "This runtime has no native parallel subagent primitive. Follow the "
             "MCP `sequential_fallback` contract and process each structured "
@@ -509,6 +557,10 @@ def build_runtime_subagent_orchestration_contract(
         # report False here and carry their capability via ``dispatch_mode``.
         supports_native_parallel_subagents=mode is SubagentDispatchMode.PLUGIN_PASSIVE,
         dispatch_mode=dispatch_mode,
+        spawn_trigger_mechanism=spawn_trigger_mechanism.value,
+        requires_explicit_spawn_request=requires_explicit_spawn_request,
+        callable_spawn_tool_name=callable_spawn_tool_name,
+        prohibited_spawn_tool_names=prohibited_spawn_tool_names,
         mcp_directive_keys=("_subagent", "_subagents"),
         sequential_fallback=dict(sequential_fallback),
         runtime_instruction_handling=runtime_instruction_handling,
@@ -642,6 +694,7 @@ __all__ = [
     "RuntimeSubagentOrchestrationContract",
     "SkillExecutionCapability",
     "SubagentDispatchMode",
+    "SubagentSpawnTriggerMechanism",
     "backend_supports_tool_envelope",
     "build_runtime_subagent_orchestration_contract",
     "get_backend_capability",

{ouroboros_ai-0.43.2.dev2 → ouroboros_ai-0.43.3.dev2}/src/ouroboros/cli/commands/run.py

@@ -22,7 +22,7 @@ if TYPE_CHECKING:
 from ouroboros.cli.formatters import console
 from ouroboros.cli.formatters.panels import print_error, print_info, print_success, print_warning
 from ouroboros.config._model_defaults import DEFAULT_SONNET_MODEL
-from ouroboros.config.loader import get_max_parallel_workers
+from ouroboros.config.loader import get_config_dir, get_max_parallel_workers, load_config
 from ouroboros.core.errors import ConfigError
 from ouroboros.core.project_paths import resolve_path_against_base, resolve_seed_project_path
 from ouroboros.core.security import InputValidator
@@ -46,6 +46,46 @@ def _resolve_execution_model(runtime_backend: str | None) -> str | None:
     return None
 
 
+def _resolve_run_execute_runtime_backend(
+    runtime_backend: str | None,
+    *,
+    resolve_backend,
+) -> str:
+    """Resolve the agent runtime backend used by ``ooo run`` execution.
+
+    ``--runtime`` remains an explicit whole-run override. Without it, the CLI
+    honors ``orchestrator.runtime_profile.stages.execute`` with the same
+    precedence as auto/MCP: execute stage mapping, profile default, then
+    ``orchestrator.runtime_backend``.
+    """
+
+    resolved_default = resolve_backend(runtime_backend)
+    if runtime_backend is not None:
+        return resolved_default
+
+    from ouroboros.orchestrator_stage import Stage, parse_stage, resolve_runtime_for_stage
+
+    try:
+        profile = load_config().orchestrator.runtime_profile
+    except ConfigError:
+        if (get_config_dir() / "config.yaml").exists():
+            raise
+        profile = None
+
+    if profile is None:
+        return resolved_default
+
+    profile_stages = {parse_stage(key): value for key, value in profile.stages.items()}
+    return resolve_backend(
+        resolve_runtime_for_stage(
+            Stage.EXECUTE,
+            stages=profile_stages,
+            default=profile.default,
+            fallback=resolved_default,
+        )
+    )
+
+
 class _DefaultWorkflowGroup(typer.core.TyperGroup):
     """TyperGroup that falls back to 'workflow' when no subcommand matches.
 
@@ -535,7 +575,11 @@ async def _run_orchestrator(
         project_dir: Optional explicit project directory for seed path resolution.
     """
     from ouroboros.core.seed import Seed
-    from ouroboros.orchestrator import OrchestratorRunner, create_agent_runtime
+    from ouroboros.orchestrator import (
+        OrchestratorRunner,
+        create_agent_runtime,
+        resolve_agent_runtime_backend,
+    )
     from ouroboros.orchestrator.session import SessionRepository
     from ouroboros.persistence.event_store import EventStore
 
@@ -630,9 +674,16 @@ async def _run_orchestrator(
         print_info(f"Task worktree: {workspace.worktree_path}")
         print_info(f"Task branch: {workspace.branch}")
 
+    resolved_runtime_backend = _resolve_run_execute_runtime_backend(
+        runtime_backend,
+        resolve_backend=resolve_agent_runtime_backend,
+    )
+    if debug:
+        print_info(f"Execution runtime: {resolved_runtime_backend}")
+
     adapter = create_agent_runtime(
-        backend=runtime_backend,
-        model=_resolve_execution_model(runtime_backend),
+        backend=resolved_runtime_backend,
+        model=_resolve_execution_model(resolved_runtime_backend),
         cwd=Path(workspace.effective_cwd) if workspace else project_dir,
     )
     runner = OrchestratorRunner(

{ouroboros_ai-0.43.2.dev2 → ouroboros_ai-0.43.3.dev2}/tests/unit/backends/test_capabilities.py

@@ -4,6 +4,7 @@ from jsonschema import Draft202012Validator
 import pytest
 
 from ouroboros.backends import (
+    SubagentSpawnTriggerMechanism,
     backend_supports_tool_envelope,
     build_runtime_subagent_orchestration_contract,
     get_backend_capability,
@@ -147,12 +148,21 @@ def test_codex_host_driven_subagent_orchestration_is_registry_owned() -> None:
     assert capability is not None
     assert capability.supports_host_driven_subagents is True
     assert capability.supports_native_parallel_subagents is False
+    assert (
+        capability.host_driven_subagent_mechanism
+        is SubagentSpawnTriggerMechanism.CODEX_NATURAL_LANGUAGE_DELEGATION
+    )
+    assert capability.host_driven_subagent_requires_explicit_request is True
+    assert capability.host_driven_callable_spawn_tool_name is None
+    assert "multi_agent_v1.spawn_agent" in capability.prohibited_subagent_spawn_tool_names
 
     guide = render_backend_skill_capability_guide("codex")
     assert "### When a skill requires `orchestrate_subagents`" in guide
     assert "dispatch_mode=host_driven" in guide
     assert "host_action=spawn_subagents" in guide
-    assert "multi_agent_v1.spawn_agent" in guide
+    assert "native subagent workflow" in guide
+    assert "explicit natural-language delegation" in guide
+    assert "multi_agent_v1.spawn_agent" not in guide
     # Correlation keys are payload-specific — the guide must not tell the host to
     # blanket-correlate advisory results by persona (absent on some lanes).
     assert "context.persona" in guide
@@ -166,6 +176,12 @@ def test_claude_host_driven_subagent_orchestration_is_registry_owned() -> None:
     assert capability is not None
     assert capability.supports_host_driven_subagents is True
     assert capability.supports_native_parallel_subagents is False
+    assert (
+        capability.host_driven_subagent_mechanism
+        is SubagentSpawnTriggerMechanism.CLAUDE_TASK_AGENT_TOOL
+    )
+    assert capability.host_driven_subagent_requires_explicit_request is True
+    assert capability.host_driven_callable_spawn_tool_name == "Task/Agent"
     names = {item.name for item in capability.skill_execution_capabilities}
     assert names == REQUIRED_SKILL_CAPABILITY_NAMES | {"orchestrate_subagents"}
 
@@ -245,6 +261,45 @@ def test_host_driven_runtime_gets_host_driven_contract(
     assert "no passive" in contract.runtime_instruction_handling
 
 
+def test_codex_subagent_contract_codifies_documented_natural_language_trigger() -> None:
+    """Codex subagents are explicit NL delegation, not a callable spawn tool."""
+    contract = build_runtime_subagent_orchestration_contract(
+        "codex",
+        directive_metadata=_LATERAL_PANEL_DIRECTIVE_METADATA,
+    )
+
+    assert contract.dispatch_mode == "host_driven"
+    assert (
+        contract.spawn_trigger_mechanism
+        == SubagentSpawnTriggerMechanism.CODEX_NATURAL_LANGUAGE_DELEGATION.value
+    )
+    assert contract.requires_explicit_spawn_request is True
+    assert contract.callable_spawn_tool_name is None
+    assert contract.prohibited_spawn_tool_names == ("multi_agent_v1.spawn_agent",)
+
+    envelope = contract.to_dict()
+    assert envelope["spawn_trigger_mechanism"] == "codex_natural_language_delegation"
+    assert envelope["requires_explicit_spawn_request"] is True
+    assert envelope["callable_spawn_tool_name"] is None
+    assert envelope["prohibited_spawn_tool_names"] == ["multi_agent_v1.spawn_agent"]
+
+
+def test_claude_subagent_contract_codifies_task_agent_trigger() -> None:
+    contract = build_runtime_subagent_orchestration_contract(
+        "claude_code",
+        directive_metadata=_LATERAL_PANEL_DIRECTIVE_METADATA,
+    )
+
+    assert contract.dispatch_mode == "host_driven"
+    assert (
+        contract.spawn_trigger_mechanism
+        == SubagentSpawnTriggerMechanism.CLAUDE_TASK_AGENT_TOOL.value
+    )
+    assert contract.requires_explicit_spawn_request is True
+    assert contract.callable_spawn_tool_name == "Task/Agent"
+    assert contract.prohibited_spawn_tool_names == ()
+
+
 @pytest.mark.parametrize("directive_metadata", [{}, {"sequential_fallback": "invalid"}])
 def test_subagent_orchestration_contract_handles_absent_or_malformed_fallback(
     directive_metadata: dict[str, object],

{ouroboros_ai-0.43.2.dev2 → ouroboros_ai-0.43.3.dev2}/tests/unit/cli/test_run_qa.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 from pathlib import Path
 from types import SimpleNamespace
-from unittest.mock import AsyncMock, MagicMock, patch
+from unittest.mock import ANY, AsyncMock, MagicMock, patch
 
 import pytest
 import typer
@@ -729,7 +729,7 @@ async def test_run_orchestrator_uses_seed_relative_project_dir_for_runtime_and_q
         mock_event_store_cls.return_value.initialize = AsyncMock()
         await _run_orchestrator(seed_file)
 
-    mock_runtime.assert_called_once_with(backend=None, model=None, cwd=expected_project_dir)
+    mock_runtime.assert_called_once_with(backend=ANY, model=ANY, cwd=expected_project_dir)
     mock_verification.assert_awaited_once_with(
         "exec-test",
         "Parallel Execution Verification Report",

ouroboros_ai-0.43.3.dev2/tests/unit/cli/test_run_runtime_routing.py

@@ -0,0 +1,90 @@
+from __future__ import annotations
+
+import pytest
+
+from ouroboros.cli.commands import run
+from ouroboros.config.models import OrchestratorConfig, OuroborosConfig, RuntimeProfileConfig
+from ouroboros.core.errors import ConfigError
+
+
+def test_run_execute_runtime_honors_runtime_profile(monkeypatch) -> None:
+    config = OuroborosConfig(
+        orchestrator=OrchestratorConfig(
+            runtime_backend="claude",
+            runtime_profile=RuntimeProfileConfig(stages={"execute": "opencode"}),
+        )
+    )
+    monkeypatch.setattr(run, "load_config", lambda: config)
+
+    resolved = run._resolve_run_execute_runtime_backend(
+        None,
+        resolve_backend=lambda value=None: value or "claude",
+    )
+
+    assert resolved == "opencode"
+
+
+def test_run_explicit_runtime_overrides_runtime_profile(monkeypatch) -> None:
+    config = OuroborosConfig(
+        orchestrator=OrchestratorConfig(
+            runtime_backend="claude",
+            runtime_profile=RuntimeProfileConfig(stages={"execute": "opencode"}),
+        )
+    )
+    monkeypatch.setattr(run, "load_config", lambda: config)
+
+    resolved = run._resolve_run_execute_runtime_backend(
+        "codex",
+        resolve_backend=lambda value=None: value or "claude",
+    )
+
+    assert resolved == "codex"
+
+
+def test_run_runtime_profile_config_error_fails_fast_when_config_exists(
+    monkeypatch, tmp_path
+) -> None:
+    def _raise() -> OuroborosConfig:
+        raise ConfigError("bad runtime_profile")
+
+    (tmp_path / "config.yaml").write_text("orchestrator: {}\n")
+    monkeypatch.setattr(run, "load_config", _raise)
+    monkeypatch.setattr(run, "get_config_dir", lambda: tmp_path)
+
+    with pytest.raises(ConfigError):
+        run._resolve_run_execute_runtime_backend(
+            None,
+            resolve_backend=lambda value=None: value or "claude",
+        )
+
+
+def test_run_execute_runtime_honors_runtime_profile_default(monkeypatch) -> None:
+    config = OuroborosConfig(
+        orchestrator=OrchestratorConfig(
+            runtime_backend="claude",
+            runtime_profile=RuntimeProfileConfig(default="opencode"),
+        )
+    )
+    monkeypatch.setattr(run, "load_config", lambda: config)
+
+    resolved = run._resolve_run_execute_runtime_backend(
+        None,
+        resolve_backend=lambda value=None: value or "claude",
+    )
+
+    assert resolved == "opencode"
+
+
+def test_run_runtime_profile_absent_config_falls_back(monkeypatch, tmp_path) -> None:
+    def _raise() -> OuroborosConfig:
+        raise ConfigError("Configuration file not found")
+
+    monkeypatch.setattr(run, "load_config", _raise)
+    monkeypatch.setattr(run, "get_config_dir", lambda: tmp_path)
+
+    resolved = run._resolve_run_execute_runtime_backend(
+        None,
+        resolve_backend=lambda value=None: value or "claude",
+    )
+
+    assert resolved == "claude"

{ouroboros_ai-0.43.2.dev2 → ouroboros_ai-0.43.3.dev2}/tests/unit/test_claude_plugin_skill_guide.py

@@ -19,6 +19,7 @@ def test_claude_plugin_interview_skill_includes_lateral_review_dispatch() -> Non
 
     assert "question_advisory_subagents` is present you MUST fan out" in skill_text
     assert "Task/Agent" in skill_text
+    assert "spawn one Codex subagent per payload" in skill_text
     assert "a reinforcing cue for host-driven runtimes" in skill_text
     assert "as a prerequisite" in skill_text
     assert "`run_lateral_review`" in skill_text