Struct Orchestrator 

pub struct Orchestrator { /* private fields */ }

The orchestrator coordinates the full Ouroboros lifecycle.

Implementations

impl Orchestrator

pub fn new( ouroboros: Arc<dyn OuroborosProtocol>, event_bus: EventBus, state_store: Arc<StateStore>, lifecycle: AgentLifecycleManager, ) -> Self

Creates a new orchestrator.

pub fn with_config( ouroboros: Arc<dyn OuroborosProtocol>, event_bus: EventBus, state_store: Arc<StateStore>, lifecycle: AgentLifecycleManager, _config: OrchestratorConfig, ) -> Self

Creates a new orchestrator with custom config.

pub fn set_intent_engine(&self, engine: Arc<dyn IntentEngineOps>)

Wire the IntentEngine for unified handle() calls (RFC-027). Called by the kernel assembler after construction.

pub fn has_intent_engine(&self) -> bool

Whether the IntentEngine is wired (unified path available).

pub fn set_project_manager(&self, manager: Arc<ProjectManager>)

Set the ProjectManager for context partitioning.

pub fn set_mount_manager(&self, manager: Arc<MountManager>)

Set the MountManager for path-alias context (RFC-025).

pub fn mount_manager(&self) -> Option<Arc<MountManager>>

Get a reference to the MountManager, if set (RFC-025).

pub fn project_manager(&self) -> Option<Arc<ProjectManager>>

Get a reference to the ProjectManager, if set.

pub fn detect_project_tag(&self, message: &str) -> Option<String>

Detect a project from a message, returning tag string.

pub fn set_a2a(&mut self, a2a: Arc<A2AProtocol>)

Set the A2A protocol for inter-agent task delegation.

pub fn set_git_layer(&mut self, git_layer: Arc<GitLayer>)

Set the GitLayer for auto-commits after state saves.

pub async fn restore_sessions(&self)

Restore sessions from persisted state.

Loads sessions from the StateStore that have an active_seed_id (meaning they are mid-orchestration) and repopulates the in-memory interview session map so that follow-up messages can continue the conversation.

pub async fn delegate_subtasks( &self, subtasks: Vec<SubTask>, parent_seed: &Seed, ) -> Result<Vec<SubTask>>

Execute multiple subtasks using separate agents in parallel.

When A2A is available, the orchestrator delegates tasks through the A2A protocol with circuit breaker and retry support. Otherwise, falls back to direct lifecycle execution.

Results are collected as they complete using JoinSet.

pub async fn handle( &self, engine: &dyn IntentEngineOps, msg: &str, ctx: &MsgCtx, ) -> Result<HandleResponse>

Unified entry point for every user message (RFC-027 §3).

One method, one match — depth falls out of [Scope]:

1. [IntentEngine::assess] classifies the message (conversation / clarify / task + scope). Always called once.
2. For Assessment::Task(scope) we build a [Directive]:
   • Scope::Trivial — Directive::from_message(msg) verbatim.
   • Scope::Substantial — [IntentEngine::crystallize] produces a structured directive with goal, constraints, and acceptance criteria.
3. The [ExecEnv] is resolved from [MsgCtx] independently of the directive (Mount workspace context, paths, project ID, cspace hint).
4. Execution delegates to the existing AgentLifecycleManager. In Phase 5 the Directive is shimmed into a Seed for the current pipeline; Phase 6 will replace this with lifecycle.execute_directive(&Directive, &ExecEnv).
5. For Scope::Substantial we call [IntentEngine::review] and, if the verdict fails, retry once with the verdict’s gaps folded back into the directive as additional constraints.

Does not modify or call the legacy handle_message() / chat() paths — they remain the canonical entry points until Phase 6 cuts the gateway over to handle().

Parameters

• engine — the LLM-backed intent engine (assess/crystallize/review).
• msg — the user’s raw message text.
• ctx — per-message context (session, history, project/mount hints).

pub async fn handle_unified( &self, user_id: &str, msg: &str, session_id: Option<&str>, project_ids: Option<&str>, mount_ids: Option<&str>, request_id: &str, ) -> Result<OrchestrationResult>

Unified entry point that accepts legacy-style parameters and returns an OrchestrationResult (RFC-027).

Builds a [MsgCtx] from the session history (if any), then delegates to handle. Falls back to handle_message if no IntentEngine is wired.