Struct Trace 

pub struct Trace {

    pub id: String,
    pub kind: TraceKind,
    pub content: String,
    pub tags: Vec<String>,
    pub created_at_ms: u64,
    pub deadline_ms: Option<u64>,
    pub salience: f32,
    pub confidence: f32,
    pub privacy: PrivacyClass,
    pub provenance: Provenance,
    pub claim_key: Option<String>,
    pub claim_value: Option<String>,
    pub supersedes: Option<String>,
    pub prediction: Option<PredictionRecord>,
    pub outcome: Option<OutcomeRecord>,
}

Fields

id: String

kind: TraceKind

content: String

tags: Vec<String>

created_at_ms: u64

deadline_ms: Option<u64>

salience: f32

confidence: f32

privacy: PrivacyClass

provenance: Provenance

claim_key: Option<String>

claim_value: Option<String>

supersedes: Option<String>

prediction: Option<PredictionRecord>

Structured payload of a Prediction trace (typed decision port).

outcome: Option<OutcomeRecord>

Structured payload of an Outcome trace that resolves a prediction.

Implementations

impl Trace

pub fn new( kind: TraceKind, content: impl Into<String>, source: impl Into<String>, ) -> Self

Examples found in repository

examples/retrieval_bench.rs (line 73)

fn make_trace(id: &str, content: &str, source: &str, kind: TraceKind) -> Trace {
    let mut t = Trace::new(kind, content, source);
    t.id = id.into();
    t.created_at_ms = CLOCK;
    t.provenance.observed_at_ms = CLOCK;
    t.provenance.locator = Some(format!("{source}:{id}"));
    t
}

examples/bench_kernel.rs (lines 97-101)

fn trace(i: usize) -> Trace {
    let mut t = Trace::new(
        TraceKind::Observation,
        format!("{} deployment observation", token(i)),
        "synthetic-kernel-benchmark",
    );
    t.id = format!("sample-{i}");
    t.created_at_ms = CLOCK;
    t.provenance.observed_at_ms = CLOCK;
    t
}

pub fn is_model_authored(&self) -> bool

True when a decision engine, not a person or tool, wrote this trace.

pub fn is_from_agent_session(&self) -> bool

True when the trace was written from a detected AI agent session (see crate::principal). source stays whatever the caller claimed.

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

Examples found in repository

examples/retrieval_bench.rs (line 167)

fn retrieve(corpus: &Path, queries: &Path, dir: &Path, dataset: &str, k: usize) -> Result<()> {
    if !(1..=100).contains(&k) || dataset.trim().is_empty() {
        return Err("k must be 1..100 and dataset must be nonempty".into());
    }
    let policy = KernelPolicy {
        recall_limit: k,
        ..KernelPolicy::default()
    };
    let path = fresh(dir)?;
    let source = format!("beir:{dataset}");
    let mut store = MemoryStore::open(&path, policy.clone())?;
    let mut baseline = Bm25::default();
    let mut ids = HashSet::new();
    let mut rejected = Vec::new();
    let mut batch = Vec::new();
    let mut baseline_index_ms = 0.0;
    let ingest = Instant::now();
    for line in BufReader::new(File::open(corpus)?).lines() {
        let doc: Document = serde_json::from_str(&line?)?;
        if doc.id.trim().is_empty() || !ids.insert(doc.id.clone()) {
            return Err("empty or duplicate document id".into());
        }
        let trace = make_trace(&doc.id, &doc.content, &source, TraceKind::Observation);
        if let Err(reason) = trace.validate() {
            rejected.push(json!({"id": doc.id, "reason": reason.to_string()}));
            continue;
        }
        let timer = Instant::now();
        baseline.add(&doc);
        baseline_index_ms += ms(timer);
        batch.push(trace);
        if batch.len() == 1000 {
            store.remember_many(std::mem::take(&mut batch))?;
        }
    }
    if !batch.is_empty() {
        store.remember_many(batch)?;
    }
    let ingest_ms = ms(ingest);
    store.verify()?;
    let head_before = serde_json::to_value(store.head())?;
    drop(store);
    let start = Instant::now();
    let store = MemoryStore::open_existing(&path, policy)?;
    let reopen_ms = ms(start);
    store.verify()?;
    let provenance_retained = store
        .all()
        .filter(|entry| {
            let t = &entry.trace;
            t.provenance.source == source
                && !t.provenance.verified
                && t.created_at_ms == CLOCK
                && t.provenance.observed_at_ms == CLOCK
                && t.provenance.locator.as_deref() == Some(format!("{source}:{}", t.id).as_str())
        })
        .count();
    if store.record_count() != baseline.ids.len()
        || provenance_retained != baseline.ids.len()
        || serde_json::to_value(store.head())? != head_before
    {
        return Err("replay, head or provenance invariant failed".into());
    }
    emit(
        json!({"kind": "loaded", "corpus_total": ids.len(), "admitted": baseline.ids.len(),
        "rejected": rejected, "provenance_retained": provenance_retained,
        "ingest_both_ms": ingest_ms, "bm25_index_ms": baseline_index_ms, "reopen_ms": reopen_ms,
        "policy": store.policy(), "bm25": {"k1": 1.2, "b": 0.75}, "query_clock_ms": CLOCK}),
    )?;
    let mut query_ids = HashSet::new();
    for line in BufReader::new(File::open(queries)?).lines() {
        let q: Query = serde_json::from_str(&line?)?;
        if q.id.trim().is_empty() || !query_ids.insert(q.id.clone()) {
            return Err("invalid query id".into());
        }
        let mut query = RecallQuery::new(&q.text);
        query.now_ms = CLOCK;
        query.limit = k;
        let start = Instant::now();
        let recalled = store.recall(&query);
        let hikmah_ms = ms(start);
        let start = Instant::now();
        let bm25 = baseline.search(&q.text, k);
        let bm25_ms = ms(start);
        let hikmah: Vec<_> = recalled.into_iter().map(|r| json!({
            "id": r.trace.id, "score": r.score, "duplicates_folded": r.duplicates,
            "provenance_source": r.trace.provenance.source, "verified": r.trace.provenance.verified,
        })).collect();
        emit(
            json!({"kind": "query", "id": q.id, "hikmah": hikmah, "bm25": bm25,
                    "hikmah_ms": hikmah_ms, "bm25_ms": bm25_ms}),
        )?;
    }
    emit(json!({"kind": "finished", "queries": query_ids.len()}))
}

Trait Implementations

impl Clone for Trace

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Trace

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Trace

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Trace

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for Trace

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Trace