Struct ReferenceSubstrate 

pub struct ReferenceSubstrate { /* private fields */ }

Implementations

impl ReferenceSubstrate

pub fn new() -> Self

pub fn set_mock_embedder(&mut self)

Install a deterministic MOCK embedder: a hashed bag of words over a small synonym table, so “record the vendor name” and “write down the supplier’s name” land close and “record the amount” does not. It exists so the T1 near-duplicate leg can be exercised with no model; it is not a semantic embedder and must never leave the test kit.

pub fn set_plan_replay(&mut self, report: Value)

Pretend the runtime rehearsed every plan revision and reported this (SubstrateRead::plan_replay). The reference substrate has no runtime, so a test of the replay gate hands it the report.

pub fn set_capabilities(&mut self, caps: Capabilities)

pub fn register_fork(&mut self, entity: &str, heads: &[&str])

Register a fork (turns on the forks capability).

pub fn set_telemetry(&mut self, view: TelemetryView)

Inject a telemetry snapshot (turns on the telemetry capability).

pub fn insert(&mut self, record: GrainRecord) -> String

Insert a fully-formed grain record; returns its assigned hash.

Trait Implementations

impl Default for ReferenceSubstrate

fn default() -> Self

Returns the “default value” for a type.

impl OmsSubstrate for ReferenceSubstrate

fn definition_inverse(&self, statement: &str) -> Result<Option<String>>

The statement restoring the CURRENT definition, or a DROP when there is none — so an apply can always record an inverse and a ROLLBACK always undoes something.

fn put_grain(&mut self, spec: &GrainSpec) -> Result<String>

Append a new grain; returns its content address.

fn supersede( &mut self, target_hash: &str, spec: &GrainSpec, _justification: &str, ) -> Result<String>

Supersede target_hash with a new grain carrying justification; returns the new grain’s address. Atomic and distinct from put (OMS §28.4).

fn retract(&mut self, hash: &str, reason: &str) -> Result<()>

Index-layer retraction (verification_status = retracted) — the inverse of an applied ADD, used by rollback. Not destructive (the grain stays content-addressed; only the index marks it retracted). The default reports it unsupported so substrates opt in.

fn execute_cal(&mut self, cal: &str) -> Result<Vec<Value>>

Execute CAL text, returning result rows as JSON. Used to regenerate evidence sets (evidence_query) and to apply proposal_cal. A substrate MAY reject CAL it cannot run with Error::CalUnsupported.

fn validate_cal(&self, cal: &str) -> Result<()>

Validate a CAL batch without executing it (statement classification, destructive-op detection). Delegated to the substrate — the engine contains a CAL writer, never a parser.

fn load_state(&self) -> Result<Value>

Load the persisted loop state blob (config + watermarks/cooldowns). Returns Value::Null when nothing has been stored yet.

fn store_state(&mut self, state: &Value) -> Result<()>

Persist the loop state blob (a file-truth, so it travels with the file on sync).

fn put_blob(&mut self, bytes: &[u8]) -> Result<String>

Store an opaque blob (candidate tool CODE, evalset payloads) in the substrate’s CAS, returning its address. §7.4’s blob seam — CAPABILITY-GATED: the default refuses, so a loop can only carry code on substrates that explicitly opt in. Code enters the substrate only through this seam or an authored add — never from a git mirror.

fn get_blob(&mut self, address: &str) -> Result<Vec<u8>>

Fetch a blob by the address put_blob returned. Same capability gate.

impl SubstrateRead for ReferenceSubstrate

fn validate_plan(&self, workflow: &Value) -> Result<()>

A MINIMAL plan check: every node named once, every edge between known nodes, at least one node. Deliberately weaker than the Areev adapter’s, which hands the body to the runtime’s own PlanGraph::build — this crate carries no Areev dependency, and the seam’s contract is “refuse a plan you cannot vouch for”, not “reimplement the scheduler”.

fn tool_evalset(&self, tool: &str) -> Result<Option<String>>

Rule E1’s pin, from the tool’s own live definition grain.

fn capabilities(&self) -> Capabilities

Declared optional capabilities.

fn embed(&self, text: &str) -> Result<Option<Vec<f32>>>

Embed one text through the substrate’s installed embedder — the T1 leg of “is this the same instruction in different words”. Ok(None) when no embedder is installed (the embeddings capability is off), so the caller falls back to a lexical measure rather than guessing. The default reports none; substrates opt in.

fn plan_replay( &self, _incumbent: &str, _candidate: &Value, ) -> Result<Option<Value>>

Rehearse a candidate Workflow body against the journaled runs of the live plan at incumbent_plan_hash — re-driven through the runtime’s pure scheduler with every effect answered from the journal, nothing dispatched, nothing written (areev run shadow --plan-file). The report is the runtime’s ShadowPlanReport as JSON; the engine reads totals.runs, no_worse, out_of_support_fraction and the per-run rows. Ok(None) when the substrate has no runtime or no journaled runs of that plan — the proposal is then simply unrehearsed, never refused for it. The default reports none.

fn grains_of_type( &self, grain_type: &str, namespace: Option<&str>, opts: ReadOpts, ) -> Result<Vec<GrainRecord>>

Curated read: all grains of one OMS type, optionally namespace-scoped and watermark/liveness filtered.

fn grain(&self, hash: &str) -> Result<Option<GrainRecord>>

Fetch one grain by content address.

fn heads(&self, _namespace: Option<&str>) -> Result<Vec<HeadGroup>>

Entities with more than one live head. Requires the forks capability; the default impl reports it missing so non-fork substrates degrade cleanly rather than pretend.

fn telemetry(&self, _namespace: Option<&str>) -> Result<Option<TelemetryView>>

A snapshot of the recall-telemetry rollups (§8). Requires the telemetry capability; the default returns None so substrates without a sidecar degrade cleanly. namespace scopes the snapshot when set.

fn address_of(&self, _spec: &GrainSpec) -> Result<Option<String>>

The content address put_grain(spec) WOULD assign, computed without writing — what lets a rehearsal name the exact grain a live pass would have stored. Ok(None) when the substrate cannot say (the default); a replay then reports findings by dedup key and summary.