Grand Diomande Research · Full HTML Reader

cc-inscription: N'Ko Inscription System

A system that compiles embodied dynamics (z-trajectory) into justified N'Ko statements with cryptographic provenance. Every inscription is traceable to its source evidence through a typed IR pipeline.

Language as Infrastructure research note experiment writeup candidate score 36 .md

Full Public Reader

cc-inscription: N'Ko Inscription System

[Overview](#overview)
[Design Philosophy](#design-philosophy)
[Architecture](#architecture)
[The Ten Claim Types](#the-ten-claim-types)
[Core Types](#core-types)
[Basin Lifecycle](#basin-lifecycle)
[Lexicon Versioning](#lexicon-versioning)
[Surface Rendering](#surface-rendering)
[Phrase Emergence](#phrase-emergence)
[Integration Points](#integration-points)
[API Reference](#api-reference)
[Examples](#examples)

---

Overview

The N'Ko Inscription System transforms continuous motion data (z-trajectory from DELL - Distributed Embodied Latent Learner) into discrete, justified claims expressed in N'Ko script. Each claim:

1. Has typed structure - A strongly-typed Intermediate Representation (IR)
2. Has a sigil - A single N'Ko character that identifies the claim type
3. Is traceable - Links back to the evidence that produced it
4. Is versioned - Rendered through a versioned lexicon

Why N'Ko?

N'Ko is a right-to-left African script with rich typographic potential. We use it as a controlled technical register where single characters (sigils) serve as operator markers. This keeps the system deterministic and learnable while opening the door to natural-language phrasing as the lexicon matures.

Line Skeleton

Every inscription follows this structure:

⟨operator-sigil⟩ ⟨time-marker⟩ : ⟨claim-body⟩ ; ⟨slots⟩

Example:

ߛ ⟦100.0–200.0⟧ : z(σ) ↓ ; ⟦home⟧ ; c=0.85

This reads: "Stabilization claim from t=100.0 to t=200.0, dispersion decreased, at place 'home', confidence 0.85"

---

Design Philosophy

Anticipation Over Prediction

The system does not predict what will happen; it detects when dynamics become constrained enough that a claim is warranted. This mirrors the anticipation principle from motion intelligence.

Non-Retroactive Corpus

Old inscriptions are never rewritten. When the lexicon evolves (basin splits, merges, renames), the original inscriptions remain untouched. Reinterpretation is a derived view, not a replacement.

Provenance Chain

Every claim maintains a chain of evidence:

z-trajectory → ClaimDetector → Typed IR → Lexicon → N'Ko Surface → Proof Scaffold

---

Architecture

┌─────────────────────────────────────────────────────────────────────┐
│                     INSCRIPTION PIPELINE                             │
├─────────────────────────────────────────────────────────────────────┤
│                                                                      │
│  z_{t-k:t}  ──┬──►  ClaimDetector  ──►  Typed IR  ──►  N'Ko Line    │
│              │           │                  │              │         │
│  place ──────┤     ┌─────▼─────┐      ┌────▼────┐    ┌────▼────┐    │
│              │     │ 10 Claim  │      │ Lexicon │    │ Surface │    │
│  slice_id ───┘     │ Detectors │      │ (vN)    │    │ Render  │    │
│                    └─────┬─────┘      └────┬────┘    └────┬────┘    │
│                          │                 │              │         │
│                    ┌─────▼─────────────────▼──────────────▼────┐    │
│                    │           PROVENANCE CHAIN                │    │
│                    │  Evidence → IR → Surface → Proof Scaffold │    │
│                    └───────────────────────────────────────────┘    │
└─────────────────────────────────────────────────────────────────────┘

Crate Structure

core/cc-inscription/
├── Cargo.toml
├── src/
│   ├── lib.rs                 # Main entry, re-exports
│   ├── claims/                # 10 typed claim IR structs
│   │   ├── mod.rs             # Claim enum + core types
│   │   ├── stabilize.rs       # ߛ Stabilization
│   │   ├── disperse.rs        # ߜ Dispersion
│   │   ├── transition.rs      # ߕ Transition
│   │   ├── return_.rs         # ߙ Return
│   │   ├── dwell.rs           # ߡ Dwell
│   │   ├── oscillate.rs       # ߚ Oscillation
│   │   ├── recover.rs         # ߞ Recovery
│   │   ├── novel.rs           # ߣ Novelty
│   │   ├── place_shift.rs     # ߠ Place-Shift
│   │   └── echo.rs            # ߥ Echo
│   ├── basin/                 # Basin lifecycle management
│   │   ├── mod.rs
│   │   ├── proto.rs           # Proto-basin (pre-graduation)
│   │   ├── graduation.rs      # Proto → Basin criteria
│   │   ├── lifecycle.rs       # Split/merge/retire
│   │   └── constitution.rs    # Basin invariants
│   ├── lexicon/               # Versioned lexicon
│   │   ├── mod.rs
│   │   ├── version.rs         # Lexicon versioning
│   │   ├── tokens.rs          # Basin/Place tokens
│   │   └── changelog.rs       # Change tracking
│   ├── surface/               # N'Ko rendering
│   │   ├── mod.rs
│   │   ├── renderer.rs        # Claim → N'Ko line
│   │   ├── grammar.rs         # Grammar skeletons
│   │   └── slots.rs           # Slot renderers
│   ├── phrase/                # Phrase emergence
│   │   ├── mod.rs
│   │   ├── detection.rs       # Sequence mining
│   │   ├── compression.rs     # Compression testing
│   │   └── registration.rs    # Phrase registry
│   ├── detector/              # Claim detection
│   │   ├── mod.rs             # Main detector
│   │   └── dynamics.rs        # z-trajectory metrics
│   └── integration/           # External system bridges
│       ├── mod.rs
│       ├── graph_kernel.rs    # Slice boundary enforcement
│       ├── rag.rs             # Evidence retrieval
│       └── dell.rs            # z-trajectory source
├── lexicons/
│   └── v1.0.json              # Initial lexicon
└── docs/
    ├── 00-PROJECT_CHARTER.md
    ├── 01-GLOSSARY.md
    ├── 02-INVARIANTS_LEDGER.md
    ├── 03-IMPLEMENTATION_GUIDE.md
    └── DESIGN.md

---

The Ten Claim Types

Each claim type has a unique N'Ko sigil, a typed IR structure, and a canonical surface form.

#	Name	Sigil	Unicode	What It Detects
1	Stabilization	ߛ	U+07DB	Dispersion decreased measurably
2	Dispersion	ߜ	U+07DC	Spread/entropy increased
3	Transition	ߕ	U+07D5	Discrete change point (curvature spike)
4	Return	ߙ	U+07D9	Re-entry to known basin
5	Dwell	ߡ	U+07E1	Sustained stay in basin
6	Oscillation	ߚ	U+07DA	Rapid alternation between basins
7	Recovery	ߞ	U+07DE	Latency to return after disruption
8	Novelty	ߣ	U+07E3	New basin discovery ("need a new word")
9	Place-Shift	ߠ	U+07E0	Location class change coupled to dynamics
10	Echo	ߥ	U+07E5	Pattern match to prior episode

Claim Details

1. Stabilization (ߛ)

Detects: Dispersion decreased measurably within a time window.

rust

pub struct StabilizeClaim {
    pub id: ClaimId,
    pub window: TimeWindow,
    pub dims: Vec<usize>,           // Which dimensions contracted
    pub metric: DispersionMetric,   // Variance or Speed
    pub delta: f64,                 // Negative (contraction amount)
    pub magnitude: f64,
    pub confidence: Confidence,
    pub place: PlaceClass,
}

Canonical N'Ko: `ߛ ⟦t0–t1⟧ : z(σ) ↓ ; ⟦place⟧ ; c=⟦conf⟧`

2. Dispersion (ߜ)

Detects: Spread/entropy increased within a time window.

rust

pub struct DisperseClaim {
    pub id: ClaimId,
    pub window: TimeWindow,
    pub metric: EntropyMetric,      // Variance or Entropy
    pub delta: f64,                 // Positive (expansion amount)
    pub magnitude: f64,
    pub confidence: Confidence,
    pub place: PlaceClass,
}

Canonical N'Ko: `ߜ ⟦t0–t1⟧ : z(σ) ↑ ; ⟦place⟧ ; c=⟦conf⟧`

3. Transition (ߕ)

Detects: Curvature spike + state delta at a discrete instant.

rust

pub struct TransitionClaim {
    pub id: ClaimId,
    pub t_star: f64,                // The instant
    pub from_basin: Option<BasinId>,
    pub to_basin: Option<BasinId>,
    pub sharpness: f64,             // Curvature magnitude
    pub confidence: Confidence,
    pub place_from: Option<PlaceClass>,
    pub place_to: Option<PlaceClass>,
}

Canonical N'Ko: `ߕ ⟦t*⟧ : ⟦B_from⟧ → ⟦B_to⟧ ; κ=⟦sharp⟧ ; c=⟦conf⟧`

4. Return (ߙ)

Detects: Re-entry to a previously known basin.

rust

pub struct ReturnClaim {
    pub id: ClaimId,
    pub t_star: f64,
    pub basin: BasinId,
    pub last_seen: f64,             // Timestamp of previous visit
    pub distance: f64,              // How far traveled before return
    pub confidence: Confidence,
}

Canonical N'Ko: `ߙ ⟦t*⟧ : ↺ ⟦B⟧ ; last=⟦Δt⟧ ; d=⟦dist⟧`

5. Dwell (ߡ)

Detects: Sustained stay in a basin long enough to matter.

rust

pub struct DwellClaim {
    pub id: ClaimId,
    pub window: TimeWindow,
    pub basin: BasinId,
    pub dwell_time: f64,            // Seconds
    pub stability: f64,             // Internal dispersion metric
    pub confidence: Confidence,
}

Canonical N'Ko: `ߡ ⟦t0–t1⟧ : stay(⟦B⟧)=⟦τ⟧ ; ϕ=⟦stab⟧`

6. Oscillation (ߚ)

Detects: Rapid alternation (ping-pong) between basins.

rust

pub struct OscillateClaim {
    pub id: ClaimId,
    pub window: TimeWindow,
    pub basins: Vec<BasinId>,       // Typically [B1, B2]
    pub frequency: f64,             // Crossings per unit time
    pub amplitude: f64,             // Average excursion distance
    pub confidence: Confidence,
}

Canonical N'Ko: `ߚ ⟦t0–t1⟧ : ⟦B1⟧ ⇄ ⟦B2⟧ ; f=⟦freq⟧ ; a=⟦amp⟧`

7. Recovery (ߞ)

Detects: Latency to return to target basin after disruption.

rust

pub struct RecoverClaim {
    pub id: ClaimId,
    pub event_t: f64,               // Disruption timestamp
    pub target_basin: BasinId,
    pub latency: f64,               // Seconds to return
    pub baseline: f64,              // Typical latency for comparison
    pub ratio: f64,                 // latency / baseline
    pub confidence: Confidence,
}

Canonical N'Ko: `ߞ ⟦t*⟧ : rec→⟦B⟧ ; τ=⟦lat⟧ (×⟦ratio⟧)`

8. Novelty (ߣ)

Detects: Region not covered by existing basin tokens ("need a new word").

rust

pub struct NovelClaim {
    pub id: ClaimId,
    pub t_star: f64,
    pub proto_id: ProtoBasinId,     // Provisional identifier
    pub distance_to_nearest: f64,   // How far from known basins
    pub support_k: usize,           // Number of samples in region
    pub confidence: Confidence,
}

Canonical N'Ko: `ߣ ⟦t⟧ : new⟦P⟧ ; d=⟦dist⟧ ; k=⟦support⟧`

9. Place-Shift (ߠ)

Detects: Location class change coupled with another claim type.

rust

pub struct PlaceShiftClaim {
    pub id: ClaimId,
    pub t_star: f64,
    pub from: PlaceClass,
    pub to: PlaceClass,
    pub coupled_claim: CoupledClaimType,  // Transition, Disperse, or Stabilize
    pub confidence: Confidence,
}

Canonical N'Ko: `ߠ ⟦t*⟧ : ⟦P_from⟧ → ⟦P_to⟧ ; ↪ ⟦claim_sigil⟧ ; c=⟦conf⟧`

10. Echo (ߥ)

Detects: Pattern match to prior episode ("I've seen this movie").

rust

pub struct EchoClaim {
    pub id: ClaimId,
    pub window: TimeWindow,
    pub match_set: Vec<NodeId>,     // From current slice only
    pub similarity: f64,
    pub outcome_tag: Option<Symbol>,
    pub confidence: Confidence,
}

Canonical N'Ko: `ߥ ⟦t0–t1⟧ : ≈ ⟦E#⟧ ; sim=⟦s⟧ ; refs=⟦n⟧`

---

Core Types

BasinId

Kernel-level primary key that survives renaming. A 16-byte UUID.

rust

pub struct BasinId(pub [u8; 16]);

impl BasinId {
    pub fn mint() -> Self;           // Create new random ID
    pub fn to_hex(&self) -> String;  // Full hex representation
    pub fn short_hex(&self) -> String; // First 8 chars
}

PlaceClass

Coarse categorical location (not GPS coordinates).

rust

pub struct PlaceClass(pub String);

impl PlaceClass {
    pub fn new(name: impl Into<String>) -> Self;
}

Examples: "home", "office", "gym", "transit"

TimeWindow

Time interval [t0, t1] in seconds since epoch.

rust

pub struct TimeWindow {
    pub t0: f64,
    pub t1: f64,
}

impl TimeWindow {
    pub fn duration(&self) -> f64;
    pub fn midpoint(&self) -> f64;
    pub fn contains(&self, t: f64) -> bool;
}

Confidence

Score in [0, 1] indicating claim certainty.

rust

pub struct Confidence(pub f32);

impl Confidence {
    pub fn new(value: f32) -> Self;  // Clamped to [0, 1]
    pub fn value(&self) -> f32;
    pub fn is_high(&self) -> bool;   // >= 0.7
    pub fn is_low(&self) -> bool;    // < 0.3
}

Claim Enum

Unified enum for all 10 claim types:

rust

pub enum Claim {
    Stabilize(StabilizeClaim),
    Disperse(DisperseClaim),
    Transition(TransitionClaim),
    Return(ReturnClaim),
    Dwell(DwellClaim),
    Oscillate(OscillateClaim),
    Recover(RecoverClaim),
    Novel(NovelClaim),
    PlaceShift(PlaceShiftClaim),
    Echo(EchoClaim),
}

impl Claim {
    pub fn sigil(&self) -> char;
    pub fn claim_type(&self) -> ClaimType;
    pub fn id(&self) -> ClaimId;
    pub fn confidence(&self) -> Confidence;
    pub fn time_range(&self) -> (f64, f64);
    pub fn time_window(&self) -> Option<TimeWindow>;
    pub fn instant(&self) -> Option<f64>;
    pub fn place(&self) -> Option<&PlaceClass>;
}

---

Basin Lifecycle

Basins are hypotheses the machine bets its consistency on. Each basin has an origin, stability phase, possible refinement, and eventual persistence or retirement.

Basin States

┌──────────────┐     graduation      ┌──────────────┐
│  ProtoBasin  │ ─────────────────►  │    Basin     │
│  (scratch)   │     criteria met    │  (identity)  │
└──────────────┘                     └──────┬───────┘
       │                                    │
       │ expires                            ├─── split ──► [Child₁, Child₂]
       ▼                                    │
┌──────────────┐                            ├─── merge ──► Parent
│   Retired    │ ◄──────────────────────────┤
│  (spurious)  │      retirement            │
└──────────────┘                            ▼
                                    ┌──────────────┐
                                    │   Retired    │
                                    │ (real-gone)  │
                                    └──────────────┘

Graduation Criteria

A proto-basin becomes a basin when it earns three independent persistence signals:

rust

pub struct GraduationCriteria {
    /// 1. Re-entry across separate sessions (minimum 3)
    pub min_return_sessions: usize,

    /// 2. Low internal dispersion vs global (max 0.3 ratio)
    pub max_internal_dispersion_ratio: f64,

    /// 3. Repeatable transition signature (min 0.7 consistency)
    pub transition_consistency_threshold: f64,
}

Split Rules

A split occurs when the distribution is demonstrably multi-modal in a way that predicts different downstream dynamics. Two subclusters that look different but lead to the same transition behavior = ornamental complexity, refuse split.

Merge Rules

A merge occurs when two basin keys become empirically indistinguishable within measurement resolution. Reasons include:
- Sensor coverage changed
- Stopped visiting separating contexts
- Behavior actually converged

Retirement Types

rust

pub enum RetirementType {
    /// Never real: proto-basin never graduated
    Spurious { proto_id, reason },

    /// Real but gone: attractor vanished
    RealButGone { basin_id, last_visit, total_dwells },

    /// Coordinate system changed
    CoordinateShift { basin_id, old_version, new_version },
}

Deprecation markers: `⊘ₛ` (spurious), `⊘ᵣ` (real-gone), `⊘ᵥ` (coordinate-shift)

---

Lexicon Versioning

Core Principle

No retroactive rewriting. Old inscriptions remain untouched. Reinterpretation is an optional derived view.

What Evolves vs What's Stable

Component	Stability	Can Change When
Operator sigils (ߛ, ߜ, ߕ...)	LOCKED	Breaking change only
Grammar skeletons	STABLE	Rarely, requires migration
Basin tokens	EVOLVING	Split/merge/naturalization
Place-class tokens	EVOLVING	New places discovered
Connective tissue	EVOLVING	Naturalization as N'Ko improves

Lexicon Structure

rust

pub struct Lexicon {
    pub version: LexiconVersion,
    pub operator_sigils: OperatorSigilTable,
    pub basin_tokens: HashMap<BasinId, BasinToken>,
    pub place_tokens: HashMap<PlaceClass, PlaceToken>,
    pub claim_grammars: HashMap<ClaimType, GrammarSkeleton>,
    pub content_hash: [u8; 32],
    pub parent_version: Option<LexiconVersion>,
    pub changelog: Vec<LexiconChange>,
}

Changelog Types

rust

pub enum LexiconChange {
    BasinAdded { id, token },
    BasinRenamed { id, old_token, new_token },
    BasinSplit { parent, children },
    BasinMerged { absorbed, into },
    BasinRetired { id, retirement },
    PlaceClassAdded { class, token },
    PhraseRegistered { phrase_id, pattern },
}

---

Surface Rendering

The `SurfaceRenderer` converts typed IR claims into N'Ko surface form.

Grammar Skeletons

Each claim type has a fixed grammar skeleton:

rust

pub struct GrammarSkeleton {
    pub sigil: char,
    pub time_format: TimeFormat,      // Window or Instant
    pub body_template: String,
    pub slots: Vec<String>,
}

Rendering Pipeline

rust

let lexicon = Arc::new(Lexicon::v1());
let renderer = SurfaceRenderer::new(lexicon);

let claim = StabilizeClaim::new(
    TimeWindow::new(100.0, 200.0),
    vec![0, 1],
    DispersionMetric::Variance,
    -0.5,
    0.5,
    Confidence::new(0.85),
    PlaceClass::new("home"),
);

let line = renderer.render(&Claim::Stabilize(claim));
// Output: ߛ ⟦100.0–200.0⟧ : z(σ) ↓ ; home ; c=0.85

NKoLine

rust

pub struct NKoLine {
    pub text: String,
    pub claim_id: ClaimId,
    pub lexicon_version: LexiconVersion,
}

---

Phrase Emergence

The system discovers recurrent sequences of claims that behave like phrases.

Phrase Structure

rust

pub struct Phrase {
    pub id: PhraseId,
    pub pattern: Vec<ClaimPattern>,   // Sequence of claim types + constraints
    pub frequency: usize,             // How often this sequence occurs
    pub compression_ratio: f64,       // How much it shortens description
    pub predictive_gain: f64,         // Does using this improve prediction?
    pub nko_idiom: Option<String>,    // Compact surface form once earned
}

Example: "Arrival Turbulence"

A common pattern: PlaceShift → Disperse → Oscillate

Old (3 lines):

ߠ ⟦t*⟧ : home → office ; ↪ ߕ ; c=0.8
ߜ ⟦t0–t1⟧ : z(σ) ↑ ; office ; c=0.7
ߚ ⟦t1–t2⟧ : B1 ⇄ B2 ; f=3.2 ; a=0.4

New (1 line with phrase reference):

⟨arrival-turbulence⟩ ⟦t*–t2⟧ : home→office ; B1⇄B2

Detection Criteria

A phrase is registered only when:
1. It occurs frequently (configurable threshold)
2. It reduces description length (compression ratio > 1)
3. It improves prediction (predictive gain > 0)

---

Integration Points

Graph Kernel

Provides slice boundary enforcement and admissibility tokens.

rust

pub struct GraphKernelClient {
    base_url: String,
}

impl GraphKernelClient {
    pub async fn verify_token(&self, [sensitive field redacted]) -> Result<bool, GraphKernelError>;
    pub async fn request_slice(&self, anchor_turn_id: &str, policy_id: &str)
        -> Result<AdmissibleEvidenceBundle, GraphKernelError>;
}

RAG++

Provides evidence retrieval for Echo claims.

rust

pub struct RagClient {
    base_url: String,
}

impl RagClient {
    pub async fn query_similar(&self, query_embedding: &[f32], slice_id: &SliceFingerprint, limit: usize)
        -> Result<Vec<RetrievedEvidence>, RagError>;
    pub async fn embed_trajectory(&self, trajectory: &[Vec<f32>])
        -> Result<Vec<f32>, RagError>;
}

DELL

Provides z-trajectory source data.

rust

pub struct DellClient {
    base_url: String,
}

impl DellClient {
    pub async fn subscribe(&self, buffer_size: usize) -> Result<DellSubscription, DellError>;
    pub async fn get_history(&self, start_t: f64, end_t: f64) -> Result<Vec<DellFrame>, DellError>;
    pub async fn get_current_place(&self) -> Result<Option<PlaceClass>, DellError>;
}

---

API Reference

Main Exports

rust

// Claims
pub use claims::{
    Claim, ClaimId, ClaimType,
    StabilizeClaim, DisperseClaim, TransitionClaim, ReturnClaim,
    DwellClaim, OscillateClaim, RecoverClaim, NovelClaim,
    PlaceShiftClaim, EchoClaim,
    BasinId, ProtoBasinId, PlaceClass, TimeWindow, Confidence,
    DispersionMetric, EntropyMetric, CoupledClaimType, NodeId, Symbol,
};

// Basin lifecycle
pub use basin::{Basin, ProtoBasin, GraduationCriteria, RetirementType};

// Lexicon
pub use lexicon::{Lexicon, LexiconVersion, BasinToken, PlaceToken};

// Surface rendering
pub use surface::{SurfaceRenderer, NKoLine};

Claim Detection

rust

use cc_inscription::detector::{ClaimDetector, DetectorConfig, ZSample};

let mut detector = ClaimDetector::new(DetectorConfig::default());

// Register known basins
detector.register_basin(basin_id, centroid);

// Detect claims from trajectory window
let samples: Vec<ZSample> = /* ... */;
let claims = detector.detect(&samples);

---

Examples

Basic Usage

rust

use cc_inscription::{
    Claim, StabilizeClaim, TimeWindow, Confidence, PlaceClass,
    DispersionMetric, Lexicon, SurfaceRenderer,
};
use std::sync::Arc;

// Create a stabilization claim
let claim = StabilizeClaim::new(
    TimeWindow::new(100.0, 200.0),
    vec![0, 1, 2],           // Dimensions that contracted
    DispersionMetric::Variance,
    -0.5,                    // Delta (negative = contraction)
    0.5,                     // Magnitude
    Confidence::new(0.85),
    PlaceClass::new("home"),
);

// Render to N'Ko
let lexicon = Arc::new(Lexicon::v1());
let renderer = SurfaceRenderer::new(lexicon);
let line = renderer.render(&Claim::Stabilize(claim));

println!("{}", line.text);
// Output: ߛ ⟦100.0–200.0⟧ : z(σ) ↓ ; home ; c=0.85

Claim Detection Pipeline

rust

use cc_inscription::detector::{ClaimDetector, DetectorConfig, ZSample};
use cc_inscription::PlaceClass;

// Configure detector
let config = DetectorConfig {
    min_confidence: 0.6,
    dispersion_window: 10.0,
    curvature_threshold: 0.5,
    min_dwell_time: 5.0,
    oscillation_threshold: 0.2,
    novelty_threshold: 3.0,
};

let mut detector = ClaimDetector::new(config);

// Create trajectory samples
let samples: Vec<ZSample> = (0..100)
    .map(|i| ZSample {
        t: i as f64 * 0.1,
        z: vec![0.1 * (i as f32).sin(), 0.2 * (i as f32).cos()],
        place: Some(PlaceClass::new("home")),
    })
    .collect();

// Detect claims
let claims = detector.detect(&samples);

for claim in claims {
    println!("Detected: {} at {:?}", claim.sigil(), claim.time_range());
}

Basin Lifecycle

rust

use cc_inscription::basin::{ProtoBasin, GraduationCriteria};
use cc_inscription::ProtoBasinId;

// Create proto-basin
let proto_id = ProtoBasinId::mint();
let mut proto = ProtoBasin::new(proto_id.clone());

// Record observations
proto.add_sample(vec![0.1, 0.2, 0.3], 100.0);
proto.record_return("session-001");
proto.record_return("session-002");
proto.record_return("session-003");

// Check graduation
let criteria = GraduationCriteria::default();
if proto.ready_to_graduate(&criteria) {
    let basin = proto.graduate();
    println!("Basin {} graduated!", basin.id.short_hex());
}

---

Testing

Run all tests:

bash

cargo test

Run specific test module:

bash

cargo test claims::stabilize
cargo test detector::dynamics
cargo test surface::renderer

License

MIT

---

Promotion Decision

Attach run IDs, datasets, metrics, and reproduction commands.

Source Anchor

Comp-Core/core/semantic/cc-inscription/README.md

Detected Structure

Method · Evaluation · Figures · Code Anchors · Architecture

Full Public Reader

cc-inscription: N'Ko Inscription System

Table of Contents

Overview

Why N'Ko?

Line Skeleton

Design Philosophy

Anticipation Over Prediction

Non-Retroactive Corpus

Provenance Chain

Architecture

Crate Structure

The Ten Claim Types

Claim Details

1. Stabilization (ߛ)

2. Dispersion (ߜ)

3. Transition (ߕ)

4. Return (ߙ)

5. Dwell (ߡ)

6. Oscillation (ߚ)

7. Recovery (ߞ)

8. Novelty (ߣ)

9. Place-Shift (ߠ)

10. Echo (ߥ)

Core Types

BasinId

PlaceClass

TimeWindow

Confidence

Claim Enum

Basin Lifecycle

Basin States

Graduation Criteria

Split Rules

Merge Rules

Retirement Types

Lexicon Versioning

Core Principle

What Evolves vs What's Stable

Lexicon Structure

Changelog Types

Surface Rendering

Grammar Skeletons

Rendering Pipeline

NKoLine

Phrase Emergence

Phrase Structure

Example: "Arrival Turbulence"

Detection Criteria

Integration Points

Graph Kernel

RAG++

DELL

API Reference

Main Exports

Claim Detection

Examples

Basic Usage

Claim Detection Pipeline

Basin Lifecycle

Testing

License

Related Documentation

Promotion Decision

Source Anchor

Detected Structure