Enum Cmd 

pub enum Cmd {
    Build {
        force: bool,
    },
    Store {
        text: String,
        layer: String,
        importance: u8,
    },
    Recall {
        query: String,
        k: usize,
    },
    Look {
        x: f32,
        y: f32,
        z: f32,
        zoom: u8,
        k: usize,
    },
    Radial {
        x: f32,
        y: f32,
        z: f32,
        depth: u8,
        radius: f32,
        k: usize,
    },
    Soft {
        x: f32,
        y: f32,
        z: f32,
        zoom: u8,
        k: usize,
        gpu: bool,
    },
    Bench,
    Stats,
    Find {
        query: String,
        k: usize,
    },
    Fingerprint,
    Links {
        block_index: usize,
    },
    Similar {
        text: String,
        k: usize,
    },
    Rebuild,
    Embed {
        query: String,
        k: usize,
        metric: String,
    },
    GpuBench,
    Verify,
    VerifyMerkle,
    Proof {
        block_index: usize,
    },
    Think {
        query: String,
        max_steps: usize,
    },
    Spine,
    Query {
        mql: String,
    },
    Export {
        output: String,
    },
    Import {
        input: String,
        output_dir: Option<String>,
    },
    Diff {
        a: String,
        b: String,
    },
    FederatedRecall {
        query: String,
        k: usize,
    },
    PulseExchange,
    FederatedFind {
        query: String,
        k: usize,
    },
    Hebbian,
    HebbianDrift,
    Hottest {
        k: usize,
    },
    Archetypes,
    Emerge,
    Resonance,
    Integrate,
    Mirror,
    Resonant {
        k: usize,
    },
    Viz {
        output: String,
    },
    Density {
        output: String,
        grid: u16,
    },
    Patterns {
        k: usize,
    },
    Paths {
        sessions: usize,
    },
    Predictions,
    TemporalPatterns,
    Attention,
    PatternExchange,
    Dream,
    DreamLog {
        k: usize,
    },
    EmotionalField,
    EmotionalExchange,
    Modalities,
    CognitiveMap {
        output: String,
    },
    StoreData {
        pairs: Vec<String>,
        importance: u8,
    },
    InitDemo {
        force: bool,
    },
    Serve {
        port: u16,
    },
}

Variants

Build

Build binary from raw layer files

Fields

force: bool

Store

Store a new memory

Fields

text: String

layer: String

importance: u8

Recall

Recall — natural language query, auto-zoom

Fields

query: String

k: usize

Look

Manual look: x y z zoom [k]

Fields

x: f32

y: f32

z: f32

zoom: u8

k: usize

Radial

Radial search: find blocks within radius at a depth

Fields

x: f32

y: f32

z: f32

depth: u8

radius: f32

k: usize

Soft

4D soft zoom: x y z zoom [k]

Fields

x: f32

y: f32

z: f32

zoom: u8

k: usize

gpu: bool

Use GPU acceleration (requires gpu feature)

Bench

Benchmark

Stats

Stats

Find

Text search

Fields

query: String

k: usize

Fingerprint

Build structural fingerprints and wormhole links

Links

Show structural links (wormholes) for a block

Fields

block_index: usize

Similar

Find structurally similar blocks to a text

Fields

text: String

k: usize

Rebuild

Rebuild — incorporate append log into main index

Embed

Semantic search using embeddings

Fields

query: String

k: usize

metric: String

GpuBench

GPU vs CPU benchmark (requires gpu feature)

Verify

Verify CRC16 integrity of all blocks

VerifyMerkle

Verify Merkle tree integrity of the entire index

Proof

Show Merkle proof for a specific block

Fields

block_index: usize

Think

Sequential Thinking — Chain-of-Thought memory sequence

Fields

query: String

max_steps: usize

Spine

Start the Binary Spine IPC listener (Zero JSON)

Query

MQL query (Microscope Query Language)

Fields

mql: String

MQL expression, e.g. ‘layer:long_term depth:2..5 “Ora”’

Export

Export index to .mscope archive

Fields

output: String

Output archive path

Import

Import .mscope archive

Fields

input: String

Input archive path

output_dir: Option<String>

Output directory (defaults to config output_dir)

Diff

Diff two .mscope archives

Fields

a: String

First archive

b: String

Second archive

FederatedRecall

Federated recall across multiple indices

Fields

query: String

k: usize

PulseExchange

Exchange resonance pulses across federated indices (mirror neuron protocol)

FederatedFind

Federated text search across multiple indices

Fields

query: String

k: usize

Hebbian

Show Hebbian learning state (activations, co-activations, energy)

HebbianDrift

Apply Hebbian drift — co-activated blocks pull coordinates closer

Hottest

Show hottest blocks (most recently/frequently activated)

Fields

k: usize

Archetypes

Show emerged archetypes (crystallized activation patterns)

Emerge

Detect new archetypes from resonance field and Hebbian state

Resonance

Show resonance protocol state (pulses, field energy)

Integrate

Integrate received pulses into local Hebbian state

Mirror

Show mirror neuron state (resonance echoes, boosted blocks)

Resonant

Show most resonant blocks (strongest mirror neuron signal)

Fields

k: usize

Viz

Export 3D visualization snapshot (Binary)

Fields

output: String

Output file path (default: viz.bin)

Density

Export binary density map for fast rendering

Fields

output: String

Output file path

grid: u16

Grid resolution (default: 32)

Patterns

Show thought patterns (crystallized recall sequences)

Fields

k: usize

Paths

Show recent thought paths (recall sequences by session)

Fields

sessions: usize

Predictions

Show predictive cache stats and active predictions

TemporalPatterns

Show temporal archetype patterns (time-of-day activation profiles)

Attention

Show attention mechanism state (layer weights, quality history)

PatternExchange

Exchange thought patterns across federated indices

Dream

Run dream consolidation (offline memory replay and pruning)

DreamLog

Show dream consolidation history

Fields

k: usize

EmotionalField

Show emotional contagion state (local + remote emotional fields)

EmotionalExchange

Exchange emotional snapshots across federated indices

Modalities

Show multimodal index statistics

CognitiveMap

Export full cognitive map (all 13 layers) as JSON for Three.js viewer

Fields

output: String

Output file path (default: cognitive_map.bin)

StoreData

Store structured data (key=value pairs)

Fields

pairs: Vec<String>

Key-value pairs: key1=val1 key2=val2

importance: u8

InitDemo

Initialize a demo dataset and configuration for quickstart

Fields

force: bool

Force overwrite existing layers/demo.txt

Serve

Start a local HTTP server for the 3D Viewer (viewer.html)

Fields

port: u16

Trait Implementations

impl FromArgMatches for Cmd

fn from_arg_matches(__clap_arg_matches: &ArgMatches) -> Result<Self, Error>

Instantiate Self from ArgMatches, parsing the arguments as needed.

fn from_arg_matches_mut( __clap_arg_matches: &mut ArgMatches, ) -> Result<Self, Error>

Instantiate Self from ArgMatches, parsing the arguments as needed.

fn update_from_arg_matches( &mut self, __clap_arg_matches: &ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

fn update_from_arg_matches_mut<'b>( &mut self, __clap_arg_matches: &mut ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

impl Subcommand for Cmd

fn augment_subcommands<'b>(__clap_app: Command) -> Command

Append to Command so it can instantiate Self via FromArgMatches::from_arg_matches_mut

fn augment_subcommands_for_update<'b>(__clap_app: Command) -> Command

Append to Command so it can instantiate self via FromArgMatches::update_from_arg_matches_mut

fn has_subcommand(__clap_name: &str) -> bool

Test whether Self can parse a specific subcommand