Struct Orchestrator 

pub struct Orchestrator { /* private fields */ }

The orchestrator coordinates the unified intent lifecycle (RFC-027).

Implementations

impl Orchestrator

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

Creates a new orchestrator.

pub fn with_config( 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.

RFC-027: the in-memory interview session map is no longer used. Clarify state is restored from the session store’s conversation history on demand by handle_unified. This function is a no-op.

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.