lash-core is the runtime kernel: it owns the mechanisms that must be uniform for every host, protocol, process runtime, store, and tool. Everything else enters through named extension contracts.
A type belongs in the kernel only when core must understand its semantics to enforce runtime mechanism: turn effects, durable commits, process leases, handle grants, plugin dispatch, tool execution, provider calls, or store consistency. Runtime policy, prompt language, product resources, and protocol-specific meaning live outside the kernel.
lash-core depends on lash-sansio and runtime support crates. It does not depend on lashlang, lash-lashlang-runtime, or lash-protocol-rlm. RLM and Lashlang are integration runtimes installed around core.
ProcessInput::ToolCall, ProcessInput::SessionTurn, and ProcessInput::External are kernel primitives because core must orchestrate tool calls, child-session turns, and externally completed work directly. New process runtimes use ProcessInput::Engine { kind, payload } plus a registered ProcessEngine unless core must enforce a new mechanism.
Core owns HostTurnProtocol, the sans-IO state type, and the singleton ProtocolDriverPlugin slot. Standard and RLM are protocol plugins that fill that slot; they are not kernel primitives and they do not require protocol-specific code in the turn loop.
These are the stable kernel-facing seams. Add integration behavior by implementing one of these contracts, not by reaching into session/runtime internals.
| Contract | Implemented by | Kernel responsibility |
|---|---|---|
Provider, ProviderFactory, ProviderHandle | Provider crates and hosts | Resolve a live model provider and execute normalized LlmRequests behind a stable runtime handle. |
ToolProvider | Tool crates, plugins, hosts | Advertise callable tools, resolve contracts, prepare calls, and execute them through core's tool-dispatch and effect boundaries. |
PluginFactory, SessionPlugin, PluginRegistrar | Protocol plugins, tool plugins, host plugins | Install lifecycle hooks, prompt/catalog contributions, session state, tools, projections, and plugin RPCs without exposing mutable runtime internals. |
ProtocolSessionPlugin, ProtocolDriverPlugin, ProtocolDriverHandle<HostTurnProtocol> | lash-protocol-standard, lash-protocol-rlm, custom protocols | Build a per-turn preamble and interpret provider output through the sans-IO machine. Core owns the slot and lifecycle; protocol crates own mode-specific prompts, state, and output parsing. |
ProcessEngine | lash-lashlang-runtime, custom process runtimes | Run opaque ProcessInput::Engine payloads under the generic process registry, lease, cancellation, environment, and event machinery. |
EffectHost, RuntimeEffectController, ScopedEffectController | Inline runtime, lash-restate, workflow adapters | Execute nondeterministic work with typed invocation metadata and replay keys while the turn machine remains deterministic. |
RuntimePersistence, SessionStoreFactory | SQLite, Postgres, host stores | Persist committed session graph state, final turn stamps, checkpoints, pending turn input, queued work, and the fenced session execution lane. |
ProcessRegistry, TriggerStore | SQLite, Postgres, host stores | Persist process records/events/leases/handle grants and source-keyed trigger subscriptions/deliveries. |
AttachmentStore | File, S3-compatible, host stores | Persist or serve attachment bytes while the graph stores refs and metadata. |
ToolResultProjector, ToolCatalogContributor | Plugin crates | Project model-facing tool results and contribute tool-catalog entries through explicit exclusive or additive plugin hooks. |
The following are intentionally not kernel concepts even when first-party crates provide them.
lash-protocol-rlm owns the protocol prompt, driver state, projected bindings, and RLM control tools. lash-lashlang-runtime owns Lashlang surface construction, artifact storage, foreground execution bridge, and the kind == "lashlang" process engine.
Tool manifests are generic by default. First-party tool crates can opt into lashlang feature metadata, but ordinary default builds do not depend on the Lashlang runtime.
lash-remote-protocol is a neutral service-boundary crate. Its bindings map stores arbitrary metadata; it does not import Lashlang constants or derive generic tool identity from a Lashlang call path.