Struct KernelHandle 

pub struct KernelHandle {

    pub state: StateApi,
    pub agents: AgentApi,
    pub security: SecurityApi,
    pub persona: PersonaApi,
    pub extensions: ExtensionApi,
    pub mcp: McpApi,
    pub infra: InfraApi,
    pub projects: Option<ProjectApi>,
    pub mounts: Option<MountApi>,
    pub exec: ExecApi,
    pub a2a: A2aApi,
    pub engine: EngineApi,
    pub knowledge: Arc<KnowledgeBase>,
    pub knowledge_lens: Arc<KnowledgeLens>,
    pub marketplace_api: MarketplaceApi,
    pub calendar: Option<CalendarApi>,
    pub email: Option<EmailApi>,
    pub readiness: Arc<ReadinessGate>,
}

Oxios kernel System Call API — composed of domain Facades.

Each Facade groups related system calls:

• StateApi — data persistence, sessions
• AgentApi — agent lifecycle, budgets, memory
• SecurityApi — auth, audit trail, RBAC, approvals
• PersonaApi — multi-persona management
• ExtensionApi — programs, skills, host tools
• McpApi — MCP server bridge
• MountApi — Mount (path alias) management (RFC-025)
• ProjectApi — Project management, memory linking
• ExecApi — execution config, access management
• A2aApi — agent-to-agent communication
• EngineApi — LLM engine providers, models, config
• [KnowledgeBase] — markdown note management (kernel-free, via oxios-markdown)

Fields

state: StateApi

State management: save/load/sessions.

agents: AgentApi

Agent management: lifecycle/budgets/memory.

security: SecurityApi

Security: auth/audit/RBAC/approvals.

persona: PersonaApi

Persona management.

extensions: ExtensionApi

Extensions: programs/skills/host tools.

mcp: McpApi

MCP server bridge.

infra: InfraApi

Infrastructure: Git/scheduler/cron/resources/events/system.

projects: Option<ProjectApi>

Project management: work context (RFC-011).

mounts: Option<MountApi>

Mount management: path aliases (RFC-025).

exec: ExecApi

Execution: config + access management.

a2a: A2aApi

Agent-to-agent communication.

engine: EngineApi

Engine: LLM providers, models, config.

knowledge: Arc<KnowledgeBase>

Knowledge base: markdown notes (direct access, no kernel dependency).

knowledge_lens: Arc<KnowledgeLens>

Semantic knowledge overlay (HNSW index + agent recall).

marketplace_api: MarketplaceApi

Marketplace API — ClawHub search, install, update.

calendar: Option<CalendarApi>

Calendar events — create, update, delete, list, search, freebusy.

email: Option<EmailApi>

Email — send HTML emails via SMTP, template management.

readiness: Arc<ReadinessGate>

RFC-024 SP4: subsystem readiness gate.

Implementations

impl KernelHandle

pub fn new( state: StateApi, agents: AgentApi, security: SecurityApi, persona: PersonaApi, extensions: ExtensionApi, mcp: McpApi, infra: InfraApi, projects: Option<ProjectApi>, exec: ExecApi, a2a: A2aApi, engine: EngineApi, knowledge: Arc<KnowledgeBase>, knowledge_lens: Arc<KnowledgeLens>, marketplace_api: MarketplaceApi, calendar: Option<CalendarApi>, email: Option<EmailApi>, ) -> Self

Create a new KernelHandle from 13 domain Facades.

Each Facade is assembled independently in kernel.rs and passed here. This enables testing individual Facades without the full kernel.

pub fn with_mounts(self, mounts: MountApi) -> Self

Attach a MountManager-backed API (RFC-025).

Called by the kernel assembler after SQLite initializes the MountManager. Leaves the Self::projects facade untouched so RFC-011 Projects continue to work during the migration.

pub fn set_mounts(&mut self, mounts: MountApi)

Set the Mounts facade in place (post-construction wiring).

pub async fn save_and_commit<T: Serialize>( &self, category: &str, name: &str, data: &T, ) -> Result<()>

Save data and commit to git (State + Infra).

The state save is the source of truth and is fully propagated. The git commit is best-effort observability: if it fails (full disk, lock contention, missing committer identity) we log a warning rather than failing the save — the data is already persisted on disk and failing here would mislead callers into thinking the save itself failed.

pub async fn save_markdown_and_commit( &self, category: &str, name: &str, content: &str, ) -> Result<()>

Save markdown and commit to git (State + Infra).

See Self::save_and_commit for the git-failure policy.

pub async fn delete_and_commit( &self, category: &str, name: &str, ) -> Result<bool>

Delete a file and commit the removal to git (State + Infra).

See Self::save_and_commit for the git-failure policy.

pub fn commit_all(&self, message: &str) -> Result<Option<CommitInfo>>

Commit all current changes to git.

pub fn flush_audit(&self) -> Result<()>

Flush audit trail and commit to git (Security + Infra).

pub async fn schedule( &self, cron_expr: &str, task: &str, persona: Option<&str>, ) -> Result<String>

Schedule a cron job by expression (convenience wrapper).

Note: the persona argument is currently NOT wired into the cron executor — CronJob has no persona field yet. Passing a non-default value logs a warning so callers are not silently surprised. The parameter is retained for forward compatibility with multi-persona scheduling (RFC tracking).

pub async fn unschedule(&self, job_id: &str) -> Result<bool>

Unschedule a cron job by string ID (convenience wrapper).

Returns Ok(true) when the job existed and was removed, Ok(false) when no job with that ID was registered, and Err(...) when the scheduler itself fails (DB corruption, lock poisoning). The previous implementation collapsed scheduler errors into Ok(false), hiding real failures from callers.

pub fn list_schedules(&self) -> Vec<CronJob>

pub async fn load_json<T: DeserializeOwned>( &self, category: &str, name: &str, ) -> Result<Option<T>>

Load JSON from state store.

pub fn start_time(&self) -> Instant

Get kernel start time.

pub fn marketplace_api(&self) -> &MarketplaceApi

Marketplace API — ClawHub search, install, update.

pub fn memory(&self) -> MemoryApi

Get a MemoryApi facade for memory operations.

Returns a fresh MemoryApi each call. It shares the same underlying Arc<MemoryManager> and Arc<HnswMemoryIndex> (when attached) as AgentApi, so semantic search and index rebuilds route through the real index rather than the keyword-only fallback.