ijima-core 0.2.1

Core schema, stores, error types, and API contract for the Ijima centralized agentic memory backend
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112

// Copyright (C) 2026 Industrial Algebra
// SPDX-License-Identifier: Apache-2.0

//! Typed identifiers for the agentic harnesses that connect to Ijima.
//!
//! Every memory and session is tagged with its originating harness so
//! that provenance is preserved end-to-end. Using an exhaustive enum
//! rather than a raw `&str` lets the compiler flag callers when a new
//! harness is added.

/// The set of harnesses known to write to or read from Ijima.
///
/// This is intentionally exhaustive: adding a harness is a one-line
/// change that the compiler propagates to every `match` site.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum Harness {
    /// Dominic — meta-orchestrator.
    Dominic,
    /// Wallace — multi-user TUI.
    Wallace,
    /// Sakamoto — pipeline coding.
    Sakamoto,
    /// Tsume — gateway adapter (Discord, etc.).
    Tsume,
    /// pi — deep-work coding sessions.
    Pi,
    /// opencode — coding CLI.
    Opencode,
    /// Proserpina — critique pipeline (future).
    Proserpina,
    /// Any other harness not yet promoted to a dedicated variant.
    Other,
}

impl Harness {
    /// Returns the lowercase wire string used in stored records and the
    /// HTTP API. Stable across releases; do not rename without a
    /// migration.
    pub fn as_wire_str(&self) -> &'static str {
        match self {
            Harness::Dominic => "dominic",
            Harness::Wallace => "wallace",
            Harness::Sakamoto => "sakamoto",
            Harness::Tsume => "tsume",
            Harness::Pi => "pi",
            Harness::Opencode => "opencode",
            Harness::Proserpina => "proserpina",
            Harness::Other => "other",
        }
    }

    /// Parses a wire string back into a [`Harness`]. Unknown strings
    /// map to [`Harness::Other`] so records from a future harness don't
    /// break deserialization.
    pub fn from_wire_str(s: &str) -> Self {
        match s {
            "dominic" => Harness::Dominic,
            "wallace" => Harness::Wallace,
            "sakamoto" => Harness::Sakamoto,
            "tsume" => Harness::Tsume,
            "pi" => Harness::Pi,
            "opencode" => Harness::Opencode,
            "proserpina" => Harness::Proserpina,
            _ => Harness::Other,
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn wire_strings_are_stable_and_lowercase() {
        assert_eq!(Harness::Pi.as_wire_str(), "pi");
        assert_eq!(Harness::Tsume.as_wire_str(), "tsume");
        for h in [
            Harness::Dominic,
            Harness::Wallace,
            Harness::Sakamoto,
            Harness::Tsume,
            Harness::Pi,
            Harness::Opencode,
            Harness::Proserpina,
            Harness::Other,
        ] {
            let s = h.as_wire_str();
            assert!(
                s == s.to_ascii_lowercase(),
                "wire string for {h:?} must be lowercase"
            );
        }
    }

    #[test]
    fn from_wire_str_round_trips_known_harnesses() {
        for h in [
            Harness::Dominic,
            Harness::Wallace,
            Harness::Sakamoto,
            Harness::Tsume,
            Harness::Pi,
            Harness::Opencode,
            Harness::Proserpina,
        ] {
            assert_eq!(Harness::from_wire_str(h.as_wire_str()), h);
        }
        // Unknown strings fall back to Other (forward-compat).
        assert_eq!(Harness::from_wire_str("future-harness"), Harness::Other);
    }
}